]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
format the list of installed packages better
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_buffer swig_types[14]
1356 #define SWIGTYPE_p_wxMenu swig_types[15]
1357 #define SWIGTYPE_p_wxGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxFlexGridSizer swig_types[17]
1359 #define SWIGTYPE_p_wxInitDialogEvent swig_types[18]
1360 #define SWIGTYPE_p_wxItemContainer swig_types[19]
1361 #define SWIGTYPE_p_wxNcPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxPaintEvent swig_types[21]
1363 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[25]
1367 #define SWIGTYPE_p_wxControl swig_types[26]
1368 #define SWIGTYPE_p_wxFont swig_types[27]
1369 #define SWIGTYPE_p_wxMenuBarBase swig_types[28]
1370 #define SWIGTYPE_p_wxSetCursorEvent swig_types[29]
1371 #define SWIGTYPE_p_wxFSFile swig_types[30]
1372 #define SWIGTYPE_p_wxCaret swig_types[31]
1373 #define SWIGTYPE_ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_std__ptrdiff_t swig_types[33]
1375 #define SWIGTYPE_p_wxRegion swig_types[34]
1376 #define SWIGTYPE_p_wxPoint2D swig_types[35]
1377 #define SWIGTYPE_p_int swig_types[36]
1378 #define SWIGTYPE_p_wxSize swig_types[37]
1379 #define SWIGTYPE_p_wxDC swig_types[38]
1380 #define SWIGTYPE_p_wxPySizer swig_types[39]
1381 #define SWIGTYPE_p_wxVisualAttributes swig_types[40]
1382 #define SWIGTYPE_p_wxNotifyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPyEvent swig_types[42]
1384 #define SWIGTYPE_p_wxPropagationDisabler swig_types[43]
1385 #define SWIGTYPE_p_form_ops_t swig_types[44]
1386 #define SWIGTYPE_p_wxAppTraits swig_types[45]
1387 #define SWIGTYPE_p_wxArrayString swig_types[46]
1388 #define SWIGTYPE_p_wxShowEvent swig_types[47]
1389 #define SWIGTYPE_p_wxToolTip swig_types[48]
1390 #define SWIGTYPE_p_wxMoveEvent swig_types[49]
1391 #define SWIGTYPE_p_wxSizeEvent swig_types[50]
1392 #define SWIGTYPE_p_wxActivateEvent swig_types[51]
1393 #define SWIGTYPE_p_wxIconizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxMaximizeEvent swig_types[53]
1395 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[54]
1396 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[55]
1397 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
1398 #define SWIGTYPE_p_wxDateEvent swig_types[57]
1399 #define SWIGTYPE_p_wxMenuItem swig_types[58]
1400 #define SWIGTYPE_p_wxStaticBox swig_types[59]
1401 #define SWIGTYPE_p_long swig_types[60]
1402 #define SWIGTYPE_p_wxDuplexMode swig_types[61]
1403 #define SWIGTYPE_p_wxTIFFHandler swig_types[62]
1404 #define SWIGTYPE_p_wxXPMHandler swig_types[63]
1405 #define SWIGTYPE_p_wxPNMHandler swig_types[64]
1406 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
1407 #define SWIGTYPE_p_wxPCXHandler swig_types[66]
1408 #define SWIGTYPE_p_wxGIFHandler swig_types[67]
1409 #define SWIGTYPE_p_wxPNGHandler swig_types[68]
1410 #define SWIGTYPE_p_wxANIHandler swig_types[69]
1411 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxZipFSHandler swig_types[71]
1413 #define SWIGTYPE_p_wxInternetFSHandler swig_types[72]
1414 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[73]
1415 #define SWIGTYPE_p_wxEvtHandler swig_types[74]
1416 #define SWIGTYPE_p_wxCURHandler swig_types[75]
1417 #define SWIGTYPE_p_wxICOHandler swig_types[76]
1418 #define SWIGTYPE_p_wxBMPHandler swig_types[77]
1419 #define SWIGTYPE_p_wxImageHandler swig_types[78]
1420 #define SWIGTYPE_p_wxFileSystemHandler swig_types[79]
1421 #define SWIGTYPE_p_wxRect swig_types[80]
1422 #define SWIGTYPE_p_wxButton swig_types[81]
1423 #define SWIGTYPE_p_wxGBSpan swig_types[82]
1424 #define SWIGTYPE_p_wxPropagateOnce swig_types[83]
1425 #define SWIGTYPE_p_wxAcceleratorTable swig_types[84]
1426 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[85]
1427 #define SWIGTYPE_p_char swig_types[86]
1428 #define SWIGTYPE_p_wxGBPosition swig_types[87]
1429 #define SWIGTYPE_p_wxImage swig_types[88]
1430 #define SWIGTYPE_p_wxFrame swig_types[89]
1431 #define SWIGTYPE_p_wxScrollWinEvent swig_types[90]
1432 #define SWIGTYPE_p_wxPaperSize swig_types[91]
1433 #define SWIGTYPE_p_wxImageHistogram swig_types[92]
1434 #define SWIGTYPE_p_wxPoint swig_types[93]
1435 #define SWIGTYPE_p_wxCursor swig_types[94]
1436 #define SWIGTYPE_p_wxObject swig_types[95]
1437 #define SWIGTYPE_p_wxInputStream swig_types[96]
1438 #define SWIGTYPE_p_wxOutputStream swig_types[97]
1439 #define SWIGTYPE_p_wxPyInputStream swig_types[98]
1440 #define SWIGTYPE_p_wxDateTime swig_types[99]
1441 #define SWIGTYPE_p_wxKeyEvent swig_types[100]
1442 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
1443 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[102]
1444 #define SWIGTYPE_p_unsigned_long swig_types[103]
1445 #define SWIGTYPE_p_wxWindow swig_types[104]
1446 #define SWIGTYPE_p_wxMenuBar swig_types[105]
1447 #define SWIGTYPE_p_wxFileSystem swig_types[106]
1448 #define SWIGTYPE_p_wxBitmap swig_types[107]
1449 #define SWIGTYPE_unsigned_int swig_types[108]
1450 #define SWIGTYPE_p_unsigned_int swig_types[109]
1451 #define SWIGTYPE_p_wxMenuEvent swig_types[110]
1452 #define SWIGTYPE_p_wxContextMenuEvent swig_types[111]
1453 #define SWIGTYPE_p_unsigned_char swig_types[112]
1454 #define SWIGTYPE_p_wxEraseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxMouseEvent swig_types[114]
1456 #define SWIGTYPE_p_wxCloseEvent swig_types[115]
1457 #define SWIGTYPE_p_wxPyApp swig_types[116]
1458 #define SWIGTYPE_p_wxCommandEvent swig_types[117]
1459 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
1460 #define SWIGTYPE_p_wxPyDropTarget swig_types[119]
1461 #define SWIGTYPE_p_wxQuantize swig_types[120]
1462 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1463 #define SWIGTYPE_p_wxChildFocusEvent swig_types[122]
1464 #define SWIGTYPE_p_wxDropFilesEvent swig_types[123]
1465 #define SWIGTYPE_p_wxControlWithItems swig_types[124]
1466 #define SWIGTYPE_p_wxColour swig_types[125]
1467 #define SWIGTYPE_p_wxValidator swig_types[126]
1468 #define SWIGTYPE_p_wxPyValidator swig_types[127]
1469 static swig_type_info *swig_types[129];
1470
1471 /* -------- TYPES TABLE (END) -------- */
1472
1473
1474 /*-----------------------------------------------
1475 @(target):= _core_.so
1476 ------------------------------------------------*/
1477 #define SWIG_init init_core_
1478
1479 #define SWIG_name "_core_"
1480
1481 #include "wx/wxPython/wxPython_int.h"
1482 #include "wx/wxPython/pyclasses.h"
1483
1484
1485 #ifndef wxPyUSE_EXPORT
1486 // Helper functions for dealing with SWIG objects and such. These are
1487 // located here so they know about the SWIG types and functions declared
1488 // in the wrapper code.
1489
1490 #include <wx/hashmap.h>
1491 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1492
1493
1494 // Maintains a hashmap of className to swig_type_info pointers. Given the
1495 // name of a class either looks up the type info in the cache, or scans the
1496 // SWIG tables for it.
1497 extern PyObject* wxPyPtrTypeMap;
1498 static
1499 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1500
1501 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1502
1503 if (typeInfoCache == NULL)
1504 typeInfoCache = new wxPyTypeInfoHashMap;
1505
1506 wxString name(className);
1507 swig_type_info* swigType = (*typeInfoCache)[name];
1508
1509 if (! swigType) {
1510 // it wasn't in the cache, so look it up from SWIG
1511 name.Append(wxT(" *"));
1512 swigType = SWIG_TypeQuery(name.mb_str());
1513
1514 // if it still wasn't found, try looking for a mapped name
1515 if (!swigType) {
1516 PyObject* item;
1517 name = className;
1518
1519 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1520 (char*)(const char*)name.mbc_str())) != NULL) {
1521 name = wxString(PyString_AsString(item), *wxConvCurrent);
1522 name.Append(wxT(" *"));
1523 swigType = SWIG_TypeQuery(name.mb_str());
1524 }
1525 }
1526 if (swigType) {
1527 // and add it to the map if found
1528 (*typeInfoCache)[className] = swigType;
1529 }
1530 }
1531 return swigType;
1532 }
1533
1534
1535 // Check if a class name is a type known to SWIG
1536 bool wxPyCheckSwigType(const wxChar* className) {
1537
1538 swig_type_info* swigType = wxPyFindSwigType(className);
1539 return swigType != NULL;
1540 }
1541
1542
1543 // Given a pointer to a C++ object and a class name, construct a Python proxy
1544 // object for it.
1545 PyObject* wxPyConstructObject(void* ptr,
1546 const wxChar* className,
1547 int setThisOwn) {
1548
1549 swig_type_info* swigType = wxPyFindSwigType(className);
1550 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1551
1552 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1553 }
1554
1555
1556 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1557 // Ensures that the proxy object is of the specified (or derived) type. If
1558 // not able to perform the conversion then a Python exception is set and the
1559 // error should be handled properly in the caller. Returns True on success.
1560 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1561 const wxChar* className) {
1562
1563 swig_type_info* swigType = wxPyFindSwigType(className);
1564 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1565
1566 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1567 }
1568
1569
1570 // Make a SWIGified pointer object suitable for a .this attribute
1571 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1572
1573 PyObject* robj = NULL;
1574
1575 swig_type_info* swigType = wxPyFindSwigType(className);
1576 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1577
1578 #ifdef SWIG_COBJECT_TYPES
1579 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1580 #else
1581 {
1582 char result[1024];
1583 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1584 PyString_FromString(result) : 0;
1585 }
1586 #endif
1587
1588 return robj;
1589 }
1590
1591
1592
1593
1594 // Export a C API in a struct. Other modules will be able to load this from
1595 // the wx._core_ module and will then have safe access to these functions,
1596 // even if they are located in another shared library.
1597 static wxPyCoreAPI API = {
1598
1599 wxPyCheckSwigType,
1600 wxPyConstructObject,
1601 wxPyConvertSwigPtr,
1602 wxPyMakeSwigPtr,
1603
1604 wxPyBeginAllowThreads,
1605 wxPyEndAllowThreads,
1606 wxPyBeginBlockThreads,
1607 wxPyEndBlockThreads,
1608
1609 wxPy_ConvertList,
1610
1611 wxString_in_helper,
1612 Py2wxString,
1613 wx2PyString,
1614
1615 byte_LIST_helper,
1616 int_LIST_helper,
1617 long_LIST_helper,
1618 string_LIST_helper,
1619 wxPoint_LIST_helper,
1620 wxBitmap_LIST_helper,
1621 wxString_LIST_helper,
1622 wxAcceleratorEntry_LIST_helper,
1623
1624 wxSize_helper,
1625 wxPoint_helper,
1626 wxRealPoint_helper,
1627 wxRect_helper,
1628 wxColour_helper,
1629 wxPoint2D_helper,
1630
1631 wxPySimple_typecheck,
1632 wxColour_typecheck,
1633
1634 wxPyCBH_setCallbackInfo,
1635 wxPyCBH_findCallback,
1636 wxPyCBH_callCallback,
1637 wxPyCBH_callCallbackObj,
1638 wxPyCBH_delete,
1639
1640 wxPyMake_wxObject,
1641 wxPyMake_wxSizer,
1642 wxPyPtrTypeMap_Add,
1643 wxPy2int_seq_helper,
1644 wxPy4int_seq_helper,
1645 wxArrayString2PyList_helper,
1646 wxArrayInt2PyList_helper,
1647
1648 wxPyClientData_dtor,
1649 wxPyUserData_dtor,
1650 wxPyOORClientData_dtor,
1651
1652 wxPyCBInputStream_create,
1653 wxPyCBInputStream_copy,
1654
1655 wxPyInstance_Check,
1656 wxPySwigInstance_Check,
1657
1658 wxPyCheckForApp
1659
1660 };
1661
1662 #endif
1663
1664
1665 #if !WXWIN_COMPATIBILITY_2_4
1666 #define wxHIDE_READONLY 0
1667 #endif
1668
1669
1670 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1671 #define SWIG_From_int PyInt_FromLong
1672 /*@@*/
1673
1674
1675 #if ! wxUSE_HOTKEY
1676 enum wxHotkeyModifier
1677 {
1678 wxMOD_NONE = 0,
1679 wxMOD_ALT = 1,
1680 wxMOD_CONTROL = 2,
1681 wxMOD_SHIFT = 4,
1682 wxMOD_WIN = 8
1683 };
1684 #define wxEVT_HOTKEY 9999
1685 #endif
1686
1687 static const wxString wxPyEmptyString(wxEmptyString);
1688 static wxString wxObject_GetClassName(wxObject *self){
1689 return self->GetClassInfo()->GetClassName();
1690 }
1691 static void wxObject_Destroy(wxObject *self){
1692 delete self;
1693 }
1694
1695 #ifndef __WXMAC__
1696 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1697 #endif
1698
1699
1700 #include <limits.h>
1701
1702
1703 SWIGINTERN int
1704 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1705 const char *errmsg)
1706 {
1707 if (value < min_value) {
1708 if (errmsg) {
1709 PyErr_Format(PyExc_OverflowError,
1710 "value %ld is less than '%s' minimum %ld",
1711 value, errmsg, min_value);
1712 }
1713 return 0;
1714 } else if (value > max_value) {
1715 if (errmsg) {
1716 PyErr_Format(PyExc_OverflowError,
1717 "value %ld is greater than '%s' maximum %ld",
1718 value, errmsg, max_value);
1719 }
1720 return 0;
1721 }
1722 return 1;
1723 }
1724
1725
1726 SWIGINTERN int
1727 SWIG_AsVal_long(PyObject* obj, long* val)
1728 {
1729 if (PyNumber_Check(obj)) {
1730 if (val) *val = PyInt_AsLong(obj);
1731 return 1;
1732 }
1733 else {
1734 SWIG_type_error("number", obj);
1735 }
1736 return 0;
1737 }
1738
1739
1740 #if INT_MAX != LONG_MAX
1741 SWIGINTERN int
1742 SWIG_AsVal_int(PyObject *obj, int *val)
1743 {
1744 const char* errmsg = val ? "int" : (char*)0;
1745 long v;
1746 if (SWIG_AsVal_long(obj, &v)) {
1747 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1748 if (val) *val = (int)(v);
1749 return 1;
1750 } else {
1751 return 0;
1752 }
1753 } else {
1754 PyErr_Clear();
1755 }
1756 if (val) {
1757 SWIG_type_error(errmsg, obj);
1758 }
1759 return 0;
1760 }
1761 #else
1762 SWIGINTERNSHORT int
1763 SWIG_AsVal_int(PyObject *obj, int *val)
1764 {
1765 return SWIG_AsVal_long(obj,(long*)val);
1766 }
1767 #endif
1768
1769
1770 SWIGINTERNSHORT int
1771 SWIG_As_int(PyObject* obj)
1772 {
1773 int v;
1774 if (!SWIG_AsVal_int(obj, &v)) {
1775 /*
1776 this is needed to make valgrind/purify happier.
1777 */
1778 memset((void*)&v, 0, sizeof(int));
1779 }
1780 return v;
1781 }
1782
1783
1784 SWIGINTERNSHORT int
1785 SWIG_Check_int(PyObject* obj)
1786 {
1787 return SWIG_AsVal_int(obj, (int*)0);
1788 }
1789
1790 static PyObject *wxSize_Get(wxSize *self){
1791 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1792 PyObject* tup = PyTuple_New(2);
1793 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1794 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1795 wxPyEndBlockThreads(blocked);
1796 return tup;
1797 }
1798
1799 SWIGINTERN int
1800 SWIG_AsVal_double(PyObject *obj, double* val)
1801 {
1802 if (PyNumber_Check(obj)) {
1803 if (val) *val = PyFloat_AsDouble(obj);
1804 return 1;
1805 }
1806 else {
1807 SWIG_type_error("number", obj);
1808 }
1809 return 0;
1810 }
1811
1812
1813 SWIGINTERNSHORT double
1814 SWIG_As_double(PyObject* obj)
1815 {
1816 double v;
1817 if (!SWIG_AsVal_double(obj, &v)) {
1818 /*
1819 this is needed to make valgrind/purify happier.
1820 */
1821 memset((void*)&v, 0, sizeof(double));
1822 }
1823 return v;
1824 }
1825
1826
1827 SWIGINTERNSHORT int
1828 SWIG_Check_double(PyObject* obj)
1829 {
1830 return SWIG_AsVal_double(obj, (double*)0);
1831 }
1832
1833
1834 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1835 #define SWIG_From_double PyFloat_FromDouble
1836 /*@@*/
1837
1838 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1839 self->x = x;
1840 self->y = y;
1841 }
1842 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1843 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1844 PyObject* tup = PyTuple_New(2);
1845 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1846 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1847 wxPyEndBlockThreads(blocked);
1848 return tup;
1849 }
1850
1851 SWIGINTERNSHORT long
1852 SWIG_As_long(PyObject* obj)
1853 {
1854 long v;
1855 if (!SWIG_AsVal_long(obj, &v)) {
1856 /*
1857 this is needed to make valgrind/purify happier.
1858 */
1859 memset((void*)&v, 0, sizeof(long));
1860 }
1861 return v;
1862 }
1863
1864
1865 SWIGINTERNSHORT int
1866 SWIG_Check_long(PyObject* obj)
1867 {
1868 return SWIG_AsVal_long(obj, (long*)0);
1869 }
1870
1871 static void wxPoint_Set(wxPoint *self,long x,long y){
1872 self->x = x;
1873 self->y = y;
1874 }
1875 static PyObject *wxPoint_Get(wxPoint *self){
1876 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1877 PyObject* tup = PyTuple_New(2);
1878 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1879 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1880 wxPyEndBlockThreads(blocked);
1881 return tup;
1882 }
1883 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1884 self->x = x;
1885 self->y = y;
1886 self->width = width;
1887 self->height = height;
1888 }
1889 static PyObject *wxRect_Get(wxRect *self){
1890 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1891 PyObject* tup = PyTuple_New(4);
1892 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1893 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1894 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1895 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1896 wxPyEndBlockThreads(blocked);
1897 return tup;
1898 }
1899
1900 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1901 wxRegion reg1(*r1);
1902 wxRegion reg2(*r2);
1903 wxRect dest(0,0,0,0);
1904 PyObject* obj;
1905
1906 reg1.Intersect(reg2);
1907 dest = reg1.GetBox();
1908
1909 if (dest != wxRect(0,0,0,0)) {
1910 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1911 wxRect* newRect = new wxRect(dest);
1912 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1913 wxPyEndBlockThreads(blocked);
1914 return obj;
1915 }
1916 Py_INCREF(Py_None);
1917 return Py_None;
1918 }
1919
1920
1921 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1922 PyObject* o2;
1923 PyObject* o3;
1924
1925 if (!target) {
1926 target = o;
1927 } else if (target == Py_None) {
1928 Py_DECREF(Py_None);
1929 target = o;
1930 } else {
1931 if (!PyTuple_Check(target)) {
1932 o2 = target;
1933 target = PyTuple_New(1);
1934 PyTuple_SetItem(target, 0, o2);
1935 }
1936 o3 = PyTuple_New(1);
1937 PyTuple_SetItem(o3, 0, o);
1938
1939 o2 = target;
1940 target = PySequence_Concat(o2, o3);
1941 Py_DECREF(o2);
1942 Py_DECREF(o3);
1943 }
1944 return target;
1945 }
1946
1947
1948 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1949 self->m_x = x;
1950 self->m_y = y;
1951 }
1952 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1953 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1954 PyObject* tup = PyTuple_New(2);
1955 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1956 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1957 wxPyEndBlockThreads(blocked);
1958 return tup;
1959 }
1960
1961 #include "wx/wxPython/pyistream.h"
1962
1963 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1964 wxInputStream* wxis = wxPyCBInputStream::create(p);
1965 if (wxis)
1966 return new wxPyInputStream(wxis);
1967 else
1968 return NULL;
1969 }
1970
1971 SWIGINTERNSHORT PyObject*
1972 SWIG_From_char(char c)
1973 {
1974 return PyString_FromStringAndSize(&c,1);
1975 }
1976
1977
1978 SWIGINTERNSHORT PyObject*
1979 SWIG_From_unsigned_SS_long(unsigned long value)
1980 {
1981 return (value > LONG_MAX) ?
1982 PyLong_FromUnsignedLong(value)
1983 : PyInt_FromLong((long)(value));
1984 }
1985
1986
1987 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1988 SWIGINTERN int
1989 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1990 {
1991 static swig_type_info* pchar_info = 0;
1992 char* vptr = 0;
1993 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1994 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1995 if (cptr) *cptr = vptr;
1996 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1997 return SWIG_OLDOBJ;
1998 } else {
1999 PyErr_Clear();
2000 if (PyString_Check(obj)) {
2001 if (cptr) {
2002 *cptr = PyString_AS_STRING(obj);
2003 if (psize) {
2004 *psize = PyString_GET_SIZE(obj) + 1;
2005 }
2006 }
2007 return SWIG_PYSTR;
2008 }
2009 }
2010 if (cptr) {
2011 SWIG_type_error("char *", obj);
2012 }
2013 return 0;
2014 }
2015
2016
2017 SWIGINTERN int
2018 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2019 {
2020 char* cptr; size_t csize;
2021 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2022 /* in C you can do:
2023
2024 char x[5] = "hello";
2025
2026 ie, assing the array using an extra '0' char.
2027 */
2028 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2029 if (csize <= size) {
2030 if (val) {
2031 if (csize) memcpy(val, cptr, csize);
2032 if (csize < size) memset(val + csize, 0, size - csize);
2033 }
2034 return 1;
2035 }
2036 }
2037 if (val) {
2038 PyErr_Format(PyExc_TypeError,
2039 "a char array of maximum size %lu is expected",
2040 (unsigned long) size);
2041 }
2042 return 0;
2043 }
2044
2045
2046 SWIGINTERN int
2047 SWIG_AsVal_char(PyObject *obj, char *val)
2048 {
2049 const char* errmsg = val ? "char" : (char*)0;
2050 long v;
2051 if (SWIG_AsVal_long(obj, &v)) {
2052 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2053 if (val) *val = (char)(v);
2054 return 1;
2055 } else {
2056 return 0;
2057 }
2058 } else {
2059 PyErr_Clear();
2060 return SWIG_AsCharArray(obj, val, 1);
2061 }
2062 }
2063
2064
2065 SWIGINTERNSHORT char
2066 SWIG_As_char(PyObject* obj)
2067 {
2068 char v;
2069 if (!SWIG_AsVal_char(obj, &v)) {
2070 /*
2071 this is needed to make valgrind/purify happier.
2072 */
2073 memset((void*)&v, 0, sizeof(char));
2074 }
2075 return v;
2076 }
2077
2078
2079 SWIGINTERNSHORT int
2080 SWIG_Check_char(PyObject* obj)
2081 {
2082 return SWIG_AsVal_char(obj, (char*)0);
2083 }
2084
2085
2086 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2087 #define SWIG_From_long PyInt_FromLong
2088 /*@@*/
2089
2090 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2091 // We use only strings for the streams, not unicode
2092 PyObject* str = PyObject_Str(obj);
2093 if (! str) {
2094 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2095 return;
2096 }
2097 self->Write(PyString_AS_STRING(str),
2098 PyString_GET_SIZE(str));
2099 Py_DECREF(str);
2100 }
2101
2102 #include "wx/wxPython/pyistream.h"
2103
2104
2105 class wxPyFileSystemHandler : public wxFileSystemHandler
2106 {
2107 public:
2108 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2109
2110 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2111 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2112 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2113 DEC_PYCALLBACK_STRING__pure(FindNext);
2114
2115 wxString GetProtocol(const wxString& location) {
2116 return wxFileSystemHandler::GetProtocol(location);
2117 }
2118
2119 wxString GetLeftLocation(const wxString& location) {
2120 return wxFileSystemHandler::GetLeftLocation(location);
2121 }
2122
2123 wxString GetAnchor(const wxString& location) {
2124 return wxFileSystemHandler::GetAnchor(location);
2125 }
2126
2127 wxString GetRightLocation(const wxString& location) {
2128 return wxFileSystemHandler::GetRightLocation(location);
2129 }
2130
2131 wxString GetMimeTypeFromExt(const wxString& location) {
2132 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2133 }
2134
2135 PYPRIVATE;
2136 };
2137
2138
2139 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2140 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2141 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2142 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2143
2144
2145 SWIGINTERN int
2146 SWIG_AsVal_bool(PyObject *obj, bool *val)
2147 {
2148 if (obj == Py_True) {
2149 if (val) *val = true;
2150 return 1;
2151 }
2152 if (obj == Py_False) {
2153 if (val) *val = false;
2154 return 1;
2155 }
2156 int res = 0;
2157 if (SWIG_AsVal_int(obj, &res)) {
2158 if (val) *val = res ? true : false;
2159 return 1;
2160 } else {
2161 PyErr_Clear();
2162 }
2163 if (val) {
2164 SWIG_type_error("bool", obj);
2165 }
2166 return 0;
2167 }
2168
2169
2170 SWIGINTERNSHORT bool
2171 SWIG_As_bool(PyObject* obj)
2172 {
2173 bool v;
2174 if (!SWIG_AsVal_bool(obj, &v)) {
2175 /*
2176 this is needed to make valgrind/purify happier.
2177 */
2178 memset((void*)&v, 0, sizeof(bool));
2179 }
2180 return v;
2181 }
2182
2183
2184 SWIGINTERNSHORT int
2185 SWIG_Check_bool(PyObject* obj)
2186 {
2187 return SWIG_AsVal_bool(obj, (bool*)0);
2188 }
2189
2190 static wxString FileSystem_URLToFileName(wxString const &url){
2191 wxFileName fname = wxFileSystem::URLToFileName(url);
2192 return fname.GetFullPath();
2193 }
2194
2195 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2196 wxImage& image,
2197 long type) {
2198 wxMemoryFSHandler::AddFile(filename, image, type);
2199 }
2200
2201 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2202 const wxBitmap& bitmap,
2203 long type) {
2204 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2205 }
2206
2207 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2208 PyObject* data) {
2209 if (! PyString_Check(data)) {
2210 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2211 "Expected string object"));
2212 return;
2213 }
2214
2215 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2216 void* ptr = (void*)PyString_AsString(data);
2217 size_t size = PyString_Size(data);
2218 wxPyEndBlockThreads(blocked);
2219
2220 wxMemoryFSHandler::AddFile(filename, ptr, size);
2221 }
2222
2223
2224 #include "wx/wxPython/pyistream.h"
2225
2226
2227 SWIGINTERN int
2228 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2229 {
2230 long v = 0;
2231 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2232 SWIG_type_error("unsigned number", obj);
2233 }
2234 else if (val)
2235 *val = (unsigned long)v;
2236 return 1;
2237 }
2238
2239
2240 SWIGINTERNSHORT int
2241 SWIG_CheckUnsignedLongInRange(unsigned long value,
2242 unsigned long max_value,
2243 const char *errmsg)
2244 {
2245 if (value > max_value) {
2246 if (errmsg) {
2247 PyErr_Format(PyExc_OverflowError,
2248 "value %lu is greater than '%s' minimum %lu",
2249 value, errmsg, max_value);
2250 }
2251 return 0;
2252 }
2253 return 1;
2254 }
2255
2256
2257 SWIGINTERN int
2258 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2259 {
2260 const char* errmsg = val ? "unsigned char" : (char*)0;
2261 unsigned long v;
2262 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2263 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2264 if (val) *val = (unsigned char)(v);
2265 return 1;
2266 } else {
2267 return 0;
2268 }
2269 } else {
2270 PyErr_Clear();
2271 }
2272 if (val) {
2273 SWIG_type_error(errmsg, obj);
2274 }
2275 return 0;
2276 }
2277
2278
2279 SWIGINTERNSHORT unsigned char
2280 SWIG_As_unsigned_SS_char(PyObject* obj)
2281 {
2282 unsigned char v;
2283 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2284 /*
2285 this is needed to make valgrind/purify happier.
2286 */
2287 memset((void*)&v, 0, sizeof(unsigned char));
2288 }
2289 return v;
2290 }
2291
2292
2293 SWIGINTERNSHORT int
2294 SWIG_Check_unsigned_SS_char(PyObject* obj)
2295 {
2296 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2297 }
2298
2299
2300 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2301 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2302 /*@@*/
2303
2304
2305
2306 SWIGINTERNSHORT unsigned long
2307 SWIG_As_unsigned_SS_long(PyObject* obj)
2308 {
2309 unsigned long v;
2310 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2311 /*
2312 this is needed to make valgrind/purify happier.
2313 */
2314 memset((void*)&v, 0, sizeof(unsigned long));
2315 }
2316 return v;
2317 }
2318
2319
2320 SWIGINTERNSHORT int
2321 SWIG_Check_unsigned_SS_long(PyObject* obj)
2322 {
2323 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2324 }
2325
2326 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2327 wxImageHistogramEntry e = (*self)[key];
2328 return e.value;
2329 }
2330 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,unsigned char r,unsigned char g,unsigned char b){
2331 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2332 wxImageHistogramEntry e = (*self)[key];
2333 return e.value;
2334 }
2335 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2336 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2337 colour.Green(),
2338 colour.Blue());
2339 wxImageHistogramEntry e = (*self)[key];
2340 return e.value;
2341 }
2342
2343 typedef unsigned char* buffer;
2344
2345 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2346 if (width > 0 && height > 0)
2347 return new wxImage(width, height, clear);
2348 else
2349 return new wxImage;
2350 }
2351 static wxImage *new_wxImage(wxBitmap const &bitmap){
2352 return new wxImage(bitmap.ConvertToImage());
2353 }
2354 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2355 if (DATASIZE != width*height*3) {
2356 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2357 return NULL;
2358 }
2359
2360 // Copy the source data so the wxImage can clean it up later
2361 buffer copy = (buffer)malloc(DATASIZE);
2362 if (copy == NULL) {
2363 wxPyBLOCK_THREADS(PyErr_NoMemory());
2364 return NULL;
2365 }
2366 memcpy(copy, data, DATASIZE);
2367 return new wxImage(width, height, copy, false);
2368 }
2369 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2370 if (DATASIZE != width*height*3) {
2371 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2372 return NULL;
2373 }
2374 if (ALPHASIZE != width*height) {
2375 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2376 return NULL;
2377 }
2378
2379 // Copy the source data so the wxImage can clean it up later
2380 buffer dcopy = (buffer)malloc(DATASIZE);
2381 if (dcopy == NULL) {
2382 wxPyBLOCK_THREADS(PyErr_NoMemory());
2383 return NULL;
2384 }
2385 memcpy(dcopy, data, DATASIZE);
2386
2387 buffer acopy = (buffer)malloc(ALPHASIZE);
2388 if (acopy == NULL) {
2389 wxPyBLOCK_THREADS(PyErr_NoMemory());
2390 return NULL;
2391 }
2392 memcpy(acopy, alpha, ALPHASIZE);
2393
2394 return new wxImage(width, height, dcopy, acopy, false);
2395 }
2396 static wxSize wxImage_GetSize(wxImage *self){
2397 wxSize size(self->GetWidth(), self->GetHeight());
2398 return size;
2399 }
2400 static PyObject *wxImage_GetData(wxImage *self){
2401 buffer data = self->GetData();
2402 int len = self->GetWidth() * self->GetHeight() * 3;
2403 PyObject* rv;
2404 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2405 return rv;
2406 }
2407 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2408 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2409 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2410 return;
2411 }
2412 buffer copy = (buffer)malloc(DATASIZE);
2413 if (copy == NULL) {
2414 wxPyBLOCK_THREADS(PyErr_NoMemory());
2415 return;
2416 }
2417 memcpy(copy, data, DATASIZE);
2418 self->SetData(copy, false);
2419 // wxImage takes ownership of copy...
2420 }
2421 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2422 buffer data = self->GetData();
2423 int len = self->GetWidth() * self->GetHeight() * 3;
2424 PyObject* rv;
2425 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2426 return rv;
2427 }
2428 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2429 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2430 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2431 return;
2432 }
2433 self->SetData(data, true);
2434 }
2435 static PyObject *wxImage_GetAlphaData(wxImage *self){
2436 buffer data = self->GetAlpha();
2437 if (! data) {
2438 RETURN_NONE();
2439 } else {
2440 int len = self->GetWidth() * self->GetHeight();
2441 PyObject* rv;
2442 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2443 return rv;
2444 }
2445 }
2446 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2447 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2448 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2449 return;
2450 }
2451 buffer acopy = (buffer)malloc(ALPHASIZE);
2452 if (acopy == NULL) {
2453 wxPyBLOCK_THREADS(PyErr_NoMemory());
2454 return;
2455 }
2456 memcpy(acopy, alpha, ALPHASIZE);
2457 self->SetAlpha(acopy, false);
2458 // wxImage takes ownership of acopy...
2459 }
2460 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2461 buffer data = self->GetAlpha();
2462 int len = self->GetWidth() * self->GetHeight();
2463 PyObject* rv;
2464 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2465 return rv;
2466 }
2467 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2468 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2469 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2470 return;
2471 }
2472 self->SetAlpha(alpha, true);
2473 }
2474 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2475 wxBitmap bitmap(*self, depth);
2476 return bitmap;
2477 }
2478 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2479 wxImage mono = self->ConvertToMono( red, green, blue );
2480 wxBitmap bitmap( mono, 1 );
2481 return bitmap;
2482 }
2483 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2484 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2485 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2486 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2487 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2488 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2489 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2490 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2491 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2492 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2493 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2494 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2495 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2496 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2497 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2498
2499 #include <wx/quantize.h>
2500
2501 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2502 return wxQuantize::Quantize(src, dest,
2503 //NULL, // palette
2504 desiredNoColours,
2505 NULL, // eightBitData
2506 flags);
2507 }
2508 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2509 if (PyCallable_Check(func)) {
2510 self->Connect(id, lastId, eventType,
2511 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2512 new wxPyCallback(func));
2513 }
2514 else if (func == Py_None) {
2515 self->Disconnect(id, lastId, eventType,
2516 (wxObjectEventFunction)
2517 &wxPyCallback::EventThunker);
2518 }
2519 else {
2520 wxPyBLOCK_THREADS(
2521 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2522 }
2523 }
2524 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2525 return self->Disconnect(id, lastId, eventType,
2526 (wxObjectEventFunction)
2527 &wxPyCallback::EventThunker);
2528 }
2529 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2530 if (_self && _self != Py_None) {
2531 self->SetClientObject(new wxPyOORClientData(_self, incref));
2532 }
2533 else {
2534 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2535 if (data) {
2536 self->SetClientObject(NULL); // This will delete it too
2537 }
2538 }
2539 }
2540
2541 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2542 #if wxUSE_UNICODE
2543 return self->GetUnicodeKey();
2544 #else
2545 return 0;
2546 #endif
2547 }
2548
2549 #if UINT_MAX < LONG_MAX
2550 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2551 #define SWIG_From_unsigned_SS_int SWIG_From_long
2552 /*@@*/
2553 #else
2554 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2555 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2556 /*@@*/
2557 #endif
2558
2559
2560 #if UINT_MAX != ULONG_MAX
2561 SWIGINTERN int
2562 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2563 {
2564 const char* errmsg = val ? "unsigned int" : (char*)0;
2565 unsigned long v;
2566 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2567 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2568 if (val) *val = (unsigned int)(v);
2569 return 1;
2570 }
2571 } else {
2572 PyErr_Clear();
2573 }
2574 if (val) {
2575 SWIG_type_error(errmsg, obj);
2576 }
2577 return 0;
2578 }
2579 #else
2580 SWIGINTERNSHORT unsigned int
2581 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2582 {
2583 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2584 }
2585 #endif
2586
2587
2588 SWIGINTERNSHORT unsigned int
2589 SWIG_As_unsigned_SS_int(PyObject* obj)
2590 {
2591 unsigned int v;
2592 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2593 /*
2594 this is needed to make valgrind/purify happier.
2595 */
2596 memset((void*)&v, 0, sizeof(unsigned int));
2597 }
2598 return v;
2599 }
2600
2601
2602 SWIGINTERNSHORT int
2603 SWIG_Check_unsigned_SS_int(PyObject* obj)
2604 {
2605 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2606 }
2607
2608 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2609 self->m_size = size;
2610 }
2611 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2612 int count = self->GetNumberOfFiles();
2613 wxString* files = self->GetFiles();
2614 PyObject* list = PyList_New(count);
2615
2616 if (!list) {
2617 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2618 return NULL;
2619 }
2620
2621 for (int i=0; i<count; i++) {
2622 PyList_SetItem(list, i, wx2PyString(files[i]));
2623 }
2624 return list;
2625 }
2626
2627
2628 static wxPyApp *new_wxPyApp(){
2629 wxPythonApp = new wxPyApp();
2630 return wxPythonApp;
2631 }
2632
2633 void wxApp_CleanUp() {
2634 __wxPyCleanup();
2635 }
2636
2637
2638 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2639
2640
2641 SWIGINTERNSHORT int
2642 SWIG_AsCharPtr(PyObject *obj, char **val)
2643 {
2644 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2645 return 1;
2646 }
2647 if (val) {
2648 PyErr_Clear();
2649 SWIG_type_error("char *", obj);
2650 }
2651 return 0;
2652 }
2653
2654
2655 SWIGINTERN PyObject *
2656 SWIG_FromCharPtr(const char* cptr)
2657 {
2658 if (cptr) {
2659 size_t size = strlen(cptr);
2660 if (size > INT_MAX) {
2661 return SWIG_NewPointerObj((char*)(cptr),
2662 SWIG_TypeQuery("char *"), 0);
2663 } else {
2664 if (size != 0) {
2665 return PyString_FromStringAndSize(cptr, size);
2666 } else {
2667 return PyString_FromString(cptr);
2668 }
2669 }
2670 }
2671 Py_INCREF(Py_None);
2672 return Py_None;
2673 }
2674
2675
2676 #ifdef __WXMAC__
2677
2678 // A dummy class that raises an exception if used...
2679 class wxEventLoop
2680 {
2681 public:
2682 wxEventLoop() { wxPyRaiseNotImplemented(); }
2683 int Run() { return 0; }
2684 void Exit(int rc = 0) {}
2685 bool Pending() const { return false; }
2686 bool Dispatch() { return false; }
2687 bool IsRunning() const { return false; }
2688 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2689 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2690 };
2691
2692 #else
2693
2694 #include <wx/evtloop.h>
2695
2696 #endif
2697
2698
2699
2700 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2701 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2702 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2703 static PyObject *wxWindow_GetChildren(wxWindow *self){
2704 wxWindowList& list = self->GetChildren();
2705 return wxPy_ConvertList(&list);
2706 }
2707 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2708 #if wxUSE_HOTKEY
2709 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2710 #else
2711 return false;
2712 #endif
2713 }
2714 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2715
2716
2717
2718 return false;
2719
2720 }
2721 static long wxWindow_GetHandle(wxWindow *self){
2722 return wxPyGetWinHandle(self);
2723 }
2724 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2725 self->AssociateHandle((WXWidget)handle);
2726 }
2727
2728 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2729 return wxWindow::FindWindowById(id, parent);
2730 }
2731
2732 wxWindow* wxFindWindowByName( const wxString& name,
2733 const wxWindow *parent = NULL ) {
2734 return wxWindow::FindWindowByName(name, parent);
2735 }
2736
2737 wxWindow* wxFindWindowByLabel( const wxString& label,
2738 const wxWindow *parent = NULL ) {
2739 return wxWindow::FindWindowByLabel(label, parent);
2740 }
2741
2742
2743 #ifdef __WXMSW__
2744 #include <wx/msw/private.h> // to get wxGetWindowId
2745 #endif
2746
2747
2748 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2749 #ifdef __WXMSW__
2750 WXHWND hWnd = (WXHWND)_hWnd;
2751 long id = wxGetWindowId(hWnd);
2752 wxWindow* win = new wxWindow;
2753 parent->AddChild(win);
2754 win->SetEventHandler(win);
2755 win->SetHWND(hWnd);
2756 win->SetId(id);
2757 win->SubclassWin(hWnd);
2758 win->AdoptAttributesFromHWND();
2759 win->SetupColours();
2760 return win;
2761 #else
2762 wxPyRaiseNotImplemented();
2763 return NULL;
2764 #endif
2765 }
2766
2767
2768 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2769 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2770 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2771
2772 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2773
2774 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2775 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2776 wxMenuItemList& list = self->GetMenuItems();
2777 return wxPy_ConvertList(&list);
2778 }
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 wxPyBlock_t 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 wxPyBlock_t 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 wxPyBlock_t 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 /*@c:\\PROJECTS\\SWIG-cvs\\Lib\\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 wxPyBlock_t 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 wxPyBlock_t 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 wxPyBlock_t 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 wxPyBlock_t 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 wxPyBlock_t 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 wxPyBlock_t 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 wxPyBlock_t 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 wxPyBlock_t 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 wxPyBlock_t 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 wxPyBlock_t 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 wxPyBlock_t 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 wxPyBlock_t 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 wxPyBlock_t 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 wxPyBlock_t 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 wxPyBlock_t 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_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5299 PyObject *resultobj;
5300 wxRect *arg1 = (wxRect *) 0 ;
5301 bool result;
5302 PyObject * obj0 = 0 ;
5303 char *kwnames[] = {
5304 (char *) "self", NULL
5305 };
5306
5307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",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 = (bool)((wxRect const *)arg1)->IsEmpty();
5313
5314 wxPyEndAllowThreads(__tstate);
5315 if (PyErr_Occurred()) SWIG_fail;
5316 }
5317 {
5318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5319 }
5320 return resultobj;
5321 fail:
5322 return NULL;
5323 }
5324
5325
5326 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5327 PyObject *resultobj;
5328 wxRect *arg1 = (wxRect *) 0 ;
5329 wxPoint result;
5330 PyObject * obj0 = 0 ;
5331 char *kwnames[] = {
5332 (char *) "self", NULL
5333 };
5334
5335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5337 if (SWIG_arg_fail(1)) SWIG_fail;
5338 {
5339 PyThreadState* __tstate = wxPyBeginAllowThreads();
5340 result = ((wxRect const *)arg1)->GetTopLeft();
5341
5342 wxPyEndAllowThreads(__tstate);
5343 if (PyErr_Occurred()) SWIG_fail;
5344 }
5345 {
5346 wxPoint * resultptr;
5347 resultptr = new wxPoint((wxPoint &)(result));
5348 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5349 }
5350 return resultobj;
5351 fail:
5352 return NULL;
5353 }
5354
5355
5356 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5357 PyObject *resultobj;
5358 wxRect *arg1 = (wxRect *) 0 ;
5359 wxPoint *arg2 = 0 ;
5360 wxPoint temp2 ;
5361 PyObject * obj0 = 0 ;
5362 PyObject * obj1 = 0 ;
5363 char *kwnames[] = {
5364 (char *) "self",(char *) "p", NULL
5365 };
5366
5367 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5368 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5369 if (SWIG_arg_fail(1)) SWIG_fail;
5370 {
5371 arg2 = &temp2;
5372 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5373 }
5374 {
5375 PyThreadState* __tstate = wxPyBeginAllowThreads();
5376 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5377
5378 wxPyEndAllowThreads(__tstate);
5379 if (PyErr_Occurred()) SWIG_fail;
5380 }
5381 Py_INCREF(Py_None); resultobj = Py_None;
5382 return resultobj;
5383 fail:
5384 return NULL;
5385 }
5386
5387
5388 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5389 PyObject *resultobj;
5390 wxRect *arg1 = (wxRect *) 0 ;
5391 wxPoint result;
5392 PyObject * obj0 = 0 ;
5393 char *kwnames[] = {
5394 (char *) "self", NULL
5395 };
5396
5397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5399 if (SWIG_arg_fail(1)) SWIG_fail;
5400 {
5401 PyThreadState* __tstate = wxPyBeginAllowThreads();
5402 result = ((wxRect const *)arg1)->GetBottomRight();
5403
5404 wxPyEndAllowThreads(__tstate);
5405 if (PyErr_Occurred()) SWIG_fail;
5406 }
5407 {
5408 wxPoint * resultptr;
5409 resultptr = new wxPoint((wxPoint &)(result));
5410 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5411 }
5412 return resultobj;
5413 fail:
5414 return NULL;
5415 }
5416
5417
5418 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5419 PyObject *resultobj;
5420 wxRect *arg1 = (wxRect *) 0 ;
5421 wxPoint *arg2 = 0 ;
5422 wxPoint temp2 ;
5423 PyObject * obj0 = 0 ;
5424 PyObject * obj1 = 0 ;
5425 char *kwnames[] = {
5426 (char *) "self",(char *) "p", NULL
5427 };
5428
5429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5431 if (SWIG_arg_fail(1)) SWIG_fail;
5432 {
5433 arg2 = &temp2;
5434 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5435 }
5436 {
5437 PyThreadState* __tstate = wxPyBeginAllowThreads();
5438 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5439
5440 wxPyEndAllowThreads(__tstate);
5441 if (PyErr_Occurred()) SWIG_fail;
5442 }
5443 Py_INCREF(Py_None); resultobj = Py_None;
5444 return resultobj;
5445 fail:
5446 return NULL;
5447 }
5448
5449
5450 static PyObject *_wrap_Rect_GetLeft(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_GetLeft",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)->GetLeft();
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_GetTop(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_GetTop",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)->GetTop();
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_GetBottom(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_GetBottom",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)->GetBottom();
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_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5535 PyObject *resultobj;
5536 wxRect *arg1 = (wxRect *) 0 ;
5537 int result;
5538 PyObject * obj0 = 0 ;
5539 char *kwnames[] = {
5540 (char *) "self", NULL
5541 };
5542
5543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5545 if (SWIG_arg_fail(1)) SWIG_fail;
5546 {
5547 PyThreadState* __tstate = wxPyBeginAllowThreads();
5548 result = (int)((wxRect const *)arg1)->GetRight();
5549
5550 wxPyEndAllowThreads(__tstate);
5551 if (PyErr_Occurred()) SWIG_fail;
5552 }
5553 {
5554 resultobj = SWIG_From_int((int)(result));
5555 }
5556 return resultobj;
5557 fail:
5558 return NULL;
5559 }
5560
5561
5562 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5563 PyObject *resultobj;
5564 wxRect *arg1 = (wxRect *) 0 ;
5565 int arg2 ;
5566 PyObject * obj0 = 0 ;
5567 PyObject * obj1 = 0 ;
5568 char *kwnames[] = {
5569 (char *) "self",(char *) "left", NULL
5570 };
5571
5572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5574 if (SWIG_arg_fail(1)) SWIG_fail;
5575 {
5576 arg2 = (int)(SWIG_As_int(obj1));
5577 if (SWIG_arg_fail(2)) SWIG_fail;
5578 }
5579 {
5580 PyThreadState* __tstate = wxPyBeginAllowThreads();
5581 (arg1)->SetLeft(arg2);
5582
5583 wxPyEndAllowThreads(__tstate);
5584 if (PyErr_Occurred()) SWIG_fail;
5585 }
5586 Py_INCREF(Py_None); resultobj = Py_None;
5587 return resultobj;
5588 fail:
5589 return NULL;
5590 }
5591
5592
5593 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5594 PyObject *resultobj;
5595 wxRect *arg1 = (wxRect *) 0 ;
5596 int arg2 ;
5597 PyObject * obj0 = 0 ;
5598 PyObject * obj1 = 0 ;
5599 char *kwnames[] = {
5600 (char *) "self",(char *) "right", NULL
5601 };
5602
5603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5605 if (SWIG_arg_fail(1)) SWIG_fail;
5606 {
5607 arg2 = (int)(SWIG_As_int(obj1));
5608 if (SWIG_arg_fail(2)) SWIG_fail;
5609 }
5610 {
5611 PyThreadState* __tstate = wxPyBeginAllowThreads();
5612 (arg1)->SetRight(arg2);
5613
5614 wxPyEndAllowThreads(__tstate);
5615 if (PyErr_Occurred()) SWIG_fail;
5616 }
5617 Py_INCREF(Py_None); resultobj = Py_None;
5618 return resultobj;
5619 fail:
5620 return NULL;
5621 }
5622
5623
5624 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5625 PyObject *resultobj;
5626 wxRect *arg1 = (wxRect *) 0 ;
5627 int arg2 ;
5628 PyObject * obj0 = 0 ;
5629 PyObject * obj1 = 0 ;
5630 char *kwnames[] = {
5631 (char *) "self",(char *) "top", NULL
5632 };
5633
5634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5636 if (SWIG_arg_fail(1)) SWIG_fail;
5637 {
5638 arg2 = (int)(SWIG_As_int(obj1));
5639 if (SWIG_arg_fail(2)) SWIG_fail;
5640 }
5641 {
5642 PyThreadState* __tstate = wxPyBeginAllowThreads();
5643 (arg1)->SetTop(arg2);
5644
5645 wxPyEndAllowThreads(__tstate);
5646 if (PyErr_Occurred()) SWIG_fail;
5647 }
5648 Py_INCREF(Py_None); resultobj = Py_None;
5649 return resultobj;
5650 fail:
5651 return NULL;
5652 }
5653
5654
5655 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5656 PyObject *resultobj;
5657 wxRect *arg1 = (wxRect *) 0 ;
5658 int arg2 ;
5659 PyObject * obj0 = 0 ;
5660 PyObject * obj1 = 0 ;
5661 char *kwnames[] = {
5662 (char *) "self",(char *) "bottom", NULL
5663 };
5664
5665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5667 if (SWIG_arg_fail(1)) SWIG_fail;
5668 {
5669 arg2 = (int)(SWIG_As_int(obj1));
5670 if (SWIG_arg_fail(2)) SWIG_fail;
5671 }
5672 {
5673 PyThreadState* __tstate = wxPyBeginAllowThreads();
5674 (arg1)->SetBottom(arg2);
5675
5676 wxPyEndAllowThreads(__tstate);
5677 if (PyErr_Occurred()) SWIG_fail;
5678 }
5679 Py_INCREF(Py_None); resultobj = Py_None;
5680 return resultobj;
5681 fail:
5682 return NULL;
5683 }
5684
5685
5686 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5687 PyObject *resultobj;
5688 wxRect *arg1 = (wxRect *) 0 ;
5689 int arg2 ;
5690 int arg3 ;
5691 wxRect *result;
5692 PyObject * obj0 = 0 ;
5693 PyObject * obj1 = 0 ;
5694 PyObject * obj2 = 0 ;
5695 char *kwnames[] = {
5696 (char *) "self",(char *) "dx",(char *) "dy", NULL
5697 };
5698
5699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5701 if (SWIG_arg_fail(1)) SWIG_fail;
5702 {
5703 arg2 = (int)(SWIG_As_int(obj1));
5704 if (SWIG_arg_fail(2)) SWIG_fail;
5705 }
5706 {
5707 arg3 = (int)(SWIG_As_int(obj2));
5708 if (SWIG_arg_fail(3)) SWIG_fail;
5709 }
5710 {
5711 PyThreadState* __tstate = wxPyBeginAllowThreads();
5712 {
5713 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5714 result = (wxRect *) &_result_ref;
5715 }
5716
5717 wxPyEndAllowThreads(__tstate);
5718 if (PyErr_Occurred()) SWIG_fail;
5719 }
5720 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5721 return resultobj;
5722 fail:
5723 return NULL;
5724 }
5725
5726
5727 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5728 PyObject *resultobj;
5729 wxRect *arg1 = (wxRect *) 0 ;
5730 int arg2 ;
5731 int arg3 ;
5732 wxRect *result;
5733 PyObject * obj0 = 0 ;
5734 PyObject * obj1 = 0 ;
5735 PyObject * obj2 = 0 ;
5736 char *kwnames[] = {
5737 (char *) "self",(char *) "dx",(char *) "dy", NULL
5738 };
5739
5740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5742 if (SWIG_arg_fail(1)) SWIG_fail;
5743 {
5744 arg2 = (int)(SWIG_As_int(obj1));
5745 if (SWIG_arg_fail(2)) SWIG_fail;
5746 }
5747 {
5748 arg3 = (int)(SWIG_As_int(obj2));
5749 if (SWIG_arg_fail(3)) SWIG_fail;
5750 }
5751 {
5752 PyThreadState* __tstate = wxPyBeginAllowThreads();
5753 {
5754 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5755 result = (wxRect *) &_result_ref;
5756 }
5757
5758 wxPyEndAllowThreads(__tstate);
5759 if (PyErr_Occurred()) SWIG_fail;
5760 }
5761 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5762 return resultobj;
5763 fail:
5764 return NULL;
5765 }
5766
5767
5768 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5769 PyObject *resultobj;
5770 wxRect *arg1 = (wxRect *) 0 ;
5771 int arg2 ;
5772 int arg3 ;
5773 PyObject * obj0 = 0 ;
5774 PyObject * obj1 = 0 ;
5775 PyObject * obj2 = 0 ;
5776 char *kwnames[] = {
5777 (char *) "self",(char *) "dx",(char *) "dy", NULL
5778 };
5779
5780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5782 if (SWIG_arg_fail(1)) SWIG_fail;
5783 {
5784 arg2 = (int)(SWIG_As_int(obj1));
5785 if (SWIG_arg_fail(2)) SWIG_fail;
5786 }
5787 {
5788 arg3 = (int)(SWIG_As_int(obj2));
5789 if (SWIG_arg_fail(3)) SWIG_fail;
5790 }
5791 {
5792 PyThreadState* __tstate = wxPyBeginAllowThreads();
5793 (arg1)->Offset(arg2,arg3);
5794
5795 wxPyEndAllowThreads(__tstate);
5796 if (PyErr_Occurred()) SWIG_fail;
5797 }
5798 Py_INCREF(Py_None); resultobj = Py_None;
5799 return resultobj;
5800 fail:
5801 return NULL;
5802 }
5803
5804
5805 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5806 PyObject *resultobj;
5807 wxRect *arg1 = (wxRect *) 0 ;
5808 wxPoint *arg2 = 0 ;
5809 wxPoint temp2 ;
5810 PyObject * obj0 = 0 ;
5811 PyObject * obj1 = 0 ;
5812 char *kwnames[] = {
5813 (char *) "self",(char *) "pt", NULL
5814 };
5815
5816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5818 if (SWIG_arg_fail(1)) SWIG_fail;
5819 {
5820 arg2 = &temp2;
5821 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5822 }
5823 {
5824 PyThreadState* __tstate = wxPyBeginAllowThreads();
5825 (arg1)->Offset((wxPoint const &)*arg2);
5826
5827 wxPyEndAllowThreads(__tstate);
5828 if (PyErr_Occurred()) SWIG_fail;
5829 }
5830 Py_INCREF(Py_None); resultobj = Py_None;
5831 return resultobj;
5832 fail:
5833 return NULL;
5834 }
5835
5836
5837 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5838 PyObject *resultobj;
5839 wxRect *arg1 = (wxRect *) 0 ;
5840 wxRect *arg2 = 0 ;
5841 wxRect result;
5842 wxRect temp2 ;
5843 PyObject * obj0 = 0 ;
5844 PyObject * obj1 = 0 ;
5845 char *kwnames[] = {
5846 (char *) "self",(char *) "rect", NULL
5847 };
5848
5849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5851 if (SWIG_arg_fail(1)) SWIG_fail;
5852 {
5853 arg2 = &temp2;
5854 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5855 }
5856 {
5857 PyThreadState* __tstate = wxPyBeginAllowThreads();
5858 result = (arg1)->Intersect((wxRect const &)*arg2);
5859
5860 wxPyEndAllowThreads(__tstate);
5861 if (PyErr_Occurred()) SWIG_fail;
5862 }
5863 {
5864 wxRect * resultptr;
5865 resultptr = new wxRect((wxRect &)(result));
5866 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5867 }
5868 return resultobj;
5869 fail:
5870 return NULL;
5871 }
5872
5873
5874 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5875 PyObject *resultobj;
5876 wxRect *arg1 = (wxRect *) 0 ;
5877 wxRect *arg2 = 0 ;
5878 wxRect result;
5879 wxRect temp2 ;
5880 PyObject * obj0 = 0 ;
5881 PyObject * obj1 = 0 ;
5882 char *kwnames[] = {
5883 (char *) "self",(char *) "rect", NULL
5884 };
5885
5886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5888 if (SWIG_arg_fail(1)) SWIG_fail;
5889 {
5890 arg2 = &temp2;
5891 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5892 }
5893 {
5894 PyThreadState* __tstate = wxPyBeginAllowThreads();
5895 result = (arg1)->Union((wxRect const &)*arg2);
5896
5897 wxPyEndAllowThreads(__tstate);
5898 if (PyErr_Occurred()) SWIG_fail;
5899 }
5900 {
5901 wxRect * resultptr;
5902 resultptr = new wxRect((wxRect &)(result));
5903 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5904 }
5905 return resultobj;
5906 fail:
5907 return NULL;
5908 }
5909
5910
5911 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5912 PyObject *resultobj;
5913 wxRect *arg1 = (wxRect *) 0 ;
5914 wxRect *arg2 = 0 ;
5915 wxRect result;
5916 wxRect temp2 ;
5917 PyObject * obj0 = 0 ;
5918 PyObject * obj1 = 0 ;
5919 char *kwnames[] = {
5920 (char *) "self",(char *) "rect", NULL
5921 };
5922
5923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5925 if (SWIG_arg_fail(1)) SWIG_fail;
5926 {
5927 arg2 = &temp2;
5928 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5929 }
5930 {
5931 PyThreadState* __tstate = wxPyBeginAllowThreads();
5932 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5933
5934 wxPyEndAllowThreads(__tstate);
5935 if (PyErr_Occurred()) SWIG_fail;
5936 }
5937 {
5938 wxRect * resultptr;
5939 resultptr = new wxRect((wxRect &)(result));
5940 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5941 }
5942 return resultobj;
5943 fail:
5944 return NULL;
5945 }
5946
5947
5948 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5949 PyObject *resultobj;
5950 wxRect *arg1 = (wxRect *) 0 ;
5951 wxRect *arg2 = 0 ;
5952 wxRect *result;
5953 wxRect temp2 ;
5954 PyObject * obj0 = 0 ;
5955 PyObject * obj1 = 0 ;
5956 char *kwnames[] = {
5957 (char *) "self",(char *) "rect", NULL
5958 };
5959
5960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5962 if (SWIG_arg_fail(1)) SWIG_fail;
5963 {
5964 arg2 = &temp2;
5965 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5966 }
5967 {
5968 PyThreadState* __tstate = wxPyBeginAllowThreads();
5969 {
5970 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5971 result = (wxRect *) &_result_ref;
5972 }
5973
5974 wxPyEndAllowThreads(__tstate);
5975 if (PyErr_Occurred()) SWIG_fail;
5976 }
5977 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5978 return resultobj;
5979 fail:
5980 return NULL;
5981 }
5982
5983
5984 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5985 PyObject *resultobj;
5986 wxRect *arg1 = (wxRect *) 0 ;
5987 wxRect *arg2 = 0 ;
5988 bool result;
5989 wxRect temp2 ;
5990 PyObject * obj0 = 0 ;
5991 PyObject * obj1 = 0 ;
5992 char *kwnames[] = {
5993 (char *) "self",(char *) "rect", NULL
5994 };
5995
5996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5998 if (SWIG_arg_fail(1)) SWIG_fail;
5999 {
6000 arg2 = &temp2;
6001 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6002 }
6003 {
6004 PyThreadState* __tstate = wxPyBeginAllowThreads();
6005 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6006
6007 wxPyEndAllowThreads(__tstate);
6008 if (PyErr_Occurred()) SWIG_fail;
6009 }
6010 {
6011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6012 }
6013 return resultobj;
6014 fail:
6015 return NULL;
6016 }
6017
6018
6019 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6020 PyObject *resultobj;
6021 wxRect *arg1 = (wxRect *) 0 ;
6022 wxRect *arg2 = 0 ;
6023 bool result;
6024 wxRect temp2 ;
6025 PyObject * obj0 = 0 ;
6026 PyObject * obj1 = 0 ;
6027 char *kwnames[] = {
6028 (char *) "self",(char *) "rect", NULL
6029 };
6030
6031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6032 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6033 if (SWIG_arg_fail(1)) SWIG_fail;
6034 {
6035 arg2 = &temp2;
6036 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6037 }
6038 {
6039 PyThreadState* __tstate = wxPyBeginAllowThreads();
6040 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6041
6042 wxPyEndAllowThreads(__tstate);
6043 if (PyErr_Occurred()) SWIG_fail;
6044 }
6045 {
6046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6047 }
6048 return resultobj;
6049 fail:
6050 return NULL;
6051 }
6052
6053
6054 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6055 PyObject *resultobj;
6056 wxRect *arg1 = (wxRect *) 0 ;
6057 int arg2 ;
6058 int arg3 ;
6059 bool result;
6060 PyObject * obj0 = 0 ;
6061 PyObject * obj1 = 0 ;
6062 PyObject * obj2 = 0 ;
6063 char *kwnames[] = {
6064 (char *) "self",(char *) "x",(char *) "y", NULL
6065 };
6066
6067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6069 if (SWIG_arg_fail(1)) SWIG_fail;
6070 {
6071 arg2 = (int)(SWIG_As_int(obj1));
6072 if (SWIG_arg_fail(2)) SWIG_fail;
6073 }
6074 {
6075 arg3 = (int)(SWIG_As_int(obj2));
6076 if (SWIG_arg_fail(3)) SWIG_fail;
6077 }
6078 {
6079 PyThreadState* __tstate = wxPyBeginAllowThreads();
6080 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6081
6082 wxPyEndAllowThreads(__tstate);
6083 if (PyErr_Occurred()) SWIG_fail;
6084 }
6085 {
6086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6087 }
6088 return resultobj;
6089 fail:
6090 return NULL;
6091 }
6092
6093
6094 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6095 PyObject *resultobj;
6096 wxRect *arg1 = (wxRect *) 0 ;
6097 wxPoint *arg2 = 0 ;
6098 bool result;
6099 wxPoint temp2 ;
6100 PyObject * obj0 = 0 ;
6101 PyObject * obj1 = 0 ;
6102 char *kwnames[] = {
6103 (char *) "self",(char *) "pt", NULL
6104 };
6105
6106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6108 if (SWIG_arg_fail(1)) SWIG_fail;
6109 {
6110 arg2 = &temp2;
6111 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6112 }
6113 {
6114 PyThreadState* __tstate = wxPyBeginAllowThreads();
6115 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6116
6117 wxPyEndAllowThreads(__tstate);
6118 if (PyErr_Occurred()) SWIG_fail;
6119 }
6120 {
6121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6122 }
6123 return resultobj;
6124 fail:
6125 return NULL;
6126 }
6127
6128
6129 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6130 PyObject *resultobj;
6131 wxRect *arg1 = (wxRect *) 0 ;
6132 wxRect *arg2 = 0 ;
6133 bool result;
6134 wxRect temp2 ;
6135 PyObject * obj0 = 0 ;
6136 PyObject * obj1 = 0 ;
6137 char *kwnames[] = {
6138 (char *) "self",(char *) "rect", NULL
6139 };
6140
6141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6143 if (SWIG_arg_fail(1)) SWIG_fail;
6144 {
6145 arg2 = &temp2;
6146 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6147 }
6148 {
6149 PyThreadState* __tstate = wxPyBeginAllowThreads();
6150 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6151
6152 wxPyEndAllowThreads(__tstate);
6153 if (PyErr_Occurred()) SWIG_fail;
6154 }
6155 {
6156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6157 }
6158 return resultobj;
6159 fail:
6160 return NULL;
6161 }
6162
6163
6164 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6165 PyObject *resultobj;
6166 wxRect *arg1 = (wxRect *) 0 ;
6167 int arg2 ;
6168 PyObject * obj0 = 0 ;
6169 PyObject * obj1 = 0 ;
6170 char *kwnames[] = {
6171 (char *) "self",(char *) "x", NULL
6172 };
6173
6174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6176 if (SWIG_arg_fail(1)) SWIG_fail;
6177 {
6178 arg2 = (int)(SWIG_As_int(obj1));
6179 if (SWIG_arg_fail(2)) SWIG_fail;
6180 }
6181 if (arg1) (arg1)->x = arg2;
6182
6183 Py_INCREF(Py_None); resultobj = Py_None;
6184 return resultobj;
6185 fail:
6186 return NULL;
6187 }
6188
6189
6190 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6191 PyObject *resultobj;
6192 wxRect *arg1 = (wxRect *) 0 ;
6193 int result;
6194 PyObject * obj0 = 0 ;
6195 char *kwnames[] = {
6196 (char *) "self", NULL
6197 };
6198
6199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6201 if (SWIG_arg_fail(1)) SWIG_fail;
6202 result = (int) ((arg1)->x);
6203
6204 {
6205 resultobj = SWIG_From_int((int)(result));
6206 }
6207 return resultobj;
6208 fail:
6209 return NULL;
6210 }
6211
6212
6213 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6214 PyObject *resultobj;
6215 wxRect *arg1 = (wxRect *) 0 ;
6216 int arg2 ;
6217 PyObject * obj0 = 0 ;
6218 PyObject * obj1 = 0 ;
6219 char *kwnames[] = {
6220 (char *) "self",(char *) "y", NULL
6221 };
6222
6223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6225 if (SWIG_arg_fail(1)) SWIG_fail;
6226 {
6227 arg2 = (int)(SWIG_As_int(obj1));
6228 if (SWIG_arg_fail(2)) SWIG_fail;
6229 }
6230 if (arg1) (arg1)->y = arg2;
6231
6232 Py_INCREF(Py_None); resultobj = Py_None;
6233 return resultobj;
6234 fail:
6235 return NULL;
6236 }
6237
6238
6239 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6240 PyObject *resultobj;
6241 wxRect *arg1 = (wxRect *) 0 ;
6242 int result;
6243 PyObject * obj0 = 0 ;
6244 char *kwnames[] = {
6245 (char *) "self", NULL
6246 };
6247
6248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6250 if (SWIG_arg_fail(1)) SWIG_fail;
6251 result = (int) ((arg1)->y);
6252
6253 {
6254 resultobj = SWIG_From_int((int)(result));
6255 }
6256 return resultobj;
6257 fail:
6258 return NULL;
6259 }
6260
6261
6262 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6263 PyObject *resultobj;
6264 wxRect *arg1 = (wxRect *) 0 ;
6265 int arg2 ;
6266 PyObject * obj0 = 0 ;
6267 PyObject * obj1 = 0 ;
6268 char *kwnames[] = {
6269 (char *) "self",(char *) "width", NULL
6270 };
6271
6272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6274 if (SWIG_arg_fail(1)) SWIG_fail;
6275 {
6276 arg2 = (int)(SWIG_As_int(obj1));
6277 if (SWIG_arg_fail(2)) SWIG_fail;
6278 }
6279 if (arg1) (arg1)->width = arg2;
6280
6281 Py_INCREF(Py_None); resultobj = Py_None;
6282 return resultobj;
6283 fail:
6284 return NULL;
6285 }
6286
6287
6288 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6289 PyObject *resultobj;
6290 wxRect *arg1 = (wxRect *) 0 ;
6291 int result;
6292 PyObject * obj0 = 0 ;
6293 char *kwnames[] = {
6294 (char *) "self", NULL
6295 };
6296
6297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6299 if (SWIG_arg_fail(1)) SWIG_fail;
6300 result = (int) ((arg1)->width);
6301
6302 {
6303 resultobj = SWIG_From_int((int)(result));
6304 }
6305 return resultobj;
6306 fail:
6307 return NULL;
6308 }
6309
6310
6311 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6312 PyObject *resultobj;
6313 wxRect *arg1 = (wxRect *) 0 ;
6314 int arg2 ;
6315 PyObject * obj0 = 0 ;
6316 PyObject * obj1 = 0 ;
6317 char *kwnames[] = {
6318 (char *) "self",(char *) "height", NULL
6319 };
6320
6321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6323 if (SWIG_arg_fail(1)) SWIG_fail;
6324 {
6325 arg2 = (int)(SWIG_As_int(obj1));
6326 if (SWIG_arg_fail(2)) SWIG_fail;
6327 }
6328 if (arg1) (arg1)->height = arg2;
6329
6330 Py_INCREF(Py_None); resultobj = Py_None;
6331 return resultobj;
6332 fail:
6333 return NULL;
6334 }
6335
6336
6337 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6338 PyObject *resultobj;
6339 wxRect *arg1 = (wxRect *) 0 ;
6340 int result;
6341 PyObject * obj0 = 0 ;
6342 char *kwnames[] = {
6343 (char *) "self", NULL
6344 };
6345
6346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6348 if (SWIG_arg_fail(1)) SWIG_fail;
6349 result = (int) ((arg1)->height);
6350
6351 {
6352 resultobj = SWIG_From_int((int)(result));
6353 }
6354 return resultobj;
6355 fail:
6356 return NULL;
6357 }
6358
6359
6360 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6361 PyObject *resultobj;
6362 wxRect *arg1 = (wxRect *) 0 ;
6363 int arg2 = (int) 0 ;
6364 int arg3 = (int) 0 ;
6365 int arg4 = (int) 0 ;
6366 int arg5 = (int) 0 ;
6367 PyObject * obj0 = 0 ;
6368 PyObject * obj1 = 0 ;
6369 PyObject * obj2 = 0 ;
6370 PyObject * obj3 = 0 ;
6371 PyObject * obj4 = 0 ;
6372 char *kwnames[] = {
6373 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6374 };
6375
6376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6378 if (SWIG_arg_fail(1)) SWIG_fail;
6379 if (obj1) {
6380 {
6381 arg2 = (int)(SWIG_As_int(obj1));
6382 if (SWIG_arg_fail(2)) SWIG_fail;
6383 }
6384 }
6385 if (obj2) {
6386 {
6387 arg3 = (int)(SWIG_As_int(obj2));
6388 if (SWIG_arg_fail(3)) SWIG_fail;
6389 }
6390 }
6391 if (obj3) {
6392 {
6393 arg4 = (int)(SWIG_As_int(obj3));
6394 if (SWIG_arg_fail(4)) SWIG_fail;
6395 }
6396 }
6397 if (obj4) {
6398 {
6399 arg5 = (int)(SWIG_As_int(obj4));
6400 if (SWIG_arg_fail(5)) SWIG_fail;
6401 }
6402 }
6403 {
6404 PyThreadState* __tstate = wxPyBeginAllowThreads();
6405 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6406
6407 wxPyEndAllowThreads(__tstate);
6408 if (PyErr_Occurred()) SWIG_fail;
6409 }
6410 Py_INCREF(Py_None); resultobj = Py_None;
6411 return resultobj;
6412 fail:
6413 return NULL;
6414 }
6415
6416
6417 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6418 PyObject *resultobj;
6419 wxRect *arg1 = (wxRect *) 0 ;
6420 PyObject *result;
6421 PyObject * obj0 = 0 ;
6422 char *kwnames[] = {
6423 (char *) "self", NULL
6424 };
6425
6426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6428 if (SWIG_arg_fail(1)) SWIG_fail;
6429 {
6430 PyThreadState* __tstate = wxPyBeginAllowThreads();
6431 result = (PyObject *)wxRect_Get(arg1);
6432
6433 wxPyEndAllowThreads(__tstate);
6434 if (PyErr_Occurred()) SWIG_fail;
6435 }
6436 resultobj = result;
6437 return resultobj;
6438 fail:
6439 return NULL;
6440 }
6441
6442
6443 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6444 PyObject *obj;
6445 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6446 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6447 Py_INCREF(obj);
6448 return Py_BuildValue((char *)"");
6449 }
6450 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6451 PyObject *resultobj;
6452 wxRect *arg1 = (wxRect *) 0 ;
6453 wxRect *arg2 = (wxRect *) 0 ;
6454 PyObject *result;
6455 PyObject * obj0 = 0 ;
6456 PyObject * obj1 = 0 ;
6457 char *kwnames[] = {
6458 (char *) "r1",(char *) "r2", NULL
6459 };
6460
6461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6463 if (SWIG_arg_fail(1)) SWIG_fail;
6464 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6465 if (SWIG_arg_fail(2)) SWIG_fail;
6466 {
6467 if (!wxPyCheckForApp()) SWIG_fail;
6468 PyThreadState* __tstate = wxPyBeginAllowThreads();
6469 result = (PyObject *)wxIntersectRect(arg1,arg2);
6470
6471 wxPyEndAllowThreads(__tstate);
6472 if (PyErr_Occurred()) SWIG_fail;
6473 }
6474 resultobj = result;
6475 return resultobj;
6476 fail:
6477 return NULL;
6478 }
6479
6480
6481 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6482 PyObject *resultobj;
6483 double arg1 = (double) 0.0 ;
6484 double arg2 = (double) 0.0 ;
6485 wxPoint2D *result;
6486 PyObject * obj0 = 0 ;
6487 PyObject * obj1 = 0 ;
6488 char *kwnames[] = {
6489 (char *) "x",(char *) "y", NULL
6490 };
6491
6492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6493 if (obj0) {
6494 {
6495 arg1 = (double)(SWIG_As_double(obj0));
6496 if (SWIG_arg_fail(1)) SWIG_fail;
6497 }
6498 }
6499 if (obj1) {
6500 {
6501 arg2 = (double)(SWIG_As_double(obj1));
6502 if (SWIG_arg_fail(2)) SWIG_fail;
6503 }
6504 }
6505 {
6506 PyThreadState* __tstate = wxPyBeginAllowThreads();
6507 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6508
6509 wxPyEndAllowThreads(__tstate);
6510 if (PyErr_Occurred()) SWIG_fail;
6511 }
6512 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6513 return resultobj;
6514 fail:
6515 return NULL;
6516 }
6517
6518
6519 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6520 PyObject *resultobj;
6521 wxPoint2D *arg1 = 0 ;
6522 wxPoint2D *result;
6523 wxPoint2D temp1 ;
6524 PyObject * obj0 = 0 ;
6525 char *kwnames[] = {
6526 (char *) "pt", NULL
6527 };
6528
6529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6530 {
6531 arg1 = &temp1;
6532 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6533 }
6534 {
6535 PyThreadState* __tstate = wxPyBeginAllowThreads();
6536 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6537
6538 wxPyEndAllowThreads(__tstate);
6539 if (PyErr_Occurred()) SWIG_fail;
6540 }
6541 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6542 return resultobj;
6543 fail:
6544 return NULL;
6545 }
6546
6547
6548 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6549 PyObject *resultobj;
6550 wxPoint *arg1 = 0 ;
6551 wxPoint2D *result;
6552 wxPoint temp1 ;
6553 PyObject * obj0 = 0 ;
6554 char *kwnames[] = {
6555 (char *) "pt", NULL
6556 };
6557
6558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6559 {
6560 arg1 = &temp1;
6561 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6562 }
6563 {
6564 PyThreadState* __tstate = wxPyBeginAllowThreads();
6565 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6566
6567 wxPyEndAllowThreads(__tstate);
6568 if (PyErr_Occurred()) SWIG_fail;
6569 }
6570 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6571 return resultobj;
6572 fail:
6573 return NULL;
6574 }
6575
6576
6577 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6578 PyObject *resultobj;
6579 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6580 int *arg2 = (int *) 0 ;
6581 int *arg3 = (int *) 0 ;
6582 int temp2 ;
6583 int res2 = 0 ;
6584 int temp3 ;
6585 int res3 = 0 ;
6586 PyObject * obj0 = 0 ;
6587 char *kwnames[] = {
6588 (char *) "self", NULL
6589 };
6590
6591 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6592 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6595 if (SWIG_arg_fail(1)) SWIG_fail;
6596 {
6597 PyThreadState* __tstate = wxPyBeginAllowThreads();
6598 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6599
6600 wxPyEndAllowThreads(__tstate);
6601 if (PyErr_Occurred()) SWIG_fail;
6602 }
6603 Py_INCREF(Py_None); resultobj = Py_None;
6604 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6605 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6606 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6607 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6608 return resultobj;
6609 fail:
6610 return NULL;
6611 }
6612
6613
6614 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6615 PyObject *resultobj;
6616 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6617 int *arg2 = (int *) 0 ;
6618 int *arg3 = (int *) 0 ;
6619 int temp2 ;
6620 int res2 = 0 ;
6621 int temp3 ;
6622 int res3 = 0 ;
6623 PyObject * obj0 = 0 ;
6624 char *kwnames[] = {
6625 (char *) "self", NULL
6626 };
6627
6628 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6629 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6632 if (SWIG_arg_fail(1)) SWIG_fail;
6633 {
6634 PyThreadState* __tstate = wxPyBeginAllowThreads();
6635 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6636
6637 wxPyEndAllowThreads(__tstate);
6638 if (PyErr_Occurred()) SWIG_fail;
6639 }
6640 Py_INCREF(Py_None); resultobj = Py_None;
6641 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6642 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6643 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6644 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6645 return resultobj;
6646 fail:
6647 return NULL;
6648 }
6649
6650
6651 static PyObject *_wrap_Point2D_GetVectorLength(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_GetVectorLength",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)->GetVectorLength();
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_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6680 PyObject *resultobj;
6681 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6682 double result;
6683 PyObject * obj0 = 0 ;
6684 char *kwnames[] = {
6685 (char *) "self", NULL
6686 };
6687
6688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6690 if (SWIG_arg_fail(1)) SWIG_fail;
6691 {
6692 PyThreadState* __tstate = wxPyBeginAllowThreads();
6693 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6694
6695 wxPyEndAllowThreads(__tstate);
6696 if (PyErr_Occurred()) SWIG_fail;
6697 }
6698 {
6699 resultobj = SWIG_From_double((double)(result));
6700 }
6701 return resultobj;
6702 fail:
6703 return NULL;
6704 }
6705
6706
6707 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6708 PyObject *resultobj;
6709 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6710 double arg2 ;
6711 PyObject * obj0 = 0 ;
6712 PyObject * obj1 = 0 ;
6713 char *kwnames[] = {
6714 (char *) "self",(char *) "length", NULL
6715 };
6716
6717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6719 if (SWIG_arg_fail(1)) SWIG_fail;
6720 {
6721 arg2 = (double)(SWIG_As_double(obj1));
6722 if (SWIG_arg_fail(2)) SWIG_fail;
6723 }
6724 {
6725 PyThreadState* __tstate = wxPyBeginAllowThreads();
6726 (arg1)->SetVectorLength(arg2);
6727
6728 wxPyEndAllowThreads(__tstate);
6729 if (PyErr_Occurred()) SWIG_fail;
6730 }
6731 Py_INCREF(Py_None); resultobj = Py_None;
6732 return resultobj;
6733 fail:
6734 return NULL;
6735 }
6736
6737
6738 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6739 PyObject *resultobj;
6740 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6741 double arg2 ;
6742 PyObject * obj0 = 0 ;
6743 PyObject * obj1 = 0 ;
6744 char *kwnames[] = {
6745 (char *) "self",(char *) "degrees", NULL
6746 };
6747
6748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6750 if (SWIG_arg_fail(1)) SWIG_fail;
6751 {
6752 arg2 = (double)(SWIG_As_double(obj1));
6753 if (SWIG_arg_fail(2)) SWIG_fail;
6754 }
6755 {
6756 PyThreadState* __tstate = wxPyBeginAllowThreads();
6757 (arg1)->SetVectorAngle(arg2);
6758
6759 wxPyEndAllowThreads(__tstate);
6760 if (PyErr_Occurred()) SWIG_fail;
6761 }
6762 Py_INCREF(Py_None); resultobj = Py_None;
6763 return resultobj;
6764 fail:
6765 return NULL;
6766 }
6767
6768
6769 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6770 PyObject *resultobj;
6771 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6772 wxPoint2D *arg2 = 0 ;
6773 double result;
6774 wxPoint2D temp2 ;
6775 PyObject * obj0 = 0 ;
6776 PyObject * obj1 = 0 ;
6777 char *kwnames[] = {
6778 (char *) "self",(char *) "pt", NULL
6779 };
6780
6781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6783 if (SWIG_arg_fail(1)) SWIG_fail;
6784 {
6785 arg2 = &temp2;
6786 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6787 }
6788 {
6789 PyThreadState* __tstate = wxPyBeginAllowThreads();
6790 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6791
6792 wxPyEndAllowThreads(__tstate);
6793 if (PyErr_Occurred()) SWIG_fail;
6794 }
6795 {
6796 resultobj = SWIG_From_double((double)(result));
6797 }
6798 return resultobj;
6799 fail:
6800 return NULL;
6801 }
6802
6803
6804 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6805 PyObject *resultobj;
6806 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6807 wxPoint2D *arg2 = 0 ;
6808 double result;
6809 wxPoint2D temp2 ;
6810 PyObject * obj0 = 0 ;
6811 PyObject * obj1 = 0 ;
6812 char *kwnames[] = {
6813 (char *) "self",(char *) "pt", NULL
6814 };
6815
6816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6818 if (SWIG_arg_fail(1)) SWIG_fail;
6819 {
6820 arg2 = &temp2;
6821 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6822 }
6823 {
6824 PyThreadState* __tstate = wxPyBeginAllowThreads();
6825 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6826
6827 wxPyEndAllowThreads(__tstate);
6828 if (PyErr_Occurred()) SWIG_fail;
6829 }
6830 {
6831 resultobj = SWIG_From_double((double)(result));
6832 }
6833 return resultobj;
6834 fail:
6835 return NULL;
6836 }
6837
6838
6839 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6840 PyObject *resultobj;
6841 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6842 wxPoint2D *arg2 = 0 ;
6843 double result;
6844 wxPoint2D temp2 ;
6845 PyObject * obj0 = 0 ;
6846 PyObject * obj1 = 0 ;
6847 char *kwnames[] = {
6848 (char *) "self",(char *) "vec", NULL
6849 };
6850
6851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6853 if (SWIG_arg_fail(1)) SWIG_fail;
6854 {
6855 arg2 = &temp2;
6856 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6857 }
6858 {
6859 PyThreadState* __tstate = wxPyBeginAllowThreads();
6860 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6861
6862 wxPyEndAllowThreads(__tstate);
6863 if (PyErr_Occurred()) SWIG_fail;
6864 }
6865 {
6866 resultobj = SWIG_From_double((double)(result));
6867 }
6868 return resultobj;
6869 fail:
6870 return NULL;
6871 }
6872
6873
6874 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6875 PyObject *resultobj;
6876 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6877 wxPoint2D *arg2 = 0 ;
6878 double result;
6879 wxPoint2D temp2 ;
6880 PyObject * obj0 = 0 ;
6881 PyObject * obj1 = 0 ;
6882 char *kwnames[] = {
6883 (char *) "self",(char *) "vec", NULL
6884 };
6885
6886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6888 if (SWIG_arg_fail(1)) SWIG_fail;
6889 {
6890 arg2 = &temp2;
6891 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6892 }
6893 {
6894 PyThreadState* __tstate = wxPyBeginAllowThreads();
6895 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6896
6897 wxPyEndAllowThreads(__tstate);
6898 if (PyErr_Occurred()) SWIG_fail;
6899 }
6900 {
6901 resultobj = SWIG_From_double((double)(result));
6902 }
6903 return resultobj;
6904 fail:
6905 return NULL;
6906 }
6907
6908
6909 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6910 PyObject *resultobj;
6911 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6912 wxPoint2D result;
6913 PyObject * obj0 = 0 ;
6914 char *kwnames[] = {
6915 (char *) "self", NULL
6916 };
6917
6918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6920 if (SWIG_arg_fail(1)) SWIG_fail;
6921 {
6922 PyThreadState* __tstate = wxPyBeginAllowThreads();
6923 result = (arg1)->operator -();
6924
6925 wxPyEndAllowThreads(__tstate);
6926 if (PyErr_Occurred()) SWIG_fail;
6927 }
6928 {
6929 wxPoint2D * resultptr;
6930 resultptr = new wxPoint2D((wxPoint2D &)(result));
6931 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6932 }
6933 return resultobj;
6934 fail:
6935 return NULL;
6936 }
6937
6938
6939 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6940 PyObject *resultobj;
6941 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6942 wxPoint2D *arg2 = 0 ;
6943 wxPoint2D *result;
6944 wxPoint2D temp2 ;
6945 PyObject * obj0 = 0 ;
6946 PyObject * obj1 = 0 ;
6947 char *kwnames[] = {
6948 (char *) "self",(char *) "pt", NULL
6949 };
6950
6951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6953 if (SWIG_arg_fail(1)) SWIG_fail;
6954 {
6955 arg2 = &temp2;
6956 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6957 }
6958 {
6959 PyThreadState* __tstate = wxPyBeginAllowThreads();
6960 {
6961 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6962 result = (wxPoint2D *) &_result_ref;
6963 }
6964
6965 wxPyEndAllowThreads(__tstate);
6966 if (PyErr_Occurred()) SWIG_fail;
6967 }
6968 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6969 return resultobj;
6970 fail:
6971 return NULL;
6972 }
6973
6974
6975 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6976 PyObject *resultobj;
6977 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6978 wxPoint2D *arg2 = 0 ;
6979 wxPoint2D *result;
6980 wxPoint2D temp2 ;
6981 PyObject * obj0 = 0 ;
6982 PyObject * obj1 = 0 ;
6983 char *kwnames[] = {
6984 (char *) "self",(char *) "pt", NULL
6985 };
6986
6987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6989 if (SWIG_arg_fail(1)) SWIG_fail;
6990 {
6991 arg2 = &temp2;
6992 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6993 }
6994 {
6995 PyThreadState* __tstate = wxPyBeginAllowThreads();
6996 {
6997 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6998 result = (wxPoint2D *) &_result_ref;
6999 }
7000
7001 wxPyEndAllowThreads(__tstate);
7002 if (PyErr_Occurred()) SWIG_fail;
7003 }
7004 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7005 return resultobj;
7006 fail:
7007 return NULL;
7008 }
7009
7010
7011 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7012 PyObject *resultobj;
7013 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7014 wxPoint2D *arg2 = 0 ;
7015 wxPoint2D *result;
7016 wxPoint2D temp2 ;
7017 PyObject * obj0 = 0 ;
7018 PyObject * obj1 = 0 ;
7019 char *kwnames[] = {
7020 (char *) "self",(char *) "pt", NULL
7021 };
7022
7023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7025 if (SWIG_arg_fail(1)) SWIG_fail;
7026 {
7027 arg2 = &temp2;
7028 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7029 }
7030 {
7031 PyThreadState* __tstate = wxPyBeginAllowThreads();
7032 {
7033 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7034 result = (wxPoint2D *) &_result_ref;
7035 }
7036
7037 wxPyEndAllowThreads(__tstate);
7038 if (PyErr_Occurred()) SWIG_fail;
7039 }
7040 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7041 return resultobj;
7042 fail:
7043 return NULL;
7044 }
7045
7046
7047 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7048 PyObject *resultobj;
7049 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7050 wxPoint2D *arg2 = 0 ;
7051 wxPoint2D *result;
7052 wxPoint2D temp2 ;
7053 PyObject * obj0 = 0 ;
7054 PyObject * obj1 = 0 ;
7055 char *kwnames[] = {
7056 (char *) "self",(char *) "pt", NULL
7057 };
7058
7059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7061 if (SWIG_arg_fail(1)) SWIG_fail;
7062 {
7063 arg2 = &temp2;
7064 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7065 }
7066 {
7067 PyThreadState* __tstate = wxPyBeginAllowThreads();
7068 {
7069 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7070 result = (wxPoint2D *) &_result_ref;
7071 }
7072
7073 wxPyEndAllowThreads(__tstate);
7074 if (PyErr_Occurred()) SWIG_fail;
7075 }
7076 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7077 return resultobj;
7078 fail:
7079 return NULL;
7080 }
7081
7082
7083 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7084 PyObject *resultobj;
7085 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7086 wxPoint2D *arg2 = 0 ;
7087 bool result;
7088 wxPoint2D temp2 ;
7089 PyObject * obj0 = 0 ;
7090 PyObject * obj1 = 0 ;
7091 char *kwnames[] = {
7092 (char *) "self",(char *) "pt", NULL
7093 };
7094
7095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7097 if (SWIG_arg_fail(1)) SWIG_fail;
7098 {
7099 arg2 = &temp2;
7100 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7101 }
7102 {
7103 PyThreadState* __tstate = wxPyBeginAllowThreads();
7104 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7105
7106 wxPyEndAllowThreads(__tstate);
7107 if (PyErr_Occurred()) SWIG_fail;
7108 }
7109 {
7110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7111 }
7112 return resultobj;
7113 fail:
7114 return NULL;
7115 }
7116
7117
7118 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7119 PyObject *resultobj;
7120 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7121 wxPoint2D *arg2 = 0 ;
7122 bool result;
7123 wxPoint2D temp2 ;
7124 PyObject * obj0 = 0 ;
7125 PyObject * obj1 = 0 ;
7126 char *kwnames[] = {
7127 (char *) "self",(char *) "pt", NULL
7128 };
7129
7130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7132 if (SWIG_arg_fail(1)) SWIG_fail;
7133 {
7134 arg2 = &temp2;
7135 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7136 }
7137 {
7138 PyThreadState* __tstate = wxPyBeginAllowThreads();
7139 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7140
7141 wxPyEndAllowThreads(__tstate);
7142 if (PyErr_Occurred()) SWIG_fail;
7143 }
7144 {
7145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7146 }
7147 return resultobj;
7148 fail:
7149 return NULL;
7150 }
7151
7152
7153 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7154 PyObject *resultobj;
7155 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7156 double arg2 ;
7157 PyObject * obj0 = 0 ;
7158 PyObject * obj1 = 0 ;
7159 char *kwnames[] = {
7160 (char *) "self",(char *) "m_x", NULL
7161 };
7162
7163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7165 if (SWIG_arg_fail(1)) SWIG_fail;
7166 {
7167 arg2 = (double)(SWIG_As_double(obj1));
7168 if (SWIG_arg_fail(2)) SWIG_fail;
7169 }
7170 if (arg1) (arg1)->m_x = arg2;
7171
7172 Py_INCREF(Py_None); resultobj = Py_None;
7173 return resultobj;
7174 fail:
7175 return NULL;
7176 }
7177
7178
7179 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7180 PyObject *resultobj;
7181 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7182 double result;
7183 PyObject * obj0 = 0 ;
7184 char *kwnames[] = {
7185 (char *) "self", NULL
7186 };
7187
7188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7190 if (SWIG_arg_fail(1)) SWIG_fail;
7191 result = (double) ((arg1)->m_x);
7192
7193 {
7194 resultobj = SWIG_From_double((double)(result));
7195 }
7196 return resultobj;
7197 fail:
7198 return NULL;
7199 }
7200
7201
7202 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7203 PyObject *resultobj;
7204 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7205 double arg2 ;
7206 PyObject * obj0 = 0 ;
7207 PyObject * obj1 = 0 ;
7208 char *kwnames[] = {
7209 (char *) "self",(char *) "m_y", NULL
7210 };
7211
7212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7214 if (SWIG_arg_fail(1)) SWIG_fail;
7215 {
7216 arg2 = (double)(SWIG_As_double(obj1));
7217 if (SWIG_arg_fail(2)) SWIG_fail;
7218 }
7219 if (arg1) (arg1)->m_y = arg2;
7220
7221 Py_INCREF(Py_None); resultobj = Py_None;
7222 return resultobj;
7223 fail:
7224 return NULL;
7225 }
7226
7227
7228 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7229 PyObject *resultobj;
7230 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7231 double result;
7232 PyObject * obj0 = 0 ;
7233 char *kwnames[] = {
7234 (char *) "self", NULL
7235 };
7236
7237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7239 if (SWIG_arg_fail(1)) SWIG_fail;
7240 result = (double) ((arg1)->m_y);
7241
7242 {
7243 resultobj = SWIG_From_double((double)(result));
7244 }
7245 return resultobj;
7246 fail:
7247 return NULL;
7248 }
7249
7250
7251 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7252 PyObject *resultobj;
7253 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7254 double arg2 = (double) 0 ;
7255 double arg3 = (double) 0 ;
7256 PyObject * obj0 = 0 ;
7257 PyObject * obj1 = 0 ;
7258 PyObject * obj2 = 0 ;
7259 char *kwnames[] = {
7260 (char *) "self",(char *) "x",(char *) "y", NULL
7261 };
7262
7263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7265 if (SWIG_arg_fail(1)) SWIG_fail;
7266 if (obj1) {
7267 {
7268 arg2 = (double)(SWIG_As_double(obj1));
7269 if (SWIG_arg_fail(2)) SWIG_fail;
7270 }
7271 }
7272 if (obj2) {
7273 {
7274 arg3 = (double)(SWIG_As_double(obj2));
7275 if (SWIG_arg_fail(3)) SWIG_fail;
7276 }
7277 }
7278 {
7279 PyThreadState* __tstate = wxPyBeginAllowThreads();
7280 wxPoint2D_Set(arg1,arg2,arg3);
7281
7282 wxPyEndAllowThreads(__tstate);
7283 if (PyErr_Occurred()) SWIG_fail;
7284 }
7285 Py_INCREF(Py_None); resultobj = Py_None;
7286 return resultobj;
7287 fail:
7288 return NULL;
7289 }
7290
7291
7292 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7293 PyObject *resultobj;
7294 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7295 PyObject *result;
7296 PyObject * obj0 = 0 ;
7297 char *kwnames[] = {
7298 (char *) "self", NULL
7299 };
7300
7301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7303 if (SWIG_arg_fail(1)) SWIG_fail;
7304 {
7305 PyThreadState* __tstate = wxPyBeginAllowThreads();
7306 result = (PyObject *)wxPoint2D_Get(arg1);
7307
7308 wxPyEndAllowThreads(__tstate);
7309 if (PyErr_Occurred()) SWIG_fail;
7310 }
7311 resultobj = result;
7312 return resultobj;
7313 fail:
7314 return NULL;
7315 }
7316
7317
7318 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7319 PyObject *obj;
7320 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7321 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7322 Py_INCREF(obj);
7323 return Py_BuildValue((char *)"");
7324 }
7325 static int _wrap_DefaultPosition_set(PyObject *) {
7326 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7327 return 1;
7328 }
7329
7330
7331 static PyObject *_wrap_DefaultPosition_get(void) {
7332 PyObject *pyobj;
7333
7334 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7335 return pyobj;
7336 }
7337
7338
7339 static int _wrap_DefaultSize_set(PyObject *) {
7340 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7341 return 1;
7342 }
7343
7344
7345 static PyObject *_wrap_DefaultSize_get(void) {
7346 PyObject *pyobj;
7347
7348 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7349 return pyobj;
7350 }
7351
7352
7353 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7354 PyObject *resultobj;
7355 PyObject *arg1 = (PyObject *) 0 ;
7356 wxPyInputStream *result;
7357 PyObject * obj0 = 0 ;
7358 char *kwnames[] = {
7359 (char *) "p", NULL
7360 };
7361
7362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7363 arg1 = obj0;
7364 {
7365 PyThreadState* __tstate = wxPyBeginAllowThreads();
7366 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7367
7368 wxPyEndAllowThreads(__tstate);
7369 if (PyErr_Occurred()) SWIG_fail;
7370 }
7371 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7372 return resultobj;
7373 fail:
7374 return NULL;
7375 }
7376
7377
7378 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7379 PyObject *resultobj;
7380 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7381 PyObject * obj0 = 0 ;
7382 char *kwnames[] = {
7383 (char *) "self", NULL
7384 };
7385
7386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7388 if (SWIG_arg_fail(1)) SWIG_fail;
7389 {
7390 PyThreadState* __tstate = wxPyBeginAllowThreads();
7391 delete arg1;
7392
7393 wxPyEndAllowThreads(__tstate);
7394 if (PyErr_Occurred()) SWIG_fail;
7395 }
7396 Py_INCREF(Py_None); resultobj = Py_None;
7397 return resultobj;
7398 fail:
7399 return NULL;
7400 }
7401
7402
7403 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7404 PyObject *resultobj;
7405 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7406 PyObject * obj0 = 0 ;
7407 char *kwnames[] = {
7408 (char *) "self", NULL
7409 };
7410
7411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7413 if (SWIG_arg_fail(1)) SWIG_fail;
7414 {
7415 PyThreadState* __tstate = wxPyBeginAllowThreads();
7416 (arg1)->close();
7417
7418 wxPyEndAllowThreads(__tstate);
7419 if (PyErr_Occurred()) SWIG_fail;
7420 }
7421 Py_INCREF(Py_None); resultobj = Py_None;
7422 return resultobj;
7423 fail:
7424 return NULL;
7425 }
7426
7427
7428 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7429 PyObject *resultobj;
7430 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7431 PyObject * obj0 = 0 ;
7432 char *kwnames[] = {
7433 (char *) "self", NULL
7434 };
7435
7436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7438 if (SWIG_arg_fail(1)) SWIG_fail;
7439 {
7440 PyThreadState* __tstate = wxPyBeginAllowThreads();
7441 (arg1)->flush();
7442
7443 wxPyEndAllowThreads(__tstate);
7444 if (PyErr_Occurred()) SWIG_fail;
7445 }
7446 Py_INCREF(Py_None); resultobj = Py_None;
7447 return resultobj;
7448 fail:
7449 return NULL;
7450 }
7451
7452
7453 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7454 PyObject *resultobj;
7455 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7456 bool result;
7457 PyObject * obj0 = 0 ;
7458 char *kwnames[] = {
7459 (char *) "self", NULL
7460 };
7461
7462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7463 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7464 if (SWIG_arg_fail(1)) SWIG_fail;
7465 {
7466 PyThreadState* __tstate = wxPyBeginAllowThreads();
7467 result = (bool)(arg1)->eof();
7468
7469 wxPyEndAllowThreads(__tstate);
7470 if (PyErr_Occurred()) SWIG_fail;
7471 }
7472 {
7473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7474 }
7475 return resultobj;
7476 fail:
7477 return NULL;
7478 }
7479
7480
7481 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7482 PyObject *resultobj;
7483 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7484 int arg2 = (int) -1 ;
7485 PyObject *result;
7486 PyObject * obj0 = 0 ;
7487 PyObject * obj1 = 0 ;
7488 char *kwnames[] = {
7489 (char *) "self",(char *) "size", NULL
7490 };
7491
7492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7494 if (SWIG_arg_fail(1)) SWIG_fail;
7495 if (obj1) {
7496 {
7497 arg2 = (int)(SWIG_As_int(obj1));
7498 if (SWIG_arg_fail(2)) SWIG_fail;
7499 }
7500 }
7501 {
7502 PyThreadState* __tstate = wxPyBeginAllowThreads();
7503 result = (PyObject *)(arg1)->read(arg2);
7504
7505 wxPyEndAllowThreads(__tstate);
7506 if (PyErr_Occurred()) SWIG_fail;
7507 }
7508 resultobj = result;
7509 return resultobj;
7510 fail:
7511 return NULL;
7512 }
7513
7514
7515 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7516 PyObject *resultobj;
7517 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7518 int arg2 = (int) -1 ;
7519 PyObject *result;
7520 PyObject * obj0 = 0 ;
7521 PyObject * obj1 = 0 ;
7522 char *kwnames[] = {
7523 (char *) "self",(char *) "size", NULL
7524 };
7525
7526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7528 if (SWIG_arg_fail(1)) SWIG_fail;
7529 if (obj1) {
7530 {
7531 arg2 = (int)(SWIG_As_int(obj1));
7532 if (SWIG_arg_fail(2)) SWIG_fail;
7533 }
7534 }
7535 {
7536 PyThreadState* __tstate = wxPyBeginAllowThreads();
7537 result = (PyObject *)(arg1)->readline(arg2);
7538
7539 wxPyEndAllowThreads(__tstate);
7540 if (PyErr_Occurred()) SWIG_fail;
7541 }
7542 resultobj = result;
7543 return resultobj;
7544 fail:
7545 return NULL;
7546 }
7547
7548
7549 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7550 PyObject *resultobj;
7551 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7552 int arg2 = (int) -1 ;
7553 PyObject *result;
7554 PyObject * obj0 = 0 ;
7555 PyObject * obj1 = 0 ;
7556 char *kwnames[] = {
7557 (char *) "self",(char *) "sizehint", NULL
7558 };
7559
7560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7562 if (SWIG_arg_fail(1)) SWIG_fail;
7563 if (obj1) {
7564 {
7565 arg2 = (int)(SWIG_As_int(obj1));
7566 if (SWIG_arg_fail(2)) SWIG_fail;
7567 }
7568 }
7569 {
7570 PyThreadState* __tstate = wxPyBeginAllowThreads();
7571 result = (PyObject *)(arg1)->readlines(arg2);
7572
7573 wxPyEndAllowThreads(__tstate);
7574 if (PyErr_Occurred()) SWIG_fail;
7575 }
7576 resultobj = result;
7577 return resultobj;
7578 fail:
7579 return NULL;
7580 }
7581
7582
7583 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7584 PyObject *resultobj;
7585 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7586 int arg2 ;
7587 int arg3 = (int) 0 ;
7588 PyObject * obj0 = 0 ;
7589 PyObject * obj1 = 0 ;
7590 PyObject * obj2 = 0 ;
7591 char *kwnames[] = {
7592 (char *) "self",(char *) "offset",(char *) "whence", NULL
7593 };
7594
7595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7597 if (SWIG_arg_fail(1)) SWIG_fail;
7598 {
7599 arg2 = (int)(SWIG_As_int(obj1));
7600 if (SWIG_arg_fail(2)) SWIG_fail;
7601 }
7602 if (obj2) {
7603 {
7604 arg3 = (int)(SWIG_As_int(obj2));
7605 if (SWIG_arg_fail(3)) SWIG_fail;
7606 }
7607 }
7608 {
7609 PyThreadState* __tstate = wxPyBeginAllowThreads();
7610 (arg1)->seek(arg2,arg3);
7611
7612 wxPyEndAllowThreads(__tstate);
7613 if (PyErr_Occurred()) SWIG_fail;
7614 }
7615 Py_INCREF(Py_None); resultobj = Py_None;
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7623 PyObject *resultobj;
7624 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7625 int result;
7626 PyObject * obj0 = 0 ;
7627 char *kwnames[] = {
7628 (char *) "self", NULL
7629 };
7630
7631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",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 = (int)(arg1)->tell();
7637
7638 wxPyEndAllowThreads(__tstate);
7639 if (PyErr_Occurred()) SWIG_fail;
7640 }
7641 {
7642 resultobj = SWIG_From_int((int)(result));
7643 }
7644 return resultobj;
7645 fail:
7646 return NULL;
7647 }
7648
7649
7650 static PyObject *_wrap_InputStream_Peek(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_Peek",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)->Peek();
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_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7679 PyObject *resultobj;
7680 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7681 char result;
7682 PyObject * obj0 = 0 ;
7683 char *kwnames[] = {
7684 (char *) "self", NULL
7685 };
7686
7687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",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 = (char)(arg1)->GetC();
7693
7694 wxPyEndAllowThreads(__tstate);
7695 if (PyErr_Occurred()) SWIG_fail;
7696 }
7697 {
7698 resultobj = SWIG_From_char((char)(result));
7699 }
7700 return resultobj;
7701 fail:
7702 return NULL;
7703 }
7704
7705
7706 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7707 PyObject *resultobj;
7708 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7709 size_t result;
7710 PyObject * obj0 = 0 ;
7711 char *kwnames[] = {
7712 (char *) "self", NULL
7713 };
7714
7715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",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 = (size_t)(arg1)->LastRead();
7721
7722 wxPyEndAllowThreads(__tstate);
7723 if (PyErr_Occurred()) SWIG_fail;
7724 }
7725 {
7726 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7727 }
7728 return resultobj;
7729 fail:
7730 return NULL;
7731 }
7732
7733
7734 static PyObject *_wrap_InputStream_CanRead(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_CanRead",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)->CanRead();
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_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7763 PyObject *resultobj;
7764 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7765 bool result;
7766 PyObject * obj0 = 0 ;
7767 char *kwnames[] = {
7768 (char *) "self", NULL
7769 };
7770
7771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7773 if (SWIG_arg_fail(1)) SWIG_fail;
7774 {
7775 PyThreadState* __tstate = wxPyBeginAllowThreads();
7776 result = (bool)(arg1)->Eof();
7777
7778 wxPyEndAllowThreads(__tstate);
7779 if (PyErr_Occurred()) SWIG_fail;
7780 }
7781 {
7782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7783 }
7784 return resultobj;
7785 fail:
7786 return NULL;
7787 }
7788
7789
7790 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7791 PyObject *resultobj;
7792 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7793 char arg2 ;
7794 bool result;
7795 PyObject * obj0 = 0 ;
7796 PyObject * obj1 = 0 ;
7797 char *kwnames[] = {
7798 (char *) "self",(char *) "c", NULL
7799 };
7800
7801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7803 if (SWIG_arg_fail(1)) SWIG_fail;
7804 {
7805 arg2 = (char)(SWIG_As_char(obj1));
7806 if (SWIG_arg_fail(2)) SWIG_fail;
7807 }
7808 {
7809 PyThreadState* __tstate = wxPyBeginAllowThreads();
7810 result = (bool)(arg1)->Ungetch(arg2);
7811
7812 wxPyEndAllowThreads(__tstate);
7813 if (PyErr_Occurred()) SWIG_fail;
7814 }
7815 {
7816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7817 }
7818 return resultobj;
7819 fail:
7820 return NULL;
7821 }
7822
7823
7824 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7825 PyObject *resultobj;
7826 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7827 long arg2 ;
7828 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7829 long result;
7830 PyObject * obj0 = 0 ;
7831 PyObject * obj1 = 0 ;
7832 PyObject * obj2 = 0 ;
7833 char *kwnames[] = {
7834 (char *) "self",(char *) "pos",(char *) "mode", NULL
7835 };
7836
7837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7839 if (SWIG_arg_fail(1)) SWIG_fail;
7840 {
7841 arg2 = (long)(SWIG_As_long(obj1));
7842 if (SWIG_arg_fail(2)) SWIG_fail;
7843 }
7844 if (obj2) {
7845 {
7846 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7847 if (SWIG_arg_fail(3)) SWIG_fail;
7848 }
7849 }
7850 {
7851 PyThreadState* __tstate = wxPyBeginAllowThreads();
7852 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
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 *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7867 PyObject *resultobj;
7868 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7869 long result;
7870 PyObject * obj0 = 0 ;
7871 char *kwnames[] = {
7872 (char *) "self", NULL
7873 };
7874
7875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7877 if (SWIG_arg_fail(1)) SWIG_fail;
7878 {
7879 PyThreadState* __tstate = wxPyBeginAllowThreads();
7880 result = (long)(arg1)->TellI();
7881
7882 wxPyEndAllowThreads(__tstate);
7883 if (PyErr_Occurred()) SWIG_fail;
7884 }
7885 {
7886 resultobj = SWIG_From_long((long)(result));
7887 }
7888 return resultobj;
7889 fail:
7890 return NULL;
7891 }
7892
7893
7894 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7895 PyObject *obj;
7896 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7897 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7898 Py_INCREF(obj);
7899 return Py_BuildValue((char *)"");
7900 }
7901 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7902 PyObject *resultobj;
7903 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7904 PyObject *arg2 = (PyObject *) 0 ;
7905 PyObject * obj0 = 0 ;
7906 PyObject * obj1 = 0 ;
7907 char *kwnames[] = {
7908 (char *) "self",(char *) "obj", NULL
7909 };
7910
7911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7913 if (SWIG_arg_fail(1)) SWIG_fail;
7914 arg2 = obj1;
7915 {
7916 PyThreadState* __tstate = wxPyBeginAllowThreads();
7917 wxOutputStream_write(arg1,arg2);
7918
7919 wxPyEndAllowThreads(__tstate);
7920 if (PyErr_Occurred()) SWIG_fail;
7921 }
7922 Py_INCREF(Py_None); resultobj = Py_None;
7923 return resultobj;
7924 fail:
7925 return NULL;
7926 }
7927
7928
7929 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7930 PyObject *obj;
7931 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7932 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7933 Py_INCREF(obj);
7934 return Py_BuildValue((char *)"");
7935 }
7936 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7937 PyObject *resultobj;
7938 wxInputStream *arg1 = (wxInputStream *) 0 ;
7939 wxString *arg2 = 0 ;
7940 wxString *arg3 = 0 ;
7941 wxString *arg4 = 0 ;
7942 wxDateTime arg5 ;
7943 wxFSFile *result;
7944 wxPyInputStream *temp1 ;
7945 bool temp2 = false ;
7946 bool temp3 = false ;
7947 bool temp4 = false ;
7948 PyObject * obj0 = 0 ;
7949 PyObject * obj1 = 0 ;
7950 PyObject * obj2 = 0 ;
7951 PyObject * obj3 = 0 ;
7952 PyObject * obj4 = 0 ;
7953 char *kwnames[] = {
7954 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7955 };
7956
7957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7958 {
7959 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7960 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7961 } else {
7962 PyErr_Clear(); // clear the failure of the wxPyConvert above
7963 arg1 = wxPyCBInputStream_create(obj0, true);
7964 if (arg1 == NULL) {
7965 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7966 SWIG_fail;
7967 }
7968 }
7969 }
7970 {
7971 arg2 = wxString_in_helper(obj1);
7972 if (arg2 == NULL) SWIG_fail;
7973 temp2 = true;
7974 }
7975 {
7976 arg3 = wxString_in_helper(obj2);
7977 if (arg3 == NULL) SWIG_fail;
7978 temp3 = true;
7979 }
7980 {
7981 arg4 = wxString_in_helper(obj3);
7982 if (arg4 == NULL) SWIG_fail;
7983 temp4 = true;
7984 }
7985 {
7986 wxDateTime * argp;
7987 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7988 if (SWIG_arg_fail(5)) SWIG_fail;
7989 if (argp == NULL) {
7990 SWIG_null_ref("wxDateTime");
7991 }
7992 if (SWIG_arg_fail(5)) SWIG_fail;
7993 arg5 = *argp;
7994 }
7995 {
7996 PyThreadState* __tstate = wxPyBeginAllowThreads();
7997 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7998
7999 wxPyEndAllowThreads(__tstate);
8000 if (PyErr_Occurred()) SWIG_fail;
8001 }
8002 {
8003 resultobj = wxPyMake_wxObject(result, 1);
8004 }
8005 {
8006 if (temp2)
8007 delete arg2;
8008 }
8009 {
8010 if (temp3)
8011 delete arg3;
8012 }
8013 {
8014 if (temp4)
8015 delete arg4;
8016 }
8017 return resultobj;
8018 fail:
8019 {
8020 if (temp2)
8021 delete arg2;
8022 }
8023 {
8024 if (temp3)
8025 delete arg3;
8026 }
8027 {
8028 if (temp4)
8029 delete arg4;
8030 }
8031 return NULL;
8032 }
8033
8034
8035 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8036 PyObject *resultobj;
8037 wxFSFile *arg1 = (wxFSFile *) 0 ;
8038 PyObject * obj0 = 0 ;
8039 char *kwnames[] = {
8040 (char *) "self", NULL
8041 };
8042
8043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8045 if (SWIG_arg_fail(1)) SWIG_fail;
8046 {
8047 PyThreadState* __tstate = wxPyBeginAllowThreads();
8048 delete arg1;
8049
8050 wxPyEndAllowThreads(__tstate);
8051 if (PyErr_Occurred()) SWIG_fail;
8052 }
8053 Py_INCREF(Py_None); resultobj = Py_None;
8054 return resultobj;
8055 fail:
8056 return NULL;
8057 }
8058
8059
8060 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8061 PyObject *resultobj;
8062 wxFSFile *arg1 = (wxFSFile *) 0 ;
8063 wxInputStream *result;
8064 PyObject * obj0 = 0 ;
8065 char *kwnames[] = {
8066 (char *) "self", NULL
8067 };
8068
8069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8071 if (SWIG_arg_fail(1)) SWIG_fail;
8072 {
8073 PyThreadState* __tstate = wxPyBeginAllowThreads();
8074 result = (wxInputStream *)(arg1)->GetStream();
8075
8076 wxPyEndAllowThreads(__tstate);
8077 if (PyErr_Occurred()) SWIG_fail;
8078 }
8079 {
8080 wxPyInputStream * _ptr = NULL;
8081
8082 if (result) {
8083 _ptr = new wxPyInputStream(result);
8084 }
8085 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8086 }
8087 return resultobj;
8088 fail:
8089 return NULL;
8090 }
8091
8092
8093 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8094 PyObject *resultobj;
8095 wxFSFile *arg1 = (wxFSFile *) 0 ;
8096 wxString *result;
8097 PyObject * obj0 = 0 ;
8098 char *kwnames[] = {
8099 (char *) "self", NULL
8100 };
8101
8102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8104 if (SWIG_arg_fail(1)) SWIG_fail;
8105 {
8106 PyThreadState* __tstate = wxPyBeginAllowThreads();
8107 {
8108 wxString const &_result_ref = (arg1)->GetMimeType();
8109 result = (wxString *) &_result_ref;
8110 }
8111
8112 wxPyEndAllowThreads(__tstate);
8113 if (PyErr_Occurred()) SWIG_fail;
8114 }
8115 {
8116 #if wxUSE_UNICODE
8117 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8118 #else
8119 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8120 #endif
8121 }
8122 return resultobj;
8123 fail:
8124 return NULL;
8125 }
8126
8127
8128 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8129 PyObject *resultobj;
8130 wxFSFile *arg1 = (wxFSFile *) 0 ;
8131 wxString *result;
8132 PyObject * obj0 = 0 ;
8133 char *kwnames[] = {
8134 (char *) "self", NULL
8135 };
8136
8137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8139 if (SWIG_arg_fail(1)) SWIG_fail;
8140 {
8141 PyThreadState* __tstate = wxPyBeginAllowThreads();
8142 {
8143 wxString const &_result_ref = (arg1)->GetLocation();
8144 result = (wxString *) &_result_ref;
8145 }
8146
8147 wxPyEndAllowThreads(__tstate);
8148 if (PyErr_Occurred()) SWIG_fail;
8149 }
8150 {
8151 #if wxUSE_UNICODE
8152 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8153 #else
8154 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8155 #endif
8156 }
8157 return resultobj;
8158 fail:
8159 return NULL;
8160 }
8161
8162
8163 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8164 PyObject *resultobj;
8165 wxFSFile *arg1 = (wxFSFile *) 0 ;
8166 wxString *result;
8167 PyObject * obj0 = 0 ;
8168 char *kwnames[] = {
8169 (char *) "self", NULL
8170 };
8171
8172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8174 if (SWIG_arg_fail(1)) SWIG_fail;
8175 {
8176 PyThreadState* __tstate = wxPyBeginAllowThreads();
8177 {
8178 wxString const &_result_ref = (arg1)->GetAnchor();
8179 result = (wxString *) &_result_ref;
8180 }
8181
8182 wxPyEndAllowThreads(__tstate);
8183 if (PyErr_Occurred()) SWIG_fail;
8184 }
8185 {
8186 #if wxUSE_UNICODE
8187 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8188 #else
8189 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8190 #endif
8191 }
8192 return resultobj;
8193 fail:
8194 return NULL;
8195 }
8196
8197
8198 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8199 PyObject *resultobj;
8200 wxFSFile *arg1 = (wxFSFile *) 0 ;
8201 wxDateTime result;
8202 PyObject * obj0 = 0 ;
8203 char *kwnames[] = {
8204 (char *) "self", NULL
8205 };
8206
8207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8209 if (SWIG_arg_fail(1)) SWIG_fail;
8210 {
8211 PyThreadState* __tstate = wxPyBeginAllowThreads();
8212 result = (arg1)->GetModificationTime();
8213
8214 wxPyEndAllowThreads(__tstate);
8215 if (PyErr_Occurred()) SWIG_fail;
8216 }
8217 {
8218 wxDateTime * resultptr;
8219 resultptr = new wxDateTime((wxDateTime &)(result));
8220 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8221 }
8222 return resultobj;
8223 fail:
8224 return NULL;
8225 }
8226
8227
8228 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8229 PyObject *obj;
8230 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8231 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8232 Py_INCREF(obj);
8233 return Py_BuildValue((char *)"");
8234 }
8235 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8236 PyObject *obj;
8237 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8238 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8239 Py_INCREF(obj);
8240 return Py_BuildValue((char *)"");
8241 }
8242 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8243 PyObject *resultobj;
8244 wxPyFileSystemHandler *result;
8245 char *kwnames[] = {
8246 NULL
8247 };
8248
8249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8250 {
8251 PyThreadState* __tstate = wxPyBeginAllowThreads();
8252 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8253
8254 wxPyEndAllowThreads(__tstate);
8255 if (PyErr_Occurred()) SWIG_fail;
8256 }
8257 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8258 return resultobj;
8259 fail:
8260 return NULL;
8261 }
8262
8263
8264 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8265 PyObject *resultobj;
8266 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8267 PyObject *arg2 = (PyObject *) 0 ;
8268 PyObject *arg3 = (PyObject *) 0 ;
8269 PyObject * obj0 = 0 ;
8270 PyObject * obj1 = 0 ;
8271 PyObject * obj2 = 0 ;
8272 char *kwnames[] = {
8273 (char *) "self",(char *) "self",(char *) "_class", NULL
8274 };
8275
8276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8278 if (SWIG_arg_fail(1)) SWIG_fail;
8279 arg2 = obj1;
8280 arg3 = obj2;
8281 {
8282 PyThreadState* __tstate = wxPyBeginAllowThreads();
8283 (arg1)->_setCallbackInfo(arg2,arg3);
8284
8285 wxPyEndAllowThreads(__tstate);
8286 if (PyErr_Occurred()) SWIG_fail;
8287 }
8288 Py_INCREF(Py_None); resultobj = Py_None;
8289 return resultobj;
8290 fail:
8291 return NULL;
8292 }
8293
8294
8295 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8296 PyObject *resultobj;
8297 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8298 wxString *arg2 = 0 ;
8299 bool result;
8300 bool temp2 = false ;
8301 PyObject * obj0 = 0 ;
8302 PyObject * obj1 = 0 ;
8303 char *kwnames[] = {
8304 (char *) "self",(char *) "location", NULL
8305 };
8306
8307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8309 if (SWIG_arg_fail(1)) SWIG_fail;
8310 {
8311 arg2 = wxString_in_helper(obj1);
8312 if (arg2 == NULL) SWIG_fail;
8313 temp2 = true;
8314 }
8315 {
8316 PyThreadState* __tstate = wxPyBeginAllowThreads();
8317 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8318
8319 wxPyEndAllowThreads(__tstate);
8320 if (PyErr_Occurred()) SWIG_fail;
8321 }
8322 {
8323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8324 }
8325 {
8326 if (temp2)
8327 delete arg2;
8328 }
8329 return resultobj;
8330 fail:
8331 {
8332 if (temp2)
8333 delete arg2;
8334 }
8335 return NULL;
8336 }
8337
8338
8339 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8340 PyObject *resultobj;
8341 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8342 wxFileSystem *arg2 = 0 ;
8343 wxString *arg3 = 0 ;
8344 wxFSFile *result;
8345 bool temp3 = false ;
8346 PyObject * obj0 = 0 ;
8347 PyObject * obj1 = 0 ;
8348 PyObject * obj2 = 0 ;
8349 char *kwnames[] = {
8350 (char *) "self",(char *) "fs",(char *) "location", NULL
8351 };
8352
8353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8355 if (SWIG_arg_fail(1)) SWIG_fail;
8356 {
8357 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8358 if (SWIG_arg_fail(2)) SWIG_fail;
8359 if (arg2 == NULL) {
8360 SWIG_null_ref("wxFileSystem");
8361 }
8362 if (SWIG_arg_fail(2)) SWIG_fail;
8363 }
8364 {
8365 arg3 = wxString_in_helper(obj2);
8366 if (arg3 == NULL) SWIG_fail;
8367 temp3 = true;
8368 }
8369 {
8370 PyThreadState* __tstate = wxPyBeginAllowThreads();
8371 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8372
8373 wxPyEndAllowThreads(__tstate);
8374 if (PyErr_Occurred()) SWIG_fail;
8375 }
8376 {
8377 resultobj = wxPyMake_wxObject(result, 1);
8378 }
8379 {
8380 if (temp3)
8381 delete arg3;
8382 }
8383 return resultobj;
8384 fail:
8385 {
8386 if (temp3)
8387 delete arg3;
8388 }
8389 return NULL;
8390 }
8391
8392
8393 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8394 PyObject *resultobj;
8395 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8396 wxString *arg2 = 0 ;
8397 int arg3 = (int) 0 ;
8398 wxString result;
8399 bool temp2 = false ;
8400 PyObject * obj0 = 0 ;
8401 PyObject * obj1 = 0 ;
8402 PyObject * obj2 = 0 ;
8403 char *kwnames[] = {
8404 (char *) "self",(char *) "spec",(char *) "flags", NULL
8405 };
8406
8407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8409 if (SWIG_arg_fail(1)) SWIG_fail;
8410 {
8411 arg2 = wxString_in_helper(obj1);
8412 if (arg2 == NULL) SWIG_fail;
8413 temp2 = true;
8414 }
8415 if (obj2) {
8416 {
8417 arg3 = (int)(SWIG_As_int(obj2));
8418 if (SWIG_arg_fail(3)) SWIG_fail;
8419 }
8420 }
8421 {
8422 PyThreadState* __tstate = wxPyBeginAllowThreads();
8423 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8424
8425 wxPyEndAllowThreads(__tstate);
8426 if (PyErr_Occurred()) SWIG_fail;
8427 }
8428 {
8429 #if wxUSE_UNICODE
8430 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8431 #else
8432 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8433 #endif
8434 }
8435 {
8436 if (temp2)
8437 delete arg2;
8438 }
8439 return resultobj;
8440 fail:
8441 {
8442 if (temp2)
8443 delete arg2;
8444 }
8445 return NULL;
8446 }
8447
8448
8449 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8450 PyObject *resultobj;
8451 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8452 wxString result;
8453 PyObject * obj0 = 0 ;
8454 char *kwnames[] = {
8455 (char *) "self", NULL
8456 };
8457
8458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8460 if (SWIG_arg_fail(1)) SWIG_fail;
8461 {
8462 PyThreadState* __tstate = wxPyBeginAllowThreads();
8463 result = (arg1)->FindNext();
8464
8465 wxPyEndAllowThreads(__tstate);
8466 if (PyErr_Occurred()) SWIG_fail;
8467 }
8468 {
8469 #if wxUSE_UNICODE
8470 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8471 #else
8472 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8473 #endif
8474 }
8475 return resultobj;
8476 fail:
8477 return NULL;
8478 }
8479
8480
8481 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8482 PyObject *resultobj;
8483 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8484 wxString *arg2 = 0 ;
8485 wxString result;
8486 bool temp2 = false ;
8487 PyObject * obj0 = 0 ;
8488 PyObject * obj1 = 0 ;
8489 char *kwnames[] = {
8490 (char *) "self",(char *) "location", NULL
8491 };
8492
8493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8495 if (SWIG_arg_fail(1)) SWIG_fail;
8496 {
8497 arg2 = wxString_in_helper(obj1);
8498 if (arg2 == NULL) SWIG_fail;
8499 temp2 = true;
8500 }
8501 {
8502 PyThreadState* __tstate = wxPyBeginAllowThreads();
8503 result = (arg1)->GetProtocol((wxString const &)*arg2);
8504
8505 wxPyEndAllowThreads(__tstate);
8506 if (PyErr_Occurred()) SWIG_fail;
8507 }
8508 {
8509 #if wxUSE_UNICODE
8510 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8511 #else
8512 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8513 #endif
8514 }
8515 {
8516 if (temp2)
8517 delete arg2;
8518 }
8519 return resultobj;
8520 fail:
8521 {
8522 if (temp2)
8523 delete arg2;
8524 }
8525 return NULL;
8526 }
8527
8528
8529 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8530 PyObject *resultobj;
8531 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8532 wxString *arg2 = 0 ;
8533 wxString result;
8534 bool temp2 = false ;
8535 PyObject * obj0 = 0 ;
8536 PyObject * obj1 = 0 ;
8537 char *kwnames[] = {
8538 (char *) "self",(char *) "location", NULL
8539 };
8540
8541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8543 if (SWIG_arg_fail(1)) SWIG_fail;
8544 {
8545 arg2 = wxString_in_helper(obj1);
8546 if (arg2 == NULL) SWIG_fail;
8547 temp2 = true;
8548 }
8549 {
8550 PyThreadState* __tstate = wxPyBeginAllowThreads();
8551 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8552
8553 wxPyEndAllowThreads(__tstate);
8554 if (PyErr_Occurred()) SWIG_fail;
8555 }
8556 {
8557 #if wxUSE_UNICODE
8558 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8559 #else
8560 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8561 #endif
8562 }
8563 {
8564 if (temp2)
8565 delete arg2;
8566 }
8567 return resultobj;
8568 fail:
8569 {
8570 if (temp2)
8571 delete arg2;
8572 }
8573 return NULL;
8574 }
8575
8576
8577 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8578 PyObject *resultobj;
8579 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8580 wxString *arg2 = 0 ;
8581 wxString result;
8582 bool temp2 = false ;
8583 PyObject * obj0 = 0 ;
8584 PyObject * obj1 = 0 ;
8585 char *kwnames[] = {
8586 (char *) "self",(char *) "location", NULL
8587 };
8588
8589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8591 if (SWIG_arg_fail(1)) SWIG_fail;
8592 {
8593 arg2 = wxString_in_helper(obj1);
8594 if (arg2 == NULL) SWIG_fail;
8595 temp2 = true;
8596 }
8597 {
8598 PyThreadState* __tstate = wxPyBeginAllowThreads();
8599 result = (arg1)->GetAnchor((wxString const &)*arg2);
8600
8601 wxPyEndAllowThreads(__tstate);
8602 if (PyErr_Occurred()) SWIG_fail;
8603 }
8604 {
8605 #if wxUSE_UNICODE
8606 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8607 #else
8608 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8609 #endif
8610 }
8611 {
8612 if (temp2)
8613 delete arg2;
8614 }
8615 return resultobj;
8616 fail:
8617 {
8618 if (temp2)
8619 delete arg2;
8620 }
8621 return NULL;
8622 }
8623
8624
8625 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8626 PyObject *resultobj;
8627 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8628 wxString *arg2 = 0 ;
8629 wxString result;
8630 bool temp2 = false ;
8631 PyObject * obj0 = 0 ;
8632 PyObject * obj1 = 0 ;
8633 char *kwnames[] = {
8634 (char *) "self",(char *) "location", NULL
8635 };
8636
8637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8639 if (SWIG_arg_fail(1)) SWIG_fail;
8640 {
8641 arg2 = wxString_in_helper(obj1);
8642 if (arg2 == NULL) SWIG_fail;
8643 temp2 = true;
8644 }
8645 {
8646 PyThreadState* __tstate = wxPyBeginAllowThreads();
8647 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8648
8649 wxPyEndAllowThreads(__tstate);
8650 if (PyErr_Occurred()) SWIG_fail;
8651 }
8652 {
8653 #if wxUSE_UNICODE
8654 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8655 #else
8656 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8657 #endif
8658 }
8659 {
8660 if (temp2)
8661 delete arg2;
8662 }
8663 return resultobj;
8664 fail:
8665 {
8666 if (temp2)
8667 delete arg2;
8668 }
8669 return NULL;
8670 }
8671
8672
8673 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8674 PyObject *resultobj;
8675 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8676 wxString *arg2 = 0 ;
8677 wxString result;
8678 bool temp2 = false ;
8679 PyObject * obj0 = 0 ;
8680 PyObject * obj1 = 0 ;
8681 char *kwnames[] = {
8682 (char *) "self",(char *) "location", NULL
8683 };
8684
8685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8687 if (SWIG_arg_fail(1)) SWIG_fail;
8688 {
8689 arg2 = wxString_in_helper(obj1);
8690 if (arg2 == NULL) SWIG_fail;
8691 temp2 = true;
8692 }
8693 {
8694 PyThreadState* __tstate = wxPyBeginAllowThreads();
8695 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8696
8697 wxPyEndAllowThreads(__tstate);
8698 if (PyErr_Occurred()) SWIG_fail;
8699 }
8700 {
8701 #if wxUSE_UNICODE
8702 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8703 #else
8704 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8705 #endif
8706 }
8707 {
8708 if (temp2)
8709 delete arg2;
8710 }
8711 return resultobj;
8712 fail:
8713 {
8714 if (temp2)
8715 delete arg2;
8716 }
8717 return NULL;
8718 }
8719
8720
8721 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8722 PyObject *obj;
8723 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8724 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8725 Py_INCREF(obj);
8726 return Py_BuildValue((char *)"");
8727 }
8728 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8729 PyObject *resultobj;
8730 wxFileSystem *result;
8731 char *kwnames[] = {
8732 NULL
8733 };
8734
8735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8736 {
8737 PyThreadState* __tstate = wxPyBeginAllowThreads();
8738 result = (wxFileSystem *)new wxFileSystem();
8739
8740 wxPyEndAllowThreads(__tstate);
8741 if (PyErr_Occurred()) SWIG_fail;
8742 }
8743 {
8744 resultobj = wxPyMake_wxObject(result, 1);
8745 }
8746 return resultobj;
8747 fail:
8748 return NULL;
8749 }
8750
8751
8752 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8753 PyObject *resultobj;
8754 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8755 PyObject * obj0 = 0 ;
8756 char *kwnames[] = {
8757 (char *) "self", NULL
8758 };
8759
8760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8762 if (SWIG_arg_fail(1)) SWIG_fail;
8763 {
8764 PyThreadState* __tstate = wxPyBeginAllowThreads();
8765 delete arg1;
8766
8767 wxPyEndAllowThreads(__tstate);
8768 if (PyErr_Occurred()) SWIG_fail;
8769 }
8770 Py_INCREF(Py_None); resultobj = Py_None;
8771 return resultobj;
8772 fail:
8773 return NULL;
8774 }
8775
8776
8777 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8778 PyObject *resultobj;
8779 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8780 wxString *arg2 = 0 ;
8781 bool arg3 = (bool) false ;
8782 bool temp2 = false ;
8783 PyObject * obj0 = 0 ;
8784 PyObject * obj1 = 0 ;
8785 PyObject * obj2 = 0 ;
8786 char *kwnames[] = {
8787 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8788 };
8789
8790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8792 if (SWIG_arg_fail(1)) SWIG_fail;
8793 {
8794 arg2 = wxString_in_helper(obj1);
8795 if (arg2 == NULL) SWIG_fail;
8796 temp2 = true;
8797 }
8798 if (obj2) {
8799 {
8800 arg3 = (bool)(SWIG_As_bool(obj2));
8801 if (SWIG_arg_fail(3)) SWIG_fail;
8802 }
8803 }
8804 {
8805 PyThreadState* __tstate = wxPyBeginAllowThreads();
8806 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8807
8808 wxPyEndAllowThreads(__tstate);
8809 if (PyErr_Occurred()) SWIG_fail;
8810 }
8811 Py_INCREF(Py_None); resultobj = Py_None;
8812 {
8813 if (temp2)
8814 delete arg2;
8815 }
8816 return resultobj;
8817 fail:
8818 {
8819 if (temp2)
8820 delete arg2;
8821 }
8822 return NULL;
8823 }
8824
8825
8826 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8827 PyObject *resultobj;
8828 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8829 wxString result;
8830 PyObject * obj0 = 0 ;
8831 char *kwnames[] = {
8832 (char *) "self", NULL
8833 };
8834
8835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8837 if (SWIG_arg_fail(1)) SWIG_fail;
8838 {
8839 PyThreadState* __tstate = wxPyBeginAllowThreads();
8840 result = (arg1)->GetPath();
8841
8842 wxPyEndAllowThreads(__tstate);
8843 if (PyErr_Occurred()) SWIG_fail;
8844 }
8845 {
8846 #if wxUSE_UNICODE
8847 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8848 #else
8849 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8850 #endif
8851 }
8852 return resultobj;
8853 fail:
8854 return NULL;
8855 }
8856
8857
8858 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8859 PyObject *resultobj;
8860 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8861 wxString *arg2 = 0 ;
8862 wxFSFile *result;
8863 bool temp2 = false ;
8864 PyObject * obj0 = 0 ;
8865 PyObject * obj1 = 0 ;
8866 char *kwnames[] = {
8867 (char *) "self",(char *) "location", NULL
8868 };
8869
8870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8872 if (SWIG_arg_fail(1)) SWIG_fail;
8873 {
8874 arg2 = wxString_in_helper(obj1);
8875 if (arg2 == NULL) SWIG_fail;
8876 temp2 = true;
8877 }
8878 {
8879 PyThreadState* __tstate = wxPyBeginAllowThreads();
8880 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8881
8882 wxPyEndAllowThreads(__tstate);
8883 if (PyErr_Occurred()) SWIG_fail;
8884 }
8885 {
8886 resultobj = wxPyMake_wxObject(result, 1);
8887 }
8888 {
8889 if (temp2)
8890 delete arg2;
8891 }
8892 return resultobj;
8893 fail:
8894 {
8895 if (temp2)
8896 delete arg2;
8897 }
8898 return NULL;
8899 }
8900
8901
8902 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8903 PyObject *resultobj;
8904 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8905 wxString *arg2 = 0 ;
8906 int arg3 = (int) 0 ;
8907 wxString result;
8908 bool temp2 = false ;
8909 PyObject * obj0 = 0 ;
8910 PyObject * obj1 = 0 ;
8911 PyObject * obj2 = 0 ;
8912 char *kwnames[] = {
8913 (char *) "self",(char *) "spec",(char *) "flags", NULL
8914 };
8915
8916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8918 if (SWIG_arg_fail(1)) SWIG_fail;
8919 {
8920 arg2 = wxString_in_helper(obj1);
8921 if (arg2 == NULL) SWIG_fail;
8922 temp2 = true;
8923 }
8924 if (obj2) {
8925 {
8926 arg3 = (int)(SWIG_As_int(obj2));
8927 if (SWIG_arg_fail(3)) SWIG_fail;
8928 }
8929 }
8930 {
8931 PyThreadState* __tstate = wxPyBeginAllowThreads();
8932 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8933
8934 wxPyEndAllowThreads(__tstate);
8935 if (PyErr_Occurred()) SWIG_fail;
8936 }
8937 {
8938 #if wxUSE_UNICODE
8939 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8940 #else
8941 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8942 #endif
8943 }
8944 {
8945 if (temp2)
8946 delete arg2;
8947 }
8948 return resultobj;
8949 fail:
8950 {
8951 if (temp2)
8952 delete arg2;
8953 }
8954 return NULL;
8955 }
8956
8957
8958 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8959 PyObject *resultobj;
8960 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8961 wxString result;
8962 PyObject * obj0 = 0 ;
8963 char *kwnames[] = {
8964 (char *) "self", NULL
8965 };
8966
8967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8969 if (SWIG_arg_fail(1)) SWIG_fail;
8970 {
8971 PyThreadState* __tstate = wxPyBeginAllowThreads();
8972 result = (arg1)->FindNext();
8973
8974 wxPyEndAllowThreads(__tstate);
8975 if (PyErr_Occurred()) SWIG_fail;
8976 }
8977 {
8978 #if wxUSE_UNICODE
8979 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8980 #else
8981 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8982 #endif
8983 }
8984 return resultobj;
8985 fail:
8986 return NULL;
8987 }
8988
8989
8990 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8991 PyObject *resultobj;
8992 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8993 PyObject * obj0 = 0 ;
8994 char *kwnames[] = {
8995 (char *) "handler", NULL
8996 };
8997
8998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9000 if (SWIG_arg_fail(1)) SWIG_fail;
9001 {
9002 PyThreadState* __tstate = wxPyBeginAllowThreads();
9003 wxFileSystem::AddHandler(arg1);
9004
9005 wxPyEndAllowThreads(__tstate);
9006 if (PyErr_Occurred()) SWIG_fail;
9007 }
9008 Py_INCREF(Py_None); resultobj = Py_None;
9009 return resultobj;
9010 fail:
9011 return NULL;
9012 }
9013
9014
9015 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9016 PyObject *resultobj;
9017 char *kwnames[] = {
9018 NULL
9019 };
9020
9021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9022 {
9023 PyThreadState* __tstate = wxPyBeginAllowThreads();
9024 wxFileSystem::CleanUpHandlers();
9025
9026 wxPyEndAllowThreads(__tstate);
9027 if (PyErr_Occurred()) SWIG_fail;
9028 }
9029 Py_INCREF(Py_None); resultobj = Py_None;
9030 return resultobj;
9031 fail:
9032 return NULL;
9033 }
9034
9035
9036 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9037 PyObject *resultobj;
9038 wxString *arg1 = 0 ;
9039 wxString result;
9040 bool temp1 = false ;
9041 PyObject * obj0 = 0 ;
9042 char *kwnames[] = {
9043 (char *) "filename", NULL
9044 };
9045
9046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9047 {
9048 arg1 = wxString_in_helper(obj0);
9049 if (arg1 == NULL) SWIG_fail;
9050 temp1 = true;
9051 }
9052 {
9053 PyThreadState* __tstate = wxPyBeginAllowThreads();
9054 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9055
9056 wxPyEndAllowThreads(__tstate);
9057 if (PyErr_Occurred()) SWIG_fail;
9058 }
9059 {
9060 #if wxUSE_UNICODE
9061 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9062 #else
9063 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9064 #endif
9065 }
9066 {
9067 if (temp1)
9068 delete arg1;
9069 }
9070 return resultobj;
9071 fail:
9072 {
9073 if (temp1)
9074 delete arg1;
9075 }
9076 return NULL;
9077 }
9078
9079
9080 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9081 PyObject *resultobj;
9082 wxString *arg1 = 0 ;
9083 wxString result;
9084 bool temp1 = false ;
9085 PyObject * obj0 = 0 ;
9086 char *kwnames[] = {
9087 (char *) "url", NULL
9088 };
9089
9090 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9091 {
9092 arg1 = wxString_in_helper(obj0);
9093 if (arg1 == NULL) SWIG_fail;
9094 temp1 = true;
9095 }
9096 {
9097 PyThreadState* __tstate = wxPyBeginAllowThreads();
9098 result = FileSystem_URLToFileName((wxString const &)*arg1);
9099
9100 wxPyEndAllowThreads(__tstate);
9101 if (PyErr_Occurred()) SWIG_fail;
9102 }
9103 {
9104 #if wxUSE_UNICODE
9105 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9106 #else
9107 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9108 #endif
9109 }
9110 {
9111 if (temp1)
9112 delete arg1;
9113 }
9114 return resultobj;
9115 fail:
9116 {
9117 if (temp1)
9118 delete arg1;
9119 }
9120 return NULL;
9121 }
9122
9123
9124 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9125 PyObject *obj;
9126 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9127 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9128 Py_INCREF(obj);
9129 return Py_BuildValue((char *)"");
9130 }
9131 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9132 PyObject *resultobj;
9133 wxInternetFSHandler *result;
9134 char *kwnames[] = {
9135 NULL
9136 };
9137
9138 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9139 {
9140 PyThreadState* __tstate = wxPyBeginAllowThreads();
9141 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9142
9143 wxPyEndAllowThreads(__tstate);
9144 if (PyErr_Occurred()) SWIG_fail;
9145 }
9146 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9147 return resultobj;
9148 fail:
9149 return NULL;
9150 }
9151
9152
9153 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9154 PyObject *resultobj;
9155 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9156 wxString *arg2 = 0 ;
9157 bool result;
9158 bool temp2 = false ;
9159 PyObject * obj0 = 0 ;
9160 PyObject * obj1 = 0 ;
9161 char *kwnames[] = {
9162 (char *) "self",(char *) "location", NULL
9163 };
9164
9165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9167 if (SWIG_arg_fail(1)) SWIG_fail;
9168 {
9169 arg2 = wxString_in_helper(obj1);
9170 if (arg2 == NULL) SWIG_fail;
9171 temp2 = true;
9172 }
9173 {
9174 PyThreadState* __tstate = wxPyBeginAllowThreads();
9175 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9176
9177 wxPyEndAllowThreads(__tstate);
9178 if (PyErr_Occurred()) SWIG_fail;
9179 }
9180 {
9181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9182 }
9183 {
9184 if (temp2)
9185 delete arg2;
9186 }
9187 return resultobj;
9188 fail:
9189 {
9190 if (temp2)
9191 delete arg2;
9192 }
9193 return NULL;
9194 }
9195
9196
9197 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9198 PyObject *resultobj;
9199 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9200 wxFileSystem *arg2 = 0 ;
9201 wxString *arg3 = 0 ;
9202 wxFSFile *result;
9203 bool temp3 = false ;
9204 PyObject * obj0 = 0 ;
9205 PyObject * obj1 = 0 ;
9206 PyObject * obj2 = 0 ;
9207 char *kwnames[] = {
9208 (char *) "self",(char *) "fs",(char *) "location", NULL
9209 };
9210
9211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9213 if (SWIG_arg_fail(1)) SWIG_fail;
9214 {
9215 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9216 if (SWIG_arg_fail(2)) SWIG_fail;
9217 if (arg2 == NULL) {
9218 SWIG_null_ref("wxFileSystem");
9219 }
9220 if (SWIG_arg_fail(2)) SWIG_fail;
9221 }
9222 {
9223 arg3 = wxString_in_helper(obj2);
9224 if (arg3 == NULL) SWIG_fail;
9225 temp3 = true;
9226 }
9227 {
9228 PyThreadState* __tstate = wxPyBeginAllowThreads();
9229 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9230
9231 wxPyEndAllowThreads(__tstate);
9232 if (PyErr_Occurred()) SWIG_fail;
9233 }
9234 {
9235 resultobj = wxPyMake_wxObject(result, 1);
9236 }
9237 {
9238 if (temp3)
9239 delete arg3;
9240 }
9241 return resultobj;
9242 fail:
9243 {
9244 if (temp3)
9245 delete arg3;
9246 }
9247 return NULL;
9248 }
9249
9250
9251 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9252 PyObject *obj;
9253 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9254 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9255 Py_INCREF(obj);
9256 return Py_BuildValue((char *)"");
9257 }
9258 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9259 PyObject *resultobj;
9260 wxZipFSHandler *result;
9261 char *kwnames[] = {
9262 NULL
9263 };
9264
9265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9266 {
9267 PyThreadState* __tstate = wxPyBeginAllowThreads();
9268 result = (wxZipFSHandler *)new wxZipFSHandler();
9269
9270 wxPyEndAllowThreads(__tstate);
9271 if (PyErr_Occurred()) SWIG_fail;
9272 }
9273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9274 return resultobj;
9275 fail:
9276 return NULL;
9277 }
9278
9279
9280 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9281 PyObject *resultobj;
9282 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9283 wxString *arg2 = 0 ;
9284 bool result;
9285 bool temp2 = false ;
9286 PyObject * obj0 = 0 ;
9287 PyObject * obj1 = 0 ;
9288 char *kwnames[] = {
9289 (char *) "self",(char *) "location", NULL
9290 };
9291
9292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9294 if (SWIG_arg_fail(1)) SWIG_fail;
9295 {
9296 arg2 = wxString_in_helper(obj1);
9297 if (arg2 == NULL) SWIG_fail;
9298 temp2 = true;
9299 }
9300 {
9301 PyThreadState* __tstate = wxPyBeginAllowThreads();
9302 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9303
9304 wxPyEndAllowThreads(__tstate);
9305 if (PyErr_Occurred()) SWIG_fail;
9306 }
9307 {
9308 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9309 }
9310 {
9311 if (temp2)
9312 delete arg2;
9313 }
9314 return resultobj;
9315 fail:
9316 {
9317 if (temp2)
9318 delete arg2;
9319 }
9320 return NULL;
9321 }
9322
9323
9324 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9325 PyObject *resultobj;
9326 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9327 wxFileSystem *arg2 = 0 ;
9328 wxString *arg3 = 0 ;
9329 wxFSFile *result;
9330 bool temp3 = false ;
9331 PyObject * obj0 = 0 ;
9332 PyObject * obj1 = 0 ;
9333 PyObject * obj2 = 0 ;
9334 char *kwnames[] = {
9335 (char *) "self",(char *) "fs",(char *) "location", NULL
9336 };
9337
9338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9340 if (SWIG_arg_fail(1)) SWIG_fail;
9341 {
9342 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9343 if (SWIG_arg_fail(2)) SWIG_fail;
9344 if (arg2 == NULL) {
9345 SWIG_null_ref("wxFileSystem");
9346 }
9347 if (SWIG_arg_fail(2)) SWIG_fail;
9348 }
9349 {
9350 arg3 = wxString_in_helper(obj2);
9351 if (arg3 == NULL) SWIG_fail;
9352 temp3 = true;
9353 }
9354 {
9355 PyThreadState* __tstate = wxPyBeginAllowThreads();
9356 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9357
9358 wxPyEndAllowThreads(__tstate);
9359 if (PyErr_Occurred()) SWIG_fail;
9360 }
9361 {
9362 resultobj = wxPyMake_wxObject(result, 1);
9363 }
9364 {
9365 if (temp3)
9366 delete arg3;
9367 }
9368 return resultobj;
9369 fail:
9370 {
9371 if (temp3)
9372 delete arg3;
9373 }
9374 return NULL;
9375 }
9376
9377
9378 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9379 PyObject *resultobj;
9380 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9381 wxString *arg2 = 0 ;
9382 int arg3 = (int) 0 ;
9383 wxString result;
9384 bool temp2 = false ;
9385 PyObject * obj0 = 0 ;
9386 PyObject * obj1 = 0 ;
9387 PyObject * obj2 = 0 ;
9388 char *kwnames[] = {
9389 (char *) "self",(char *) "spec",(char *) "flags", NULL
9390 };
9391
9392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9394 if (SWIG_arg_fail(1)) SWIG_fail;
9395 {
9396 arg2 = wxString_in_helper(obj1);
9397 if (arg2 == NULL) SWIG_fail;
9398 temp2 = true;
9399 }
9400 if (obj2) {
9401 {
9402 arg3 = (int)(SWIG_As_int(obj2));
9403 if (SWIG_arg_fail(3)) SWIG_fail;
9404 }
9405 }
9406 {
9407 PyThreadState* __tstate = wxPyBeginAllowThreads();
9408 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9409
9410 wxPyEndAllowThreads(__tstate);
9411 if (PyErr_Occurred()) SWIG_fail;
9412 }
9413 {
9414 #if wxUSE_UNICODE
9415 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9416 #else
9417 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9418 #endif
9419 }
9420 {
9421 if (temp2)
9422 delete arg2;
9423 }
9424 return resultobj;
9425 fail:
9426 {
9427 if (temp2)
9428 delete arg2;
9429 }
9430 return NULL;
9431 }
9432
9433
9434 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9435 PyObject *resultobj;
9436 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9437 wxString result;
9438 PyObject * obj0 = 0 ;
9439 char *kwnames[] = {
9440 (char *) "self", NULL
9441 };
9442
9443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9445 if (SWIG_arg_fail(1)) SWIG_fail;
9446 {
9447 PyThreadState* __tstate = wxPyBeginAllowThreads();
9448 result = (arg1)->FindNext();
9449
9450 wxPyEndAllowThreads(__tstate);
9451 if (PyErr_Occurred()) SWIG_fail;
9452 }
9453 {
9454 #if wxUSE_UNICODE
9455 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9456 #else
9457 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9458 #endif
9459 }
9460 return resultobj;
9461 fail:
9462 return NULL;
9463 }
9464
9465
9466 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9467 PyObject *obj;
9468 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9469 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9470 Py_INCREF(obj);
9471 return Py_BuildValue((char *)"");
9472 }
9473 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9474 PyObject *resultobj;
9475 wxString *arg1 = 0 ;
9476 wxImage *arg2 = 0 ;
9477 long arg3 ;
9478 bool temp1 = false ;
9479 PyObject * obj0 = 0 ;
9480 PyObject * obj1 = 0 ;
9481 PyObject * obj2 = 0 ;
9482 char *kwnames[] = {
9483 (char *) "filename",(char *) "image",(char *) "type", NULL
9484 };
9485
9486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9487 {
9488 arg1 = wxString_in_helper(obj0);
9489 if (arg1 == NULL) SWIG_fail;
9490 temp1 = true;
9491 }
9492 {
9493 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9494 if (SWIG_arg_fail(2)) SWIG_fail;
9495 if (arg2 == NULL) {
9496 SWIG_null_ref("wxImage");
9497 }
9498 if (SWIG_arg_fail(2)) SWIG_fail;
9499 }
9500 {
9501 arg3 = (long)(SWIG_As_long(obj2));
9502 if (SWIG_arg_fail(3)) SWIG_fail;
9503 }
9504 {
9505 PyThreadState* __tstate = wxPyBeginAllowThreads();
9506 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9507
9508 wxPyEndAllowThreads(__tstate);
9509 if (PyErr_Occurred()) SWIG_fail;
9510 }
9511 Py_INCREF(Py_None); resultobj = Py_None;
9512 {
9513 if (temp1)
9514 delete arg1;
9515 }
9516 return resultobj;
9517 fail:
9518 {
9519 if (temp1)
9520 delete arg1;
9521 }
9522 return NULL;
9523 }
9524
9525
9526 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9527 PyObject *resultobj;
9528 wxString *arg1 = 0 ;
9529 wxBitmap *arg2 = 0 ;
9530 long arg3 ;
9531 bool temp1 = false ;
9532 PyObject * obj0 = 0 ;
9533 PyObject * obj1 = 0 ;
9534 PyObject * obj2 = 0 ;
9535 char *kwnames[] = {
9536 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9537 };
9538
9539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9540 {
9541 arg1 = wxString_in_helper(obj0);
9542 if (arg1 == NULL) SWIG_fail;
9543 temp1 = true;
9544 }
9545 {
9546 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9547 if (SWIG_arg_fail(2)) SWIG_fail;
9548 if (arg2 == NULL) {
9549 SWIG_null_ref("wxBitmap");
9550 }
9551 if (SWIG_arg_fail(2)) SWIG_fail;
9552 }
9553 {
9554 arg3 = (long)(SWIG_As_long(obj2));
9555 if (SWIG_arg_fail(3)) SWIG_fail;
9556 }
9557 {
9558 PyThreadState* __tstate = wxPyBeginAllowThreads();
9559 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9560
9561 wxPyEndAllowThreads(__tstate);
9562 if (PyErr_Occurred()) SWIG_fail;
9563 }
9564 Py_INCREF(Py_None); resultobj = Py_None;
9565 {
9566 if (temp1)
9567 delete arg1;
9568 }
9569 return resultobj;
9570 fail:
9571 {
9572 if (temp1)
9573 delete arg1;
9574 }
9575 return NULL;
9576 }
9577
9578
9579 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9580 PyObject *resultobj;
9581 wxString *arg1 = 0 ;
9582 PyObject *arg2 = (PyObject *) 0 ;
9583 bool temp1 = false ;
9584 PyObject * obj0 = 0 ;
9585 PyObject * obj1 = 0 ;
9586 char *kwnames[] = {
9587 (char *) "filename",(char *) "data", NULL
9588 };
9589
9590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9591 {
9592 arg1 = wxString_in_helper(obj0);
9593 if (arg1 == NULL) SWIG_fail;
9594 temp1 = true;
9595 }
9596 arg2 = obj1;
9597 {
9598 PyThreadState* __tstate = wxPyBeginAllowThreads();
9599 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9600
9601 wxPyEndAllowThreads(__tstate);
9602 if (PyErr_Occurred()) SWIG_fail;
9603 }
9604 Py_INCREF(Py_None); resultobj = Py_None;
9605 {
9606 if (temp1)
9607 delete arg1;
9608 }
9609 return resultobj;
9610 fail:
9611 {
9612 if (temp1)
9613 delete arg1;
9614 }
9615 return NULL;
9616 }
9617
9618
9619 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9620 PyObject *resultobj;
9621 wxMemoryFSHandler *result;
9622 char *kwnames[] = {
9623 NULL
9624 };
9625
9626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9627 {
9628 PyThreadState* __tstate = wxPyBeginAllowThreads();
9629 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9630
9631 wxPyEndAllowThreads(__tstate);
9632 if (PyErr_Occurred()) SWIG_fail;
9633 }
9634 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9635 return resultobj;
9636 fail:
9637 return NULL;
9638 }
9639
9640
9641 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9642 PyObject *resultobj;
9643 wxString *arg1 = 0 ;
9644 bool temp1 = false ;
9645 PyObject * obj0 = 0 ;
9646 char *kwnames[] = {
9647 (char *) "filename", NULL
9648 };
9649
9650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9651 {
9652 arg1 = wxString_in_helper(obj0);
9653 if (arg1 == NULL) SWIG_fail;
9654 temp1 = true;
9655 }
9656 {
9657 PyThreadState* __tstate = wxPyBeginAllowThreads();
9658 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9659
9660 wxPyEndAllowThreads(__tstate);
9661 if (PyErr_Occurred()) SWIG_fail;
9662 }
9663 Py_INCREF(Py_None); resultobj = Py_None;
9664 {
9665 if (temp1)
9666 delete arg1;
9667 }
9668 return resultobj;
9669 fail:
9670 {
9671 if (temp1)
9672 delete arg1;
9673 }
9674 return NULL;
9675 }
9676
9677
9678 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9679 PyObject *resultobj;
9680 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9681 wxString *arg2 = 0 ;
9682 bool result;
9683 bool temp2 = false ;
9684 PyObject * obj0 = 0 ;
9685 PyObject * obj1 = 0 ;
9686 char *kwnames[] = {
9687 (char *) "self",(char *) "location", NULL
9688 };
9689
9690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9692 if (SWIG_arg_fail(1)) SWIG_fail;
9693 {
9694 arg2 = wxString_in_helper(obj1);
9695 if (arg2 == NULL) SWIG_fail;
9696 temp2 = true;
9697 }
9698 {
9699 PyThreadState* __tstate = wxPyBeginAllowThreads();
9700 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9701
9702 wxPyEndAllowThreads(__tstate);
9703 if (PyErr_Occurred()) SWIG_fail;
9704 }
9705 {
9706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9707 }
9708 {
9709 if (temp2)
9710 delete arg2;
9711 }
9712 return resultobj;
9713 fail:
9714 {
9715 if (temp2)
9716 delete arg2;
9717 }
9718 return NULL;
9719 }
9720
9721
9722 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9723 PyObject *resultobj;
9724 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9725 wxFileSystem *arg2 = 0 ;
9726 wxString *arg3 = 0 ;
9727 wxFSFile *result;
9728 bool temp3 = false ;
9729 PyObject * obj0 = 0 ;
9730 PyObject * obj1 = 0 ;
9731 PyObject * obj2 = 0 ;
9732 char *kwnames[] = {
9733 (char *) "self",(char *) "fs",(char *) "location", NULL
9734 };
9735
9736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9738 if (SWIG_arg_fail(1)) SWIG_fail;
9739 {
9740 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9741 if (SWIG_arg_fail(2)) SWIG_fail;
9742 if (arg2 == NULL) {
9743 SWIG_null_ref("wxFileSystem");
9744 }
9745 if (SWIG_arg_fail(2)) SWIG_fail;
9746 }
9747 {
9748 arg3 = wxString_in_helper(obj2);
9749 if (arg3 == NULL) SWIG_fail;
9750 temp3 = true;
9751 }
9752 {
9753 PyThreadState* __tstate = wxPyBeginAllowThreads();
9754 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9755
9756 wxPyEndAllowThreads(__tstate);
9757 if (PyErr_Occurred()) SWIG_fail;
9758 }
9759 {
9760 resultobj = wxPyMake_wxObject(result, 1);
9761 }
9762 {
9763 if (temp3)
9764 delete arg3;
9765 }
9766 return resultobj;
9767 fail:
9768 {
9769 if (temp3)
9770 delete arg3;
9771 }
9772 return NULL;
9773 }
9774
9775
9776 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9777 PyObject *resultobj;
9778 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9779 wxString *arg2 = 0 ;
9780 int arg3 = (int) 0 ;
9781 wxString result;
9782 bool temp2 = false ;
9783 PyObject * obj0 = 0 ;
9784 PyObject * obj1 = 0 ;
9785 PyObject * obj2 = 0 ;
9786 char *kwnames[] = {
9787 (char *) "self",(char *) "spec",(char *) "flags", NULL
9788 };
9789
9790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9792 if (SWIG_arg_fail(1)) SWIG_fail;
9793 {
9794 arg2 = wxString_in_helper(obj1);
9795 if (arg2 == NULL) SWIG_fail;
9796 temp2 = true;
9797 }
9798 if (obj2) {
9799 {
9800 arg3 = (int)(SWIG_As_int(obj2));
9801 if (SWIG_arg_fail(3)) SWIG_fail;
9802 }
9803 }
9804 {
9805 PyThreadState* __tstate = wxPyBeginAllowThreads();
9806 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9807
9808 wxPyEndAllowThreads(__tstate);
9809 if (PyErr_Occurred()) SWIG_fail;
9810 }
9811 {
9812 #if wxUSE_UNICODE
9813 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9814 #else
9815 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9816 #endif
9817 }
9818 {
9819 if (temp2)
9820 delete arg2;
9821 }
9822 return resultobj;
9823 fail:
9824 {
9825 if (temp2)
9826 delete arg2;
9827 }
9828 return NULL;
9829 }
9830
9831
9832 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9833 PyObject *resultobj;
9834 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9835 wxString result;
9836 PyObject * obj0 = 0 ;
9837 char *kwnames[] = {
9838 (char *) "self", NULL
9839 };
9840
9841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9843 if (SWIG_arg_fail(1)) SWIG_fail;
9844 {
9845 PyThreadState* __tstate = wxPyBeginAllowThreads();
9846 result = (arg1)->FindNext();
9847
9848 wxPyEndAllowThreads(__tstate);
9849 if (PyErr_Occurred()) SWIG_fail;
9850 }
9851 {
9852 #if wxUSE_UNICODE
9853 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9854 #else
9855 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9856 #endif
9857 }
9858 return resultobj;
9859 fail:
9860 return NULL;
9861 }
9862
9863
9864 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9865 PyObject *obj;
9866 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9867 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9868 Py_INCREF(obj);
9869 return Py_BuildValue((char *)"");
9870 }
9871 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9872 PyObject *resultobj;
9873 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9874 wxString result;
9875 PyObject * obj0 = 0 ;
9876 char *kwnames[] = {
9877 (char *) "self", NULL
9878 };
9879
9880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9882 if (SWIG_arg_fail(1)) SWIG_fail;
9883 {
9884 PyThreadState* __tstate = wxPyBeginAllowThreads();
9885 result = (arg1)->GetName();
9886
9887 wxPyEndAllowThreads(__tstate);
9888 if (PyErr_Occurred()) SWIG_fail;
9889 }
9890 {
9891 #if wxUSE_UNICODE
9892 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9893 #else
9894 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9895 #endif
9896 }
9897 return resultobj;
9898 fail:
9899 return NULL;
9900 }
9901
9902
9903 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9904 PyObject *resultobj;
9905 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9906 wxString result;
9907 PyObject * obj0 = 0 ;
9908 char *kwnames[] = {
9909 (char *) "self", NULL
9910 };
9911
9912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9914 if (SWIG_arg_fail(1)) SWIG_fail;
9915 {
9916 PyThreadState* __tstate = wxPyBeginAllowThreads();
9917 result = (arg1)->GetExtension();
9918
9919 wxPyEndAllowThreads(__tstate);
9920 if (PyErr_Occurred()) SWIG_fail;
9921 }
9922 {
9923 #if wxUSE_UNICODE
9924 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9925 #else
9926 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9927 #endif
9928 }
9929 return resultobj;
9930 fail:
9931 return NULL;
9932 }
9933
9934
9935 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9936 PyObject *resultobj;
9937 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9938 long result;
9939 PyObject * obj0 = 0 ;
9940 char *kwnames[] = {
9941 (char *) "self", NULL
9942 };
9943
9944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",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 = (long)(arg1)->GetType();
9950
9951 wxPyEndAllowThreads(__tstate);
9952 if (PyErr_Occurred()) SWIG_fail;
9953 }
9954 {
9955 resultobj = SWIG_From_long((long)(result));
9956 }
9957 return resultobj;
9958 fail:
9959 return NULL;
9960 }
9961
9962
9963 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9964 PyObject *resultobj;
9965 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9966 wxString result;
9967 PyObject * obj0 = 0 ;
9968 char *kwnames[] = {
9969 (char *) "self", NULL
9970 };
9971
9972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9974 if (SWIG_arg_fail(1)) SWIG_fail;
9975 {
9976 PyThreadState* __tstate = wxPyBeginAllowThreads();
9977 result = (arg1)->GetMimeType();
9978
9979 wxPyEndAllowThreads(__tstate);
9980 if (PyErr_Occurred()) SWIG_fail;
9981 }
9982 {
9983 #if wxUSE_UNICODE
9984 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9985 #else
9986 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9987 #endif
9988 }
9989 return resultobj;
9990 fail:
9991 return NULL;
9992 }
9993
9994
9995 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9996 PyObject *resultobj;
9997 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9998 wxString *arg2 = 0 ;
9999 bool result;
10000 bool temp2 = false ;
10001 PyObject * obj0 = 0 ;
10002 PyObject * obj1 = 0 ;
10003 char *kwnames[] = {
10004 (char *) "self",(char *) "name", NULL
10005 };
10006
10007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10009 if (SWIG_arg_fail(1)) SWIG_fail;
10010 {
10011 arg2 = wxString_in_helper(obj1);
10012 if (arg2 == NULL) SWIG_fail;
10013 temp2 = true;
10014 }
10015 {
10016 PyThreadState* __tstate = wxPyBeginAllowThreads();
10017 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10018
10019 wxPyEndAllowThreads(__tstate);
10020 if (PyErr_Occurred()) SWIG_fail;
10021 }
10022 {
10023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10024 }
10025 {
10026 if (temp2)
10027 delete arg2;
10028 }
10029 return resultobj;
10030 fail:
10031 {
10032 if (temp2)
10033 delete arg2;
10034 }
10035 return NULL;
10036 }
10037
10038
10039 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10040 PyObject *resultobj;
10041 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10042 wxString *arg2 = 0 ;
10043 bool temp2 = false ;
10044 PyObject * obj0 = 0 ;
10045 PyObject * obj1 = 0 ;
10046 char *kwnames[] = {
10047 (char *) "self",(char *) "name", NULL
10048 };
10049
10050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10052 if (SWIG_arg_fail(1)) SWIG_fail;
10053 {
10054 arg2 = wxString_in_helper(obj1);
10055 if (arg2 == NULL) SWIG_fail;
10056 temp2 = true;
10057 }
10058 {
10059 PyThreadState* __tstate = wxPyBeginAllowThreads();
10060 (arg1)->SetName((wxString const &)*arg2);
10061
10062 wxPyEndAllowThreads(__tstate);
10063 if (PyErr_Occurred()) SWIG_fail;
10064 }
10065 Py_INCREF(Py_None); resultobj = Py_None;
10066 {
10067 if (temp2)
10068 delete arg2;
10069 }
10070 return resultobj;
10071 fail:
10072 {
10073 if (temp2)
10074 delete arg2;
10075 }
10076 return NULL;
10077 }
10078
10079
10080 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10081 PyObject *resultobj;
10082 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10083 wxString *arg2 = 0 ;
10084 bool temp2 = false ;
10085 PyObject * obj0 = 0 ;
10086 PyObject * obj1 = 0 ;
10087 char *kwnames[] = {
10088 (char *) "self",(char *) "extension", NULL
10089 };
10090
10091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10093 if (SWIG_arg_fail(1)) SWIG_fail;
10094 {
10095 arg2 = wxString_in_helper(obj1);
10096 if (arg2 == NULL) SWIG_fail;
10097 temp2 = true;
10098 }
10099 {
10100 PyThreadState* __tstate = wxPyBeginAllowThreads();
10101 (arg1)->SetExtension((wxString const &)*arg2);
10102
10103 wxPyEndAllowThreads(__tstate);
10104 if (PyErr_Occurred()) SWIG_fail;
10105 }
10106 Py_INCREF(Py_None); resultobj = Py_None;
10107 {
10108 if (temp2)
10109 delete arg2;
10110 }
10111 return resultobj;
10112 fail:
10113 {
10114 if (temp2)
10115 delete arg2;
10116 }
10117 return NULL;
10118 }
10119
10120
10121 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10122 PyObject *resultobj;
10123 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10124 long arg2 ;
10125 PyObject * obj0 = 0 ;
10126 PyObject * obj1 = 0 ;
10127 char *kwnames[] = {
10128 (char *) "self",(char *) "type", NULL
10129 };
10130
10131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10133 if (SWIG_arg_fail(1)) SWIG_fail;
10134 {
10135 arg2 = (long)(SWIG_As_long(obj1));
10136 if (SWIG_arg_fail(2)) SWIG_fail;
10137 }
10138 {
10139 PyThreadState* __tstate = wxPyBeginAllowThreads();
10140 (arg1)->SetType(arg2);
10141
10142 wxPyEndAllowThreads(__tstate);
10143 if (PyErr_Occurred()) SWIG_fail;
10144 }
10145 Py_INCREF(Py_None); resultobj = Py_None;
10146 return resultobj;
10147 fail:
10148 return NULL;
10149 }
10150
10151
10152 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10153 PyObject *resultobj;
10154 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10155 wxString *arg2 = 0 ;
10156 bool temp2 = false ;
10157 PyObject * obj0 = 0 ;
10158 PyObject * obj1 = 0 ;
10159 char *kwnames[] = {
10160 (char *) "self",(char *) "mimetype", NULL
10161 };
10162
10163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10165 if (SWIG_arg_fail(1)) SWIG_fail;
10166 {
10167 arg2 = wxString_in_helper(obj1);
10168 if (arg2 == NULL) SWIG_fail;
10169 temp2 = true;
10170 }
10171 {
10172 PyThreadState* __tstate = wxPyBeginAllowThreads();
10173 (arg1)->SetMimeType((wxString const &)*arg2);
10174
10175 wxPyEndAllowThreads(__tstate);
10176 if (PyErr_Occurred()) SWIG_fail;
10177 }
10178 Py_INCREF(Py_None); resultobj = Py_None;
10179 {
10180 if (temp2)
10181 delete arg2;
10182 }
10183 return resultobj;
10184 fail:
10185 {
10186 if (temp2)
10187 delete arg2;
10188 }
10189 return NULL;
10190 }
10191
10192
10193 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10194 PyObject *obj;
10195 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10196 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10197 Py_INCREF(obj);
10198 return Py_BuildValue((char *)"");
10199 }
10200 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10201 PyObject *resultobj;
10202 wxImageHistogram *result;
10203 char *kwnames[] = {
10204 NULL
10205 };
10206
10207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10208 {
10209 PyThreadState* __tstate = wxPyBeginAllowThreads();
10210 result = (wxImageHistogram *)new wxImageHistogram();
10211
10212 wxPyEndAllowThreads(__tstate);
10213 if (PyErr_Occurred()) SWIG_fail;
10214 }
10215 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10216 return resultobj;
10217 fail:
10218 return NULL;
10219 }
10220
10221
10222 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10223 PyObject *resultobj;
10224 unsigned char arg1 ;
10225 unsigned char arg2 ;
10226 unsigned char arg3 ;
10227 unsigned long result;
10228 PyObject * obj0 = 0 ;
10229 PyObject * obj1 = 0 ;
10230 PyObject * obj2 = 0 ;
10231 char *kwnames[] = {
10232 (char *) "r",(char *) "g",(char *) "b", NULL
10233 };
10234
10235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10236 {
10237 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10238 if (SWIG_arg_fail(1)) SWIG_fail;
10239 }
10240 {
10241 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10242 if (SWIG_arg_fail(2)) SWIG_fail;
10243 }
10244 {
10245 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10246 if (SWIG_arg_fail(3)) SWIG_fail;
10247 }
10248 {
10249 PyThreadState* __tstate = wxPyBeginAllowThreads();
10250 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10251
10252 wxPyEndAllowThreads(__tstate);
10253 if (PyErr_Occurred()) SWIG_fail;
10254 }
10255 {
10256 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10257 }
10258 return resultobj;
10259 fail:
10260 return NULL;
10261 }
10262
10263
10264 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10265 PyObject *resultobj;
10266 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10267 unsigned char *arg2 = (unsigned char *) 0 ;
10268 unsigned char *arg3 = (unsigned char *) 0 ;
10269 unsigned char *arg4 = (unsigned char *) 0 ;
10270 unsigned char arg5 = (unsigned char) 1 ;
10271 unsigned char arg6 = (unsigned char) 0 ;
10272 unsigned char arg7 = (unsigned char) 0 ;
10273 bool result;
10274 unsigned char temp2 ;
10275 int res2 = 0 ;
10276 unsigned char temp3 ;
10277 int res3 = 0 ;
10278 unsigned char temp4 ;
10279 int res4 = 0 ;
10280 PyObject * obj0 = 0 ;
10281 PyObject * obj1 = 0 ;
10282 PyObject * obj2 = 0 ;
10283 PyObject * obj3 = 0 ;
10284 char *kwnames[] = {
10285 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10286 };
10287
10288 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10289 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10290 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10293 if (SWIG_arg_fail(1)) SWIG_fail;
10294 if (obj1) {
10295 {
10296 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10297 if (SWIG_arg_fail(5)) SWIG_fail;
10298 }
10299 }
10300 if (obj2) {
10301 {
10302 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10303 if (SWIG_arg_fail(6)) SWIG_fail;
10304 }
10305 }
10306 if (obj3) {
10307 {
10308 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10309 if (SWIG_arg_fail(7)) SWIG_fail;
10310 }
10311 }
10312 {
10313 PyThreadState* __tstate = wxPyBeginAllowThreads();
10314 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10315
10316 wxPyEndAllowThreads(__tstate);
10317 if (PyErr_Occurred()) SWIG_fail;
10318 }
10319 {
10320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10321 }
10322 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10323 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10324 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10325 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10326 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10327 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10328 return resultobj;
10329 fail:
10330 return NULL;
10331 }
10332
10333
10334 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10335 PyObject *resultobj;
10336 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10337 unsigned long arg2 ;
10338 unsigned long result;
10339 PyObject * obj0 = 0 ;
10340 PyObject * obj1 = 0 ;
10341 char *kwnames[] = {
10342 (char *) "self",(char *) "key", NULL
10343 };
10344
10345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10347 if (SWIG_arg_fail(1)) SWIG_fail;
10348 {
10349 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10350 if (SWIG_arg_fail(2)) SWIG_fail;
10351 }
10352 {
10353 PyThreadState* __tstate = wxPyBeginAllowThreads();
10354 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10355
10356 wxPyEndAllowThreads(__tstate);
10357 if (PyErr_Occurred()) SWIG_fail;
10358 }
10359 {
10360 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10361 }
10362 return resultobj;
10363 fail:
10364 return NULL;
10365 }
10366
10367
10368 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10369 PyObject *resultobj;
10370 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10371 unsigned char arg2 ;
10372 unsigned char arg3 ;
10373 unsigned char arg4 ;
10374 unsigned long result;
10375 PyObject * obj0 = 0 ;
10376 PyObject * obj1 = 0 ;
10377 PyObject * obj2 = 0 ;
10378 PyObject * obj3 = 0 ;
10379 char *kwnames[] = {
10380 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10381 };
10382
10383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10385 if (SWIG_arg_fail(1)) SWIG_fail;
10386 {
10387 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10388 if (SWIG_arg_fail(2)) SWIG_fail;
10389 }
10390 {
10391 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10392 if (SWIG_arg_fail(3)) SWIG_fail;
10393 }
10394 {
10395 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10396 if (SWIG_arg_fail(4)) SWIG_fail;
10397 }
10398 {
10399 PyThreadState* __tstate = wxPyBeginAllowThreads();
10400 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10401
10402 wxPyEndAllowThreads(__tstate);
10403 if (PyErr_Occurred()) SWIG_fail;
10404 }
10405 {
10406 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10407 }
10408 return resultobj;
10409 fail:
10410 return NULL;
10411 }
10412
10413
10414 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10415 PyObject *resultobj;
10416 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10417 wxColour *arg2 = 0 ;
10418 unsigned long result;
10419 wxColour temp2 ;
10420 PyObject * obj0 = 0 ;
10421 PyObject * obj1 = 0 ;
10422 char *kwnames[] = {
10423 (char *) "self",(char *) "colour", NULL
10424 };
10425
10426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10428 if (SWIG_arg_fail(1)) SWIG_fail;
10429 {
10430 arg2 = &temp2;
10431 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10432 }
10433 {
10434 PyThreadState* __tstate = wxPyBeginAllowThreads();
10435 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10436
10437 wxPyEndAllowThreads(__tstate);
10438 if (PyErr_Occurred()) SWIG_fail;
10439 }
10440 {
10441 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10442 }
10443 return resultobj;
10444 fail:
10445 return NULL;
10446 }
10447
10448
10449 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10450 PyObject *obj;
10451 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10452 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10453 Py_INCREF(obj);
10454 return Py_BuildValue((char *)"");
10455 }
10456 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10457 PyObject *resultobj;
10458 wxString *arg1 = 0 ;
10459 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10460 int arg3 = (int) -1 ;
10461 wxImage *result;
10462 bool temp1 = false ;
10463 PyObject * obj0 = 0 ;
10464 PyObject * obj1 = 0 ;
10465 PyObject * obj2 = 0 ;
10466 char *kwnames[] = {
10467 (char *) "name",(char *) "type",(char *) "index", NULL
10468 };
10469
10470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10471 {
10472 arg1 = wxString_in_helper(obj0);
10473 if (arg1 == NULL) SWIG_fail;
10474 temp1 = true;
10475 }
10476 if (obj1) {
10477 {
10478 arg2 = (long)(SWIG_As_long(obj1));
10479 if (SWIG_arg_fail(2)) SWIG_fail;
10480 }
10481 }
10482 if (obj2) {
10483 {
10484 arg3 = (int)(SWIG_As_int(obj2));
10485 if (SWIG_arg_fail(3)) SWIG_fail;
10486 }
10487 }
10488 {
10489 PyThreadState* __tstate = wxPyBeginAllowThreads();
10490 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10491
10492 wxPyEndAllowThreads(__tstate);
10493 if (PyErr_Occurred()) SWIG_fail;
10494 }
10495 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10496 {
10497 if (temp1)
10498 delete arg1;
10499 }
10500 return resultobj;
10501 fail:
10502 {
10503 if (temp1)
10504 delete arg1;
10505 }
10506 return NULL;
10507 }
10508
10509
10510 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10511 PyObject *resultobj;
10512 wxImage *arg1 = (wxImage *) 0 ;
10513 PyObject * obj0 = 0 ;
10514 char *kwnames[] = {
10515 (char *) "self", NULL
10516 };
10517
10518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10520 if (SWIG_arg_fail(1)) SWIG_fail;
10521 {
10522 PyThreadState* __tstate = wxPyBeginAllowThreads();
10523 delete arg1;
10524
10525 wxPyEndAllowThreads(__tstate);
10526 if (PyErr_Occurred()) SWIG_fail;
10527 }
10528 Py_INCREF(Py_None); resultobj = Py_None;
10529 return resultobj;
10530 fail:
10531 return NULL;
10532 }
10533
10534
10535 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10536 PyObject *resultobj;
10537 wxString *arg1 = 0 ;
10538 wxString *arg2 = 0 ;
10539 int arg3 = (int) -1 ;
10540 wxImage *result;
10541 bool temp1 = false ;
10542 bool temp2 = false ;
10543 PyObject * obj0 = 0 ;
10544 PyObject * obj1 = 0 ;
10545 PyObject * obj2 = 0 ;
10546 char *kwnames[] = {
10547 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10548 };
10549
10550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10551 {
10552 arg1 = wxString_in_helper(obj0);
10553 if (arg1 == NULL) SWIG_fail;
10554 temp1 = true;
10555 }
10556 {
10557 arg2 = wxString_in_helper(obj1);
10558 if (arg2 == NULL) SWIG_fail;
10559 temp2 = true;
10560 }
10561 if (obj2) {
10562 {
10563 arg3 = (int)(SWIG_As_int(obj2));
10564 if (SWIG_arg_fail(3)) SWIG_fail;
10565 }
10566 }
10567 {
10568 PyThreadState* __tstate = wxPyBeginAllowThreads();
10569 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10570
10571 wxPyEndAllowThreads(__tstate);
10572 if (PyErr_Occurred()) SWIG_fail;
10573 }
10574 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10575 {
10576 if (temp1)
10577 delete arg1;
10578 }
10579 {
10580 if (temp2)
10581 delete arg2;
10582 }
10583 return resultobj;
10584 fail:
10585 {
10586 if (temp1)
10587 delete arg1;
10588 }
10589 {
10590 if (temp2)
10591 delete arg2;
10592 }
10593 return NULL;
10594 }
10595
10596
10597 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10598 PyObject *resultobj;
10599 wxInputStream *arg1 = 0 ;
10600 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10601 int arg3 = (int) -1 ;
10602 wxImage *result;
10603 wxPyInputStream *temp1 ;
10604 bool created1 ;
10605 PyObject * obj0 = 0 ;
10606 PyObject * obj1 = 0 ;
10607 PyObject * obj2 = 0 ;
10608 char *kwnames[] = {
10609 (char *) "stream",(char *) "type",(char *) "index", NULL
10610 };
10611
10612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10613 {
10614 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10615 arg1 = temp1->m_wxis;
10616 created1 = false;
10617 } else {
10618 PyErr_Clear(); // clear the failure of the wxPyConvert above
10619 arg1 = wxPyCBInputStream_create(obj0, false);
10620 if (arg1 == NULL) {
10621 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10622 SWIG_fail;
10623 }
10624 created1 = true;
10625 }
10626 }
10627 if (obj1) {
10628 {
10629 arg2 = (long)(SWIG_As_long(obj1));
10630 if (SWIG_arg_fail(2)) SWIG_fail;
10631 }
10632 }
10633 if (obj2) {
10634 {
10635 arg3 = (int)(SWIG_As_int(obj2));
10636 if (SWIG_arg_fail(3)) SWIG_fail;
10637 }
10638 }
10639 {
10640 PyThreadState* __tstate = wxPyBeginAllowThreads();
10641 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10642
10643 wxPyEndAllowThreads(__tstate);
10644 if (PyErr_Occurred()) SWIG_fail;
10645 }
10646 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10647 {
10648 if (created1) delete arg1;
10649 }
10650 return resultobj;
10651 fail:
10652 {
10653 if (created1) delete arg1;
10654 }
10655 return NULL;
10656 }
10657
10658
10659 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10660 PyObject *resultobj;
10661 wxInputStream *arg1 = 0 ;
10662 wxString *arg2 = 0 ;
10663 int arg3 = (int) -1 ;
10664 wxImage *result;
10665 wxPyInputStream *temp1 ;
10666 bool created1 ;
10667 bool temp2 = false ;
10668 PyObject * obj0 = 0 ;
10669 PyObject * obj1 = 0 ;
10670 PyObject * obj2 = 0 ;
10671 char *kwnames[] = {
10672 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10673 };
10674
10675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10676 {
10677 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10678 arg1 = temp1->m_wxis;
10679 created1 = false;
10680 } else {
10681 PyErr_Clear(); // clear the failure of the wxPyConvert above
10682 arg1 = wxPyCBInputStream_create(obj0, false);
10683 if (arg1 == NULL) {
10684 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10685 SWIG_fail;
10686 }
10687 created1 = true;
10688 }
10689 }
10690 {
10691 arg2 = wxString_in_helper(obj1);
10692 if (arg2 == NULL) SWIG_fail;
10693 temp2 = true;
10694 }
10695 if (obj2) {
10696 {
10697 arg3 = (int)(SWIG_As_int(obj2));
10698 if (SWIG_arg_fail(3)) SWIG_fail;
10699 }
10700 }
10701 {
10702 PyThreadState* __tstate = wxPyBeginAllowThreads();
10703 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10704
10705 wxPyEndAllowThreads(__tstate);
10706 if (PyErr_Occurred()) SWIG_fail;
10707 }
10708 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10709 {
10710 if (created1) delete arg1;
10711 }
10712 {
10713 if (temp2)
10714 delete arg2;
10715 }
10716 return resultobj;
10717 fail:
10718 {
10719 if (created1) delete arg1;
10720 }
10721 {
10722 if (temp2)
10723 delete arg2;
10724 }
10725 return NULL;
10726 }
10727
10728
10729 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10730 PyObject *resultobj;
10731 int arg1 = (int) 0 ;
10732 int arg2 = (int) 0 ;
10733 bool arg3 = (bool) true ;
10734 wxImage *result;
10735 PyObject * obj0 = 0 ;
10736 PyObject * obj1 = 0 ;
10737 PyObject * obj2 = 0 ;
10738 char *kwnames[] = {
10739 (char *) "width",(char *) "height",(char *) "clear", NULL
10740 };
10741
10742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10743 if (obj0) {
10744 {
10745 arg1 = (int)(SWIG_As_int(obj0));
10746 if (SWIG_arg_fail(1)) SWIG_fail;
10747 }
10748 }
10749 if (obj1) {
10750 {
10751 arg2 = (int)(SWIG_As_int(obj1));
10752 if (SWIG_arg_fail(2)) SWIG_fail;
10753 }
10754 }
10755 if (obj2) {
10756 {
10757 arg3 = (bool)(SWIG_As_bool(obj2));
10758 if (SWIG_arg_fail(3)) SWIG_fail;
10759 }
10760 }
10761 {
10762 PyThreadState* __tstate = wxPyBeginAllowThreads();
10763 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10764
10765 wxPyEndAllowThreads(__tstate);
10766 if (PyErr_Occurred()) SWIG_fail;
10767 }
10768 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10769 return resultobj;
10770 fail:
10771 return NULL;
10772 }
10773
10774
10775 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10776 PyObject *resultobj;
10777 wxBitmap *arg1 = 0 ;
10778 wxImage *result;
10779 PyObject * obj0 = 0 ;
10780 char *kwnames[] = {
10781 (char *) "bitmap", NULL
10782 };
10783
10784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10785 {
10786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10787 if (SWIG_arg_fail(1)) SWIG_fail;
10788 if (arg1 == NULL) {
10789 SWIG_null_ref("wxBitmap");
10790 }
10791 if (SWIG_arg_fail(1)) SWIG_fail;
10792 }
10793 {
10794 if (!wxPyCheckForApp()) SWIG_fail;
10795 PyThreadState* __tstate = wxPyBeginAllowThreads();
10796 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10797
10798 wxPyEndAllowThreads(__tstate);
10799 if (PyErr_Occurred()) SWIG_fail;
10800 }
10801 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10802 return resultobj;
10803 fail:
10804 return NULL;
10805 }
10806
10807
10808 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10809 PyObject *resultobj;
10810 int arg1 ;
10811 int arg2 ;
10812 buffer arg3 ;
10813 int arg4 ;
10814 wxImage *result;
10815 PyObject * obj0 = 0 ;
10816 PyObject * obj1 = 0 ;
10817 PyObject * obj2 = 0 ;
10818 char *kwnames[] = {
10819 (char *) "width",(char *) "height",(char *) "data", NULL
10820 };
10821
10822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10823 {
10824 arg1 = (int)(SWIG_As_int(obj0));
10825 if (SWIG_arg_fail(1)) SWIG_fail;
10826 }
10827 {
10828 arg2 = (int)(SWIG_As_int(obj1));
10829 if (SWIG_arg_fail(2)) SWIG_fail;
10830 }
10831 {
10832 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10833 }
10834 {
10835 PyThreadState* __tstate = wxPyBeginAllowThreads();
10836 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10837
10838 wxPyEndAllowThreads(__tstate);
10839 if (PyErr_Occurred()) SWIG_fail;
10840 }
10841 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10842 return resultobj;
10843 fail:
10844 return NULL;
10845 }
10846
10847
10848 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10849 PyObject *resultobj;
10850 int arg1 ;
10851 int arg2 ;
10852 buffer arg3 ;
10853 int arg4 ;
10854 buffer arg5 ;
10855 int arg6 ;
10856 wxImage *result;
10857 PyObject * obj0 = 0 ;
10858 PyObject * obj1 = 0 ;
10859 PyObject * obj2 = 0 ;
10860 PyObject * obj3 = 0 ;
10861 char *kwnames[] = {
10862 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10863 };
10864
10865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10866 {
10867 arg1 = (int)(SWIG_As_int(obj0));
10868 if (SWIG_arg_fail(1)) SWIG_fail;
10869 }
10870 {
10871 arg2 = (int)(SWIG_As_int(obj1));
10872 if (SWIG_arg_fail(2)) SWIG_fail;
10873 }
10874 {
10875 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10876 }
10877 {
10878 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
10879 }
10880 {
10881 PyThreadState* __tstate = wxPyBeginAllowThreads();
10882 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
10883
10884 wxPyEndAllowThreads(__tstate);
10885 if (PyErr_Occurred()) SWIG_fail;
10886 }
10887 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10888 return resultobj;
10889 fail:
10890 return NULL;
10891 }
10892
10893
10894 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10895 PyObject *resultobj;
10896 wxImage *arg1 = (wxImage *) 0 ;
10897 int arg2 ;
10898 int arg3 ;
10899 PyObject * obj0 = 0 ;
10900 PyObject * obj1 = 0 ;
10901 PyObject * obj2 = 0 ;
10902 char *kwnames[] = {
10903 (char *) "self",(char *) "width",(char *) "height", NULL
10904 };
10905
10906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10908 if (SWIG_arg_fail(1)) SWIG_fail;
10909 {
10910 arg2 = (int)(SWIG_As_int(obj1));
10911 if (SWIG_arg_fail(2)) SWIG_fail;
10912 }
10913 {
10914 arg3 = (int)(SWIG_As_int(obj2));
10915 if (SWIG_arg_fail(3)) SWIG_fail;
10916 }
10917 {
10918 PyThreadState* __tstate = wxPyBeginAllowThreads();
10919 (arg1)->Create(arg2,arg3);
10920
10921 wxPyEndAllowThreads(__tstate);
10922 if (PyErr_Occurred()) SWIG_fail;
10923 }
10924 Py_INCREF(Py_None); resultobj = Py_None;
10925 return resultobj;
10926 fail:
10927 return NULL;
10928 }
10929
10930
10931 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10932 PyObject *resultobj;
10933 wxImage *arg1 = (wxImage *) 0 ;
10934 PyObject * obj0 = 0 ;
10935 char *kwnames[] = {
10936 (char *) "self", NULL
10937 };
10938
10939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10941 if (SWIG_arg_fail(1)) SWIG_fail;
10942 {
10943 PyThreadState* __tstate = wxPyBeginAllowThreads();
10944 (arg1)->Destroy();
10945
10946 wxPyEndAllowThreads(__tstate);
10947 if (PyErr_Occurred()) SWIG_fail;
10948 }
10949 Py_INCREF(Py_None); resultobj = Py_None;
10950 return resultobj;
10951 fail:
10952 return NULL;
10953 }
10954
10955
10956 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10957 PyObject *resultobj;
10958 wxImage *arg1 = (wxImage *) 0 ;
10959 int arg2 ;
10960 int arg3 ;
10961 SwigValueWrapper<wxImage > result;
10962 PyObject * obj0 = 0 ;
10963 PyObject * obj1 = 0 ;
10964 PyObject * obj2 = 0 ;
10965 char *kwnames[] = {
10966 (char *) "self",(char *) "width",(char *) "height", NULL
10967 };
10968
10969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10971 if (SWIG_arg_fail(1)) SWIG_fail;
10972 {
10973 arg2 = (int)(SWIG_As_int(obj1));
10974 if (SWIG_arg_fail(2)) SWIG_fail;
10975 }
10976 {
10977 arg3 = (int)(SWIG_As_int(obj2));
10978 if (SWIG_arg_fail(3)) SWIG_fail;
10979 }
10980 {
10981 PyThreadState* __tstate = wxPyBeginAllowThreads();
10982 result = (arg1)->Scale(arg2,arg3);
10983
10984 wxPyEndAllowThreads(__tstate);
10985 if (PyErr_Occurred()) SWIG_fail;
10986 }
10987 {
10988 wxImage * resultptr;
10989 resultptr = new wxImage((wxImage &)(result));
10990 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10991 }
10992 return resultobj;
10993 fail:
10994 return NULL;
10995 }
10996
10997
10998 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10999 PyObject *resultobj;
11000 wxImage *arg1 = (wxImage *) 0 ;
11001 int arg2 ;
11002 int arg3 ;
11003 SwigValueWrapper<wxImage > result;
11004 PyObject * obj0 = 0 ;
11005 PyObject * obj1 = 0 ;
11006 PyObject * obj2 = 0 ;
11007 char *kwnames[] = {
11008 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11009 };
11010
11011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11013 if (SWIG_arg_fail(1)) SWIG_fail;
11014 {
11015 arg2 = (int)(SWIG_As_int(obj1));
11016 if (SWIG_arg_fail(2)) SWIG_fail;
11017 }
11018 {
11019 arg3 = (int)(SWIG_As_int(obj2));
11020 if (SWIG_arg_fail(3)) SWIG_fail;
11021 }
11022 {
11023 PyThreadState* __tstate = wxPyBeginAllowThreads();
11024 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11025
11026 wxPyEndAllowThreads(__tstate);
11027 if (PyErr_Occurred()) SWIG_fail;
11028 }
11029 {
11030 wxImage * resultptr;
11031 resultptr = new wxImage((wxImage &)(result));
11032 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11033 }
11034 return resultobj;
11035 fail:
11036 return NULL;
11037 }
11038
11039
11040 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11041 PyObject *resultobj;
11042 wxImage *arg1 = (wxImage *) 0 ;
11043 int arg2 ;
11044 int arg3 ;
11045 wxImage *result;
11046 PyObject * obj0 = 0 ;
11047 PyObject * obj1 = 0 ;
11048 PyObject * obj2 = 0 ;
11049 char *kwnames[] = {
11050 (char *) "self",(char *) "width",(char *) "height", NULL
11051 };
11052
11053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11055 if (SWIG_arg_fail(1)) SWIG_fail;
11056 {
11057 arg2 = (int)(SWIG_As_int(obj1));
11058 if (SWIG_arg_fail(2)) SWIG_fail;
11059 }
11060 {
11061 arg3 = (int)(SWIG_As_int(obj2));
11062 if (SWIG_arg_fail(3)) SWIG_fail;
11063 }
11064 {
11065 PyThreadState* __tstate = wxPyBeginAllowThreads();
11066 {
11067 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11068 result = (wxImage *) &_result_ref;
11069 }
11070
11071 wxPyEndAllowThreads(__tstate);
11072 if (PyErr_Occurred()) SWIG_fail;
11073 }
11074 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11075 return resultobj;
11076 fail:
11077 return NULL;
11078 }
11079
11080
11081 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11082 PyObject *resultobj;
11083 wxImage *arg1 = (wxImage *) 0 ;
11084 wxSize *arg2 = 0 ;
11085 wxPoint *arg3 = 0 ;
11086 int arg4 = (int) -1 ;
11087 int arg5 = (int) -1 ;
11088 int arg6 = (int) -1 ;
11089 wxImage *result;
11090 wxSize temp2 ;
11091 wxPoint temp3 ;
11092 PyObject * obj0 = 0 ;
11093 PyObject * obj1 = 0 ;
11094 PyObject * obj2 = 0 ;
11095 PyObject * obj3 = 0 ;
11096 PyObject * obj4 = 0 ;
11097 PyObject * obj5 = 0 ;
11098 char *kwnames[] = {
11099 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11100 };
11101
11102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11104 if (SWIG_arg_fail(1)) SWIG_fail;
11105 {
11106 arg2 = &temp2;
11107 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11108 }
11109 {
11110 arg3 = &temp3;
11111 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11112 }
11113 if (obj3) {
11114 {
11115 arg4 = (int)(SWIG_As_int(obj3));
11116 if (SWIG_arg_fail(4)) SWIG_fail;
11117 }
11118 }
11119 if (obj4) {
11120 {
11121 arg5 = (int)(SWIG_As_int(obj4));
11122 if (SWIG_arg_fail(5)) SWIG_fail;
11123 }
11124 }
11125 if (obj5) {
11126 {
11127 arg6 = (int)(SWIG_As_int(obj5));
11128 if (SWIG_arg_fail(6)) SWIG_fail;
11129 }
11130 }
11131 {
11132 PyThreadState* __tstate = wxPyBeginAllowThreads();
11133 {
11134 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11135 result = (wxImage *) &_result_ref;
11136 }
11137
11138 wxPyEndAllowThreads(__tstate);
11139 if (PyErr_Occurred()) SWIG_fail;
11140 }
11141 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11142 return resultobj;
11143 fail:
11144 return NULL;
11145 }
11146
11147
11148 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11149 PyObject *resultobj;
11150 wxImage *arg1 = (wxImage *) 0 ;
11151 int arg2 ;
11152 int arg3 ;
11153 unsigned char arg4 ;
11154 unsigned char arg5 ;
11155 unsigned char arg6 ;
11156 PyObject * obj0 = 0 ;
11157 PyObject * obj1 = 0 ;
11158 PyObject * obj2 = 0 ;
11159 PyObject * obj3 = 0 ;
11160 PyObject * obj4 = 0 ;
11161 PyObject * obj5 = 0 ;
11162 char *kwnames[] = {
11163 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11164 };
11165
11166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11168 if (SWIG_arg_fail(1)) SWIG_fail;
11169 {
11170 arg2 = (int)(SWIG_As_int(obj1));
11171 if (SWIG_arg_fail(2)) SWIG_fail;
11172 }
11173 {
11174 arg3 = (int)(SWIG_As_int(obj2));
11175 if (SWIG_arg_fail(3)) SWIG_fail;
11176 }
11177 {
11178 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11179 if (SWIG_arg_fail(4)) SWIG_fail;
11180 }
11181 {
11182 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11183 if (SWIG_arg_fail(5)) SWIG_fail;
11184 }
11185 {
11186 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
11187 if (SWIG_arg_fail(6)) SWIG_fail;
11188 }
11189 {
11190 PyThreadState* __tstate = wxPyBeginAllowThreads();
11191 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11192
11193 wxPyEndAllowThreads(__tstate);
11194 if (PyErr_Occurred()) SWIG_fail;
11195 }
11196 Py_INCREF(Py_None); resultobj = Py_None;
11197 return resultobj;
11198 fail:
11199 return NULL;
11200 }
11201
11202
11203 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11204 PyObject *resultobj;
11205 wxImage *arg1 = (wxImage *) 0 ;
11206 wxRect *arg2 = 0 ;
11207 unsigned char arg3 ;
11208 unsigned char arg4 ;
11209 unsigned char arg5 ;
11210 wxRect temp2 ;
11211 PyObject * obj0 = 0 ;
11212 PyObject * obj1 = 0 ;
11213 PyObject * obj2 = 0 ;
11214 PyObject * obj3 = 0 ;
11215 PyObject * obj4 = 0 ;
11216 char *kwnames[] = {
11217 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11218 };
11219
11220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11222 if (SWIG_arg_fail(1)) SWIG_fail;
11223 {
11224 arg2 = &temp2;
11225 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11226 }
11227 {
11228 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11229 if (SWIG_arg_fail(3)) SWIG_fail;
11230 }
11231 {
11232 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11233 if (SWIG_arg_fail(4)) SWIG_fail;
11234 }
11235 {
11236 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11237 if (SWIG_arg_fail(5)) SWIG_fail;
11238 }
11239 {
11240 PyThreadState* __tstate = wxPyBeginAllowThreads();
11241 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11242
11243 wxPyEndAllowThreads(__tstate);
11244 if (PyErr_Occurred()) SWIG_fail;
11245 }
11246 Py_INCREF(Py_None); resultobj = Py_None;
11247 return resultobj;
11248 fail:
11249 return NULL;
11250 }
11251
11252
11253 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11254 PyObject *resultobj;
11255 wxImage *arg1 = (wxImage *) 0 ;
11256 int arg2 ;
11257 int arg3 ;
11258 unsigned char result;
11259 PyObject * obj0 = 0 ;
11260 PyObject * obj1 = 0 ;
11261 PyObject * obj2 = 0 ;
11262 char *kwnames[] = {
11263 (char *) "self",(char *) "x",(char *) "y", NULL
11264 };
11265
11266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11268 if (SWIG_arg_fail(1)) SWIG_fail;
11269 {
11270 arg2 = (int)(SWIG_As_int(obj1));
11271 if (SWIG_arg_fail(2)) SWIG_fail;
11272 }
11273 {
11274 arg3 = (int)(SWIG_As_int(obj2));
11275 if (SWIG_arg_fail(3)) SWIG_fail;
11276 }
11277 {
11278 PyThreadState* __tstate = wxPyBeginAllowThreads();
11279 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11280
11281 wxPyEndAllowThreads(__tstate);
11282 if (PyErr_Occurred()) SWIG_fail;
11283 }
11284 {
11285 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11286 }
11287 return resultobj;
11288 fail:
11289 return NULL;
11290 }
11291
11292
11293 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11294 PyObject *resultobj;
11295 wxImage *arg1 = (wxImage *) 0 ;
11296 int arg2 ;
11297 int arg3 ;
11298 unsigned char result;
11299 PyObject * obj0 = 0 ;
11300 PyObject * obj1 = 0 ;
11301 PyObject * obj2 = 0 ;
11302 char *kwnames[] = {
11303 (char *) "self",(char *) "x",(char *) "y", NULL
11304 };
11305
11306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11308 if (SWIG_arg_fail(1)) SWIG_fail;
11309 {
11310 arg2 = (int)(SWIG_As_int(obj1));
11311 if (SWIG_arg_fail(2)) SWIG_fail;
11312 }
11313 {
11314 arg3 = (int)(SWIG_As_int(obj2));
11315 if (SWIG_arg_fail(3)) SWIG_fail;
11316 }
11317 {
11318 PyThreadState* __tstate = wxPyBeginAllowThreads();
11319 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11320
11321 wxPyEndAllowThreads(__tstate);
11322 if (PyErr_Occurred()) SWIG_fail;
11323 }
11324 {
11325 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11326 }
11327 return resultobj;
11328 fail:
11329 return NULL;
11330 }
11331
11332
11333 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11334 PyObject *resultobj;
11335 wxImage *arg1 = (wxImage *) 0 ;
11336 int arg2 ;
11337 int arg3 ;
11338 unsigned char result;
11339 PyObject * obj0 = 0 ;
11340 PyObject * obj1 = 0 ;
11341 PyObject * obj2 = 0 ;
11342 char *kwnames[] = {
11343 (char *) "self",(char *) "x",(char *) "y", NULL
11344 };
11345
11346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11348 if (SWIG_arg_fail(1)) SWIG_fail;
11349 {
11350 arg2 = (int)(SWIG_As_int(obj1));
11351 if (SWIG_arg_fail(2)) SWIG_fail;
11352 }
11353 {
11354 arg3 = (int)(SWIG_As_int(obj2));
11355 if (SWIG_arg_fail(3)) SWIG_fail;
11356 }
11357 {
11358 PyThreadState* __tstate = wxPyBeginAllowThreads();
11359 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11360
11361 wxPyEndAllowThreads(__tstate);
11362 if (PyErr_Occurred()) SWIG_fail;
11363 }
11364 {
11365 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11366 }
11367 return resultobj;
11368 fail:
11369 return NULL;
11370 }
11371
11372
11373 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11374 PyObject *resultobj;
11375 wxImage *arg1 = (wxImage *) 0 ;
11376 int arg2 ;
11377 int arg3 ;
11378 unsigned char arg4 ;
11379 PyObject * obj0 = 0 ;
11380 PyObject * obj1 = 0 ;
11381 PyObject * obj2 = 0 ;
11382 PyObject * obj3 = 0 ;
11383 char *kwnames[] = {
11384 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11385 };
11386
11387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11389 if (SWIG_arg_fail(1)) SWIG_fail;
11390 {
11391 arg2 = (int)(SWIG_As_int(obj1));
11392 if (SWIG_arg_fail(2)) SWIG_fail;
11393 }
11394 {
11395 arg3 = (int)(SWIG_As_int(obj2));
11396 if (SWIG_arg_fail(3)) SWIG_fail;
11397 }
11398 {
11399 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11400 if (SWIG_arg_fail(4)) SWIG_fail;
11401 }
11402 {
11403 PyThreadState* __tstate = wxPyBeginAllowThreads();
11404 (arg1)->SetAlpha(arg2,arg3,arg4);
11405
11406 wxPyEndAllowThreads(__tstate);
11407 if (PyErr_Occurred()) SWIG_fail;
11408 }
11409 Py_INCREF(Py_None); resultobj = Py_None;
11410 return resultobj;
11411 fail:
11412 return NULL;
11413 }
11414
11415
11416 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11417 PyObject *resultobj;
11418 wxImage *arg1 = (wxImage *) 0 ;
11419 int arg2 ;
11420 int arg3 ;
11421 unsigned char result;
11422 PyObject * obj0 = 0 ;
11423 PyObject * obj1 = 0 ;
11424 PyObject * obj2 = 0 ;
11425 char *kwnames[] = {
11426 (char *) "self",(char *) "x",(char *) "y", NULL
11427 };
11428
11429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11431 if (SWIG_arg_fail(1)) SWIG_fail;
11432 {
11433 arg2 = (int)(SWIG_As_int(obj1));
11434 if (SWIG_arg_fail(2)) SWIG_fail;
11435 }
11436 {
11437 arg3 = (int)(SWIG_As_int(obj2));
11438 if (SWIG_arg_fail(3)) SWIG_fail;
11439 }
11440 {
11441 PyThreadState* __tstate = wxPyBeginAllowThreads();
11442 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11443
11444 wxPyEndAllowThreads(__tstate);
11445 if (PyErr_Occurred()) SWIG_fail;
11446 }
11447 {
11448 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11449 }
11450 return resultobj;
11451 fail:
11452 return NULL;
11453 }
11454
11455
11456 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11457 PyObject *resultobj;
11458 wxImage *arg1 = (wxImage *) 0 ;
11459 bool result;
11460 PyObject * obj0 = 0 ;
11461 char *kwnames[] = {
11462 (char *) "self", NULL
11463 };
11464
11465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11467 if (SWIG_arg_fail(1)) SWIG_fail;
11468 {
11469 PyThreadState* __tstate = wxPyBeginAllowThreads();
11470 result = (bool)(arg1)->HasAlpha();
11471
11472 wxPyEndAllowThreads(__tstate);
11473 if (PyErr_Occurred()) SWIG_fail;
11474 }
11475 {
11476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11477 }
11478 return resultobj;
11479 fail:
11480 return NULL;
11481 }
11482
11483
11484 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11485 PyObject *resultobj;
11486 wxImage *arg1 = (wxImage *) 0 ;
11487 PyObject * obj0 = 0 ;
11488 char *kwnames[] = {
11489 (char *) "self", NULL
11490 };
11491
11492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11494 if (SWIG_arg_fail(1)) SWIG_fail;
11495 {
11496 PyThreadState* __tstate = wxPyBeginAllowThreads();
11497 (arg1)->InitAlpha();
11498
11499 wxPyEndAllowThreads(__tstate);
11500 if (PyErr_Occurred()) SWIG_fail;
11501 }
11502 Py_INCREF(Py_None); resultobj = Py_None;
11503 return resultobj;
11504 fail:
11505 return NULL;
11506 }
11507
11508
11509 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
11510 PyObject *resultobj;
11511 wxImage *arg1 = (wxImage *) 0 ;
11512 int arg2 ;
11513 int arg3 ;
11514 unsigned char arg4 = (unsigned char) wxIMAGE_ALPHA_THRESHOLD ;
11515 bool result;
11516 PyObject * obj0 = 0 ;
11517 PyObject * obj1 = 0 ;
11518 PyObject * obj2 = 0 ;
11519 PyObject * obj3 = 0 ;
11520 char *kwnames[] = {
11521 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
11522 };
11523
11524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11526 if (SWIG_arg_fail(1)) SWIG_fail;
11527 {
11528 arg2 = (int)(SWIG_As_int(obj1));
11529 if (SWIG_arg_fail(2)) SWIG_fail;
11530 }
11531 {
11532 arg3 = (int)(SWIG_As_int(obj2));
11533 if (SWIG_arg_fail(3)) SWIG_fail;
11534 }
11535 if (obj3) {
11536 {
11537 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11538 if (SWIG_arg_fail(4)) SWIG_fail;
11539 }
11540 }
11541 {
11542 PyThreadState* __tstate = wxPyBeginAllowThreads();
11543 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
11544
11545 wxPyEndAllowThreads(__tstate);
11546 if (PyErr_Occurred()) SWIG_fail;
11547 }
11548 {
11549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11550 }
11551 return resultobj;
11552 fail:
11553 return NULL;
11554 }
11555
11556
11557 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11558 PyObject *resultobj;
11559 wxImage *arg1 = (wxImage *) 0 ;
11560 byte *arg2 = (byte *) 0 ;
11561 byte *arg3 = (byte *) 0 ;
11562 byte *arg4 = (byte *) 0 ;
11563 byte arg5 = (byte) 0 ;
11564 byte arg6 = (byte) 0 ;
11565 byte arg7 = (byte) 0 ;
11566 bool result;
11567 byte temp2 ;
11568 int res2 = 0 ;
11569 byte temp3 ;
11570 int res3 = 0 ;
11571 byte temp4 ;
11572 int res4 = 0 ;
11573 PyObject * obj0 = 0 ;
11574 PyObject * obj1 = 0 ;
11575 PyObject * obj2 = 0 ;
11576 PyObject * obj3 = 0 ;
11577 char *kwnames[] = {
11578 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11579 };
11580
11581 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11582 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11583 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11586 if (SWIG_arg_fail(1)) SWIG_fail;
11587 if (obj1) {
11588 {
11589 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11590 if (SWIG_arg_fail(5)) SWIG_fail;
11591 }
11592 }
11593 if (obj2) {
11594 {
11595 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11596 if (SWIG_arg_fail(6)) SWIG_fail;
11597 }
11598 }
11599 if (obj3) {
11600 {
11601 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11602 if (SWIG_arg_fail(7)) SWIG_fail;
11603 }
11604 }
11605 {
11606 PyThreadState* __tstate = wxPyBeginAllowThreads();
11607 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11608
11609 wxPyEndAllowThreads(__tstate);
11610 if (PyErr_Occurred()) SWIG_fail;
11611 }
11612 {
11613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11614 }
11615 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11616 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11617 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11618 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11619 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11620 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11621 return resultobj;
11622 fail:
11623 return NULL;
11624 }
11625
11626
11627 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11628 PyObject *resultobj;
11629 wxImage *arg1 = (wxImage *) 0 ;
11630 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
11631 bool result;
11632 PyObject * obj0 = 0 ;
11633 PyObject * obj1 = 0 ;
11634 char *kwnames[] = {
11635 (char *) "self",(char *) "threshold", NULL
11636 };
11637
11638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11640 if (SWIG_arg_fail(1)) SWIG_fail;
11641 if (obj1) {
11642 {
11643 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11644 if (SWIG_arg_fail(2)) SWIG_fail;
11645 }
11646 }
11647 {
11648 PyThreadState* __tstate = wxPyBeginAllowThreads();
11649 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11650
11651 wxPyEndAllowThreads(__tstate);
11652 if (PyErr_Occurred()) SWIG_fail;
11653 }
11654 {
11655 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11656 }
11657 return resultobj;
11658 fail:
11659 return NULL;
11660 }
11661
11662
11663 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11664 PyObject *resultobj;
11665 wxImage *arg1 = (wxImage *) 0 ;
11666 unsigned char arg2 ;
11667 unsigned char arg3 ;
11668 unsigned char arg4 ;
11669 bool result;
11670 PyObject * obj0 = 0 ;
11671 PyObject * obj1 = 0 ;
11672 PyObject * obj2 = 0 ;
11673 PyObject * obj3 = 0 ;
11674 char *kwnames[] = {
11675 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11676 };
11677
11678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11680 if (SWIG_arg_fail(1)) SWIG_fail;
11681 {
11682 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11683 if (SWIG_arg_fail(2)) SWIG_fail;
11684 }
11685 {
11686 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11687 if (SWIG_arg_fail(3)) SWIG_fail;
11688 }
11689 {
11690 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11691 if (SWIG_arg_fail(4)) SWIG_fail;
11692 }
11693 {
11694 PyThreadState* __tstate = wxPyBeginAllowThreads();
11695 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11696
11697 wxPyEndAllowThreads(__tstate);
11698 if (PyErr_Occurred()) SWIG_fail;
11699 }
11700 {
11701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11702 }
11703 return resultobj;
11704 fail:
11705 return NULL;
11706 }
11707
11708
11709 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11710 PyObject *resultobj;
11711 wxImage *arg1 = (wxImage *) 0 ;
11712 wxImage *arg2 = 0 ;
11713 byte arg3 ;
11714 byte arg4 ;
11715 byte arg5 ;
11716 bool result;
11717 PyObject * obj0 = 0 ;
11718 PyObject * obj1 = 0 ;
11719 PyObject * obj2 = 0 ;
11720 PyObject * obj3 = 0 ;
11721 PyObject * obj4 = 0 ;
11722 char *kwnames[] = {
11723 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11724 };
11725
11726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11728 if (SWIG_arg_fail(1)) SWIG_fail;
11729 {
11730 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11731 if (SWIG_arg_fail(2)) SWIG_fail;
11732 if (arg2 == NULL) {
11733 SWIG_null_ref("wxImage");
11734 }
11735 if (SWIG_arg_fail(2)) SWIG_fail;
11736 }
11737 {
11738 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11739 if (SWIG_arg_fail(3)) SWIG_fail;
11740 }
11741 {
11742 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11743 if (SWIG_arg_fail(4)) SWIG_fail;
11744 }
11745 {
11746 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11747 if (SWIG_arg_fail(5)) SWIG_fail;
11748 }
11749 {
11750 PyThreadState* __tstate = wxPyBeginAllowThreads();
11751 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11752
11753 wxPyEndAllowThreads(__tstate);
11754 if (PyErr_Occurred()) SWIG_fail;
11755 }
11756 {
11757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11758 }
11759 return resultobj;
11760 fail:
11761 return NULL;
11762 }
11763
11764
11765 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11766 PyObject *resultobj;
11767 wxString *arg1 = 0 ;
11768 bool result;
11769 bool temp1 = false ;
11770 PyObject * obj0 = 0 ;
11771 char *kwnames[] = {
11772 (char *) "name", NULL
11773 };
11774
11775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11776 {
11777 arg1 = wxString_in_helper(obj0);
11778 if (arg1 == NULL) SWIG_fail;
11779 temp1 = true;
11780 }
11781 {
11782 PyThreadState* __tstate = wxPyBeginAllowThreads();
11783 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11784
11785 wxPyEndAllowThreads(__tstate);
11786 if (PyErr_Occurred()) SWIG_fail;
11787 }
11788 {
11789 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11790 }
11791 {
11792 if (temp1)
11793 delete arg1;
11794 }
11795 return resultobj;
11796 fail:
11797 {
11798 if (temp1)
11799 delete arg1;
11800 }
11801 return NULL;
11802 }
11803
11804
11805 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11806 PyObject *resultobj;
11807 wxString *arg1 = 0 ;
11808 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11809 int result;
11810 bool temp1 = false ;
11811 PyObject * obj0 = 0 ;
11812 PyObject * obj1 = 0 ;
11813 char *kwnames[] = {
11814 (char *) "name",(char *) "type", NULL
11815 };
11816
11817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11818 {
11819 arg1 = wxString_in_helper(obj0);
11820 if (arg1 == NULL) SWIG_fail;
11821 temp1 = true;
11822 }
11823 if (obj1) {
11824 {
11825 arg2 = (long)(SWIG_As_long(obj1));
11826 if (SWIG_arg_fail(2)) SWIG_fail;
11827 }
11828 }
11829 {
11830 PyThreadState* __tstate = wxPyBeginAllowThreads();
11831 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11832
11833 wxPyEndAllowThreads(__tstate);
11834 if (PyErr_Occurred()) SWIG_fail;
11835 }
11836 {
11837 resultobj = SWIG_From_int((int)(result));
11838 }
11839 {
11840 if (temp1)
11841 delete arg1;
11842 }
11843 return resultobj;
11844 fail:
11845 {
11846 if (temp1)
11847 delete arg1;
11848 }
11849 return NULL;
11850 }
11851
11852
11853 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11854 PyObject *resultobj;
11855 wxImage *arg1 = (wxImage *) 0 ;
11856 wxString *arg2 = 0 ;
11857 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11858 int arg4 = (int) -1 ;
11859 bool result;
11860 bool temp2 = false ;
11861 PyObject * obj0 = 0 ;
11862 PyObject * obj1 = 0 ;
11863 PyObject * obj2 = 0 ;
11864 PyObject * obj3 = 0 ;
11865 char *kwnames[] = {
11866 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11867 };
11868
11869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11871 if (SWIG_arg_fail(1)) SWIG_fail;
11872 {
11873 arg2 = wxString_in_helper(obj1);
11874 if (arg2 == NULL) SWIG_fail;
11875 temp2 = true;
11876 }
11877 if (obj2) {
11878 {
11879 arg3 = (long)(SWIG_As_long(obj2));
11880 if (SWIG_arg_fail(3)) SWIG_fail;
11881 }
11882 }
11883 if (obj3) {
11884 {
11885 arg4 = (int)(SWIG_As_int(obj3));
11886 if (SWIG_arg_fail(4)) SWIG_fail;
11887 }
11888 }
11889 {
11890 PyThreadState* __tstate = wxPyBeginAllowThreads();
11891 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11892
11893 wxPyEndAllowThreads(__tstate);
11894 if (PyErr_Occurred()) SWIG_fail;
11895 }
11896 {
11897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11898 }
11899 {
11900 if (temp2)
11901 delete arg2;
11902 }
11903 return resultobj;
11904 fail:
11905 {
11906 if (temp2)
11907 delete arg2;
11908 }
11909 return NULL;
11910 }
11911
11912
11913 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11914 PyObject *resultobj;
11915 wxImage *arg1 = (wxImage *) 0 ;
11916 wxString *arg2 = 0 ;
11917 wxString *arg3 = 0 ;
11918 int arg4 = (int) -1 ;
11919 bool result;
11920 bool temp2 = false ;
11921 bool temp3 = false ;
11922 PyObject * obj0 = 0 ;
11923 PyObject * obj1 = 0 ;
11924 PyObject * obj2 = 0 ;
11925 PyObject * obj3 = 0 ;
11926 char *kwnames[] = {
11927 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11928 };
11929
11930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11932 if (SWIG_arg_fail(1)) SWIG_fail;
11933 {
11934 arg2 = wxString_in_helper(obj1);
11935 if (arg2 == NULL) SWIG_fail;
11936 temp2 = true;
11937 }
11938 {
11939 arg3 = wxString_in_helper(obj2);
11940 if (arg3 == NULL) SWIG_fail;
11941 temp3 = true;
11942 }
11943 if (obj3) {
11944 {
11945 arg4 = (int)(SWIG_As_int(obj3));
11946 if (SWIG_arg_fail(4)) SWIG_fail;
11947 }
11948 }
11949 {
11950 PyThreadState* __tstate = wxPyBeginAllowThreads();
11951 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11952
11953 wxPyEndAllowThreads(__tstate);
11954 if (PyErr_Occurred()) SWIG_fail;
11955 }
11956 {
11957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11958 }
11959 {
11960 if (temp2)
11961 delete arg2;
11962 }
11963 {
11964 if (temp3)
11965 delete arg3;
11966 }
11967 return resultobj;
11968 fail:
11969 {
11970 if (temp2)
11971 delete arg2;
11972 }
11973 {
11974 if (temp3)
11975 delete arg3;
11976 }
11977 return NULL;
11978 }
11979
11980
11981 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11982 PyObject *resultobj;
11983 wxImage *arg1 = (wxImage *) 0 ;
11984 wxString *arg2 = 0 ;
11985 int arg3 ;
11986 bool result;
11987 bool temp2 = false ;
11988 PyObject * obj0 = 0 ;
11989 PyObject * obj1 = 0 ;
11990 PyObject * obj2 = 0 ;
11991 char *kwnames[] = {
11992 (char *) "self",(char *) "name",(char *) "type", NULL
11993 };
11994
11995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11997 if (SWIG_arg_fail(1)) SWIG_fail;
11998 {
11999 arg2 = wxString_in_helper(obj1);
12000 if (arg2 == NULL) SWIG_fail;
12001 temp2 = true;
12002 }
12003 {
12004 arg3 = (int)(SWIG_As_int(obj2));
12005 if (SWIG_arg_fail(3)) SWIG_fail;
12006 }
12007 {
12008 PyThreadState* __tstate = wxPyBeginAllowThreads();
12009 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12010
12011 wxPyEndAllowThreads(__tstate);
12012 if (PyErr_Occurred()) SWIG_fail;
12013 }
12014 {
12015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12016 }
12017 {
12018 if (temp2)
12019 delete arg2;
12020 }
12021 return resultobj;
12022 fail:
12023 {
12024 if (temp2)
12025 delete arg2;
12026 }
12027 return NULL;
12028 }
12029
12030
12031 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12032 PyObject *resultobj;
12033 wxImage *arg1 = (wxImage *) 0 ;
12034 wxString *arg2 = 0 ;
12035 wxString *arg3 = 0 ;
12036 bool result;
12037 bool temp2 = false ;
12038 bool temp3 = false ;
12039 PyObject * obj0 = 0 ;
12040 PyObject * obj1 = 0 ;
12041 PyObject * obj2 = 0 ;
12042 char *kwnames[] = {
12043 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12044 };
12045
12046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12048 if (SWIG_arg_fail(1)) SWIG_fail;
12049 {
12050 arg2 = wxString_in_helper(obj1);
12051 if (arg2 == NULL) SWIG_fail;
12052 temp2 = true;
12053 }
12054 {
12055 arg3 = wxString_in_helper(obj2);
12056 if (arg3 == NULL) SWIG_fail;
12057 temp3 = true;
12058 }
12059 {
12060 PyThreadState* __tstate = wxPyBeginAllowThreads();
12061 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12062
12063 wxPyEndAllowThreads(__tstate);
12064 if (PyErr_Occurred()) SWIG_fail;
12065 }
12066 {
12067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12068 }
12069 {
12070 if (temp2)
12071 delete arg2;
12072 }
12073 {
12074 if (temp3)
12075 delete arg3;
12076 }
12077 return resultobj;
12078 fail:
12079 {
12080 if (temp2)
12081 delete arg2;
12082 }
12083 {
12084 if (temp3)
12085 delete arg3;
12086 }
12087 return NULL;
12088 }
12089
12090
12091 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12092 PyObject *resultobj;
12093 wxInputStream *arg1 = 0 ;
12094 bool result;
12095 wxPyInputStream *temp1 ;
12096 bool created1 ;
12097 PyObject * obj0 = 0 ;
12098 char *kwnames[] = {
12099 (char *) "stream", NULL
12100 };
12101
12102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12103 {
12104 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12105 arg1 = temp1->m_wxis;
12106 created1 = false;
12107 } else {
12108 PyErr_Clear(); // clear the failure of the wxPyConvert above
12109 arg1 = wxPyCBInputStream_create(obj0, false);
12110 if (arg1 == NULL) {
12111 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12112 SWIG_fail;
12113 }
12114 created1 = true;
12115 }
12116 }
12117 {
12118 PyThreadState* __tstate = wxPyBeginAllowThreads();
12119 result = (bool)wxImage::CanRead(*arg1);
12120
12121 wxPyEndAllowThreads(__tstate);
12122 if (PyErr_Occurred()) SWIG_fail;
12123 }
12124 {
12125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12126 }
12127 {
12128 if (created1) delete arg1;
12129 }
12130 return resultobj;
12131 fail:
12132 {
12133 if (created1) delete arg1;
12134 }
12135 return NULL;
12136 }
12137
12138
12139 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12140 PyObject *resultobj;
12141 wxImage *arg1 = (wxImage *) 0 ;
12142 wxInputStream *arg2 = 0 ;
12143 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12144 int arg4 = (int) -1 ;
12145 bool result;
12146 wxPyInputStream *temp2 ;
12147 bool created2 ;
12148 PyObject * obj0 = 0 ;
12149 PyObject * obj1 = 0 ;
12150 PyObject * obj2 = 0 ;
12151 PyObject * obj3 = 0 ;
12152 char *kwnames[] = {
12153 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12154 };
12155
12156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12158 if (SWIG_arg_fail(1)) SWIG_fail;
12159 {
12160 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12161 arg2 = temp2->m_wxis;
12162 created2 = false;
12163 } else {
12164 PyErr_Clear(); // clear the failure of the wxPyConvert above
12165 arg2 = wxPyCBInputStream_create(obj1, false);
12166 if (arg2 == NULL) {
12167 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12168 SWIG_fail;
12169 }
12170 created2 = true;
12171 }
12172 }
12173 if (obj2) {
12174 {
12175 arg3 = (long)(SWIG_As_long(obj2));
12176 if (SWIG_arg_fail(3)) SWIG_fail;
12177 }
12178 }
12179 if (obj3) {
12180 {
12181 arg4 = (int)(SWIG_As_int(obj3));
12182 if (SWIG_arg_fail(4)) SWIG_fail;
12183 }
12184 }
12185 {
12186 PyThreadState* __tstate = wxPyBeginAllowThreads();
12187 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12188
12189 wxPyEndAllowThreads(__tstate);
12190 if (PyErr_Occurred()) SWIG_fail;
12191 }
12192 {
12193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12194 }
12195 {
12196 if (created2) delete arg2;
12197 }
12198 return resultobj;
12199 fail:
12200 {
12201 if (created2) delete arg2;
12202 }
12203 return NULL;
12204 }
12205
12206
12207 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12208 PyObject *resultobj;
12209 wxImage *arg1 = (wxImage *) 0 ;
12210 wxInputStream *arg2 = 0 ;
12211 wxString *arg3 = 0 ;
12212 int arg4 = (int) -1 ;
12213 bool result;
12214 wxPyInputStream *temp2 ;
12215 bool created2 ;
12216 bool temp3 = false ;
12217 PyObject * obj0 = 0 ;
12218 PyObject * obj1 = 0 ;
12219 PyObject * obj2 = 0 ;
12220 PyObject * obj3 = 0 ;
12221 char *kwnames[] = {
12222 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12223 };
12224
12225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12227 if (SWIG_arg_fail(1)) SWIG_fail;
12228 {
12229 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12230 arg2 = temp2->m_wxis;
12231 created2 = false;
12232 } else {
12233 PyErr_Clear(); // clear the failure of the wxPyConvert above
12234 arg2 = wxPyCBInputStream_create(obj1, false);
12235 if (arg2 == NULL) {
12236 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12237 SWIG_fail;
12238 }
12239 created2 = true;
12240 }
12241 }
12242 {
12243 arg3 = wxString_in_helper(obj2);
12244 if (arg3 == NULL) SWIG_fail;
12245 temp3 = true;
12246 }
12247 if (obj3) {
12248 {
12249 arg4 = (int)(SWIG_As_int(obj3));
12250 if (SWIG_arg_fail(4)) SWIG_fail;
12251 }
12252 }
12253 {
12254 PyThreadState* __tstate = wxPyBeginAllowThreads();
12255 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12256
12257 wxPyEndAllowThreads(__tstate);
12258 if (PyErr_Occurred()) SWIG_fail;
12259 }
12260 {
12261 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12262 }
12263 {
12264 if (created2) delete arg2;
12265 }
12266 {
12267 if (temp3)
12268 delete arg3;
12269 }
12270 return resultobj;
12271 fail:
12272 {
12273 if (created2) delete arg2;
12274 }
12275 {
12276 if (temp3)
12277 delete arg3;
12278 }
12279 return NULL;
12280 }
12281
12282
12283 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12284 PyObject *resultobj;
12285 wxImage *arg1 = (wxImage *) 0 ;
12286 bool result;
12287 PyObject * obj0 = 0 ;
12288 char *kwnames[] = {
12289 (char *) "self", NULL
12290 };
12291
12292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12294 if (SWIG_arg_fail(1)) SWIG_fail;
12295 {
12296 PyThreadState* __tstate = wxPyBeginAllowThreads();
12297 result = (bool)(arg1)->Ok();
12298
12299 wxPyEndAllowThreads(__tstate);
12300 if (PyErr_Occurred()) SWIG_fail;
12301 }
12302 {
12303 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12304 }
12305 return resultobj;
12306 fail:
12307 return NULL;
12308 }
12309
12310
12311 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12312 PyObject *resultobj;
12313 wxImage *arg1 = (wxImage *) 0 ;
12314 int result;
12315 PyObject * obj0 = 0 ;
12316 char *kwnames[] = {
12317 (char *) "self", NULL
12318 };
12319
12320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12322 if (SWIG_arg_fail(1)) SWIG_fail;
12323 {
12324 PyThreadState* __tstate = wxPyBeginAllowThreads();
12325 result = (int)(arg1)->GetWidth();
12326
12327 wxPyEndAllowThreads(__tstate);
12328 if (PyErr_Occurred()) SWIG_fail;
12329 }
12330 {
12331 resultobj = SWIG_From_int((int)(result));
12332 }
12333 return resultobj;
12334 fail:
12335 return NULL;
12336 }
12337
12338
12339 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12340 PyObject *resultobj;
12341 wxImage *arg1 = (wxImage *) 0 ;
12342 int result;
12343 PyObject * obj0 = 0 ;
12344 char *kwnames[] = {
12345 (char *) "self", NULL
12346 };
12347
12348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12350 if (SWIG_arg_fail(1)) SWIG_fail;
12351 {
12352 PyThreadState* __tstate = wxPyBeginAllowThreads();
12353 result = (int)(arg1)->GetHeight();
12354
12355 wxPyEndAllowThreads(__tstate);
12356 if (PyErr_Occurred()) SWIG_fail;
12357 }
12358 {
12359 resultobj = SWIG_From_int((int)(result));
12360 }
12361 return resultobj;
12362 fail:
12363 return NULL;
12364 }
12365
12366
12367 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12368 PyObject *resultobj;
12369 wxImage *arg1 = (wxImage *) 0 ;
12370 wxSize result;
12371 PyObject * obj0 = 0 ;
12372 char *kwnames[] = {
12373 (char *) "self", NULL
12374 };
12375
12376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12378 if (SWIG_arg_fail(1)) SWIG_fail;
12379 {
12380 PyThreadState* __tstate = wxPyBeginAllowThreads();
12381 result = wxImage_GetSize(arg1);
12382
12383 wxPyEndAllowThreads(__tstate);
12384 if (PyErr_Occurred()) SWIG_fail;
12385 }
12386 {
12387 wxSize * resultptr;
12388 resultptr = new wxSize((wxSize &)(result));
12389 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12390 }
12391 return resultobj;
12392 fail:
12393 return NULL;
12394 }
12395
12396
12397 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12398 PyObject *resultobj;
12399 wxImage *arg1 = (wxImage *) 0 ;
12400 wxRect *arg2 = 0 ;
12401 SwigValueWrapper<wxImage > result;
12402 wxRect temp2 ;
12403 PyObject * obj0 = 0 ;
12404 PyObject * obj1 = 0 ;
12405 char *kwnames[] = {
12406 (char *) "self",(char *) "rect", NULL
12407 };
12408
12409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12411 if (SWIG_arg_fail(1)) SWIG_fail;
12412 {
12413 arg2 = &temp2;
12414 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12415 }
12416 {
12417 PyThreadState* __tstate = wxPyBeginAllowThreads();
12418 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12419
12420 wxPyEndAllowThreads(__tstate);
12421 if (PyErr_Occurred()) SWIG_fail;
12422 }
12423 {
12424 wxImage * resultptr;
12425 resultptr = new wxImage((wxImage &)(result));
12426 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12427 }
12428 return resultobj;
12429 fail:
12430 return NULL;
12431 }
12432
12433
12434 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12435 PyObject *resultobj;
12436 wxImage *arg1 = (wxImage *) 0 ;
12437 wxSize *arg2 = 0 ;
12438 wxPoint *arg3 = 0 ;
12439 int arg4 = (int) -1 ;
12440 int arg5 = (int) -1 ;
12441 int arg6 = (int) -1 ;
12442 SwigValueWrapper<wxImage > result;
12443 wxSize temp2 ;
12444 wxPoint temp3 ;
12445 PyObject * obj0 = 0 ;
12446 PyObject * obj1 = 0 ;
12447 PyObject * obj2 = 0 ;
12448 PyObject * obj3 = 0 ;
12449 PyObject * obj4 = 0 ;
12450 PyObject * obj5 = 0 ;
12451 char *kwnames[] = {
12452 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12453 };
12454
12455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12457 if (SWIG_arg_fail(1)) SWIG_fail;
12458 {
12459 arg2 = &temp2;
12460 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12461 }
12462 {
12463 arg3 = &temp3;
12464 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12465 }
12466 if (obj3) {
12467 {
12468 arg4 = (int)(SWIG_As_int(obj3));
12469 if (SWIG_arg_fail(4)) SWIG_fail;
12470 }
12471 }
12472 if (obj4) {
12473 {
12474 arg5 = (int)(SWIG_As_int(obj4));
12475 if (SWIG_arg_fail(5)) SWIG_fail;
12476 }
12477 }
12478 if (obj5) {
12479 {
12480 arg6 = (int)(SWIG_As_int(obj5));
12481 if (SWIG_arg_fail(6)) SWIG_fail;
12482 }
12483 }
12484 {
12485 PyThreadState* __tstate = wxPyBeginAllowThreads();
12486 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12487
12488 wxPyEndAllowThreads(__tstate);
12489 if (PyErr_Occurred()) SWIG_fail;
12490 }
12491 {
12492 wxImage * resultptr;
12493 resultptr = new wxImage((wxImage &)(result));
12494 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12495 }
12496 return resultobj;
12497 fail:
12498 return NULL;
12499 }
12500
12501
12502 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12503 PyObject *resultobj;
12504 wxImage *arg1 = (wxImage *) 0 ;
12505 SwigValueWrapper<wxImage > result;
12506 PyObject * obj0 = 0 ;
12507 char *kwnames[] = {
12508 (char *) "self", NULL
12509 };
12510
12511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12513 if (SWIG_arg_fail(1)) SWIG_fail;
12514 {
12515 PyThreadState* __tstate = wxPyBeginAllowThreads();
12516 result = (arg1)->Copy();
12517
12518 wxPyEndAllowThreads(__tstate);
12519 if (PyErr_Occurred()) SWIG_fail;
12520 }
12521 {
12522 wxImage * resultptr;
12523 resultptr = new wxImage((wxImage &)(result));
12524 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12525 }
12526 return resultobj;
12527 fail:
12528 return NULL;
12529 }
12530
12531
12532 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12533 PyObject *resultobj;
12534 wxImage *arg1 = (wxImage *) 0 ;
12535 wxImage *arg2 = 0 ;
12536 int arg3 ;
12537 int arg4 ;
12538 PyObject * obj0 = 0 ;
12539 PyObject * obj1 = 0 ;
12540 PyObject * obj2 = 0 ;
12541 PyObject * obj3 = 0 ;
12542 char *kwnames[] = {
12543 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12544 };
12545
12546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12548 if (SWIG_arg_fail(1)) SWIG_fail;
12549 {
12550 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12551 if (SWIG_arg_fail(2)) SWIG_fail;
12552 if (arg2 == NULL) {
12553 SWIG_null_ref("wxImage");
12554 }
12555 if (SWIG_arg_fail(2)) SWIG_fail;
12556 }
12557 {
12558 arg3 = (int)(SWIG_As_int(obj2));
12559 if (SWIG_arg_fail(3)) SWIG_fail;
12560 }
12561 {
12562 arg4 = (int)(SWIG_As_int(obj3));
12563 if (SWIG_arg_fail(4)) SWIG_fail;
12564 }
12565 {
12566 PyThreadState* __tstate = wxPyBeginAllowThreads();
12567 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12568
12569 wxPyEndAllowThreads(__tstate);
12570 if (PyErr_Occurred()) SWIG_fail;
12571 }
12572 Py_INCREF(Py_None); resultobj = Py_None;
12573 return resultobj;
12574 fail:
12575 return NULL;
12576 }
12577
12578
12579 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12580 PyObject *resultobj;
12581 wxImage *arg1 = (wxImage *) 0 ;
12582 PyObject *result;
12583 PyObject * obj0 = 0 ;
12584 char *kwnames[] = {
12585 (char *) "self", NULL
12586 };
12587
12588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12590 if (SWIG_arg_fail(1)) SWIG_fail;
12591 {
12592 PyThreadState* __tstate = wxPyBeginAllowThreads();
12593 result = (PyObject *)wxImage_GetData(arg1);
12594
12595 wxPyEndAllowThreads(__tstate);
12596 if (PyErr_Occurred()) SWIG_fail;
12597 }
12598 resultobj = result;
12599 return resultobj;
12600 fail:
12601 return NULL;
12602 }
12603
12604
12605 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12606 PyObject *resultobj;
12607 wxImage *arg1 = (wxImage *) 0 ;
12608 buffer arg2 ;
12609 int arg3 ;
12610 PyObject * obj0 = 0 ;
12611 PyObject * obj1 = 0 ;
12612 char *kwnames[] = {
12613 (char *) "self",(char *) "data", NULL
12614 };
12615
12616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12618 if (SWIG_arg_fail(1)) SWIG_fail;
12619 {
12620 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12621 }
12622 {
12623 PyThreadState* __tstate = wxPyBeginAllowThreads();
12624 wxImage_SetData(arg1,arg2,arg3);
12625
12626 wxPyEndAllowThreads(__tstate);
12627 if (PyErr_Occurred()) SWIG_fail;
12628 }
12629 Py_INCREF(Py_None); resultobj = Py_None;
12630 return resultobj;
12631 fail:
12632 return NULL;
12633 }
12634
12635
12636 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12637 PyObject *resultobj;
12638 wxImage *arg1 = (wxImage *) 0 ;
12639 PyObject *result;
12640 PyObject * obj0 = 0 ;
12641 char *kwnames[] = {
12642 (char *) "self", NULL
12643 };
12644
12645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12647 if (SWIG_arg_fail(1)) SWIG_fail;
12648 {
12649 PyThreadState* __tstate = wxPyBeginAllowThreads();
12650 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12651
12652 wxPyEndAllowThreads(__tstate);
12653 if (PyErr_Occurred()) SWIG_fail;
12654 }
12655 resultobj = result;
12656 return resultobj;
12657 fail:
12658 return NULL;
12659 }
12660
12661
12662 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12663 PyObject *resultobj;
12664 wxImage *arg1 = (wxImage *) 0 ;
12665 buffer arg2 ;
12666 int arg3 ;
12667 PyObject * obj0 = 0 ;
12668 PyObject * obj1 = 0 ;
12669 char *kwnames[] = {
12670 (char *) "self",(char *) "data", NULL
12671 };
12672
12673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12675 if (SWIG_arg_fail(1)) SWIG_fail;
12676 {
12677 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12678 }
12679 {
12680 PyThreadState* __tstate = wxPyBeginAllowThreads();
12681 wxImage_SetDataBuffer(arg1,arg2,arg3);
12682
12683 wxPyEndAllowThreads(__tstate);
12684 if (PyErr_Occurred()) SWIG_fail;
12685 }
12686 Py_INCREF(Py_None); resultobj = Py_None;
12687 return resultobj;
12688 fail:
12689 return NULL;
12690 }
12691
12692
12693 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12694 PyObject *resultobj;
12695 wxImage *arg1 = (wxImage *) 0 ;
12696 PyObject *result;
12697 PyObject * obj0 = 0 ;
12698 char *kwnames[] = {
12699 (char *) "self", NULL
12700 };
12701
12702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
12703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12704 if (SWIG_arg_fail(1)) SWIG_fail;
12705 {
12706 PyThreadState* __tstate = wxPyBeginAllowThreads();
12707 result = (PyObject *)wxImage_GetAlphaData(arg1);
12708
12709 wxPyEndAllowThreads(__tstate);
12710 if (PyErr_Occurred()) SWIG_fail;
12711 }
12712 resultobj = result;
12713 return resultobj;
12714 fail:
12715 return NULL;
12716 }
12717
12718
12719 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12720 PyObject *resultobj;
12721 wxImage *arg1 = (wxImage *) 0 ;
12722 buffer arg2 ;
12723 int arg3 ;
12724 PyObject * obj0 = 0 ;
12725 PyObject * obj1 = 0 ;
12726 char *kwnames[] = {
12727 (char *) "self",(char *) "alpha", NULL
12728 };
12729
12730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12732 if (SWIG_arg_fail(1)) SWIG_fail;
12733 {
12734 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12735 }
12736 {
12737 PyThreadState* __tstate = wxPyBeginAllowThreads();
12738 wxImage_SetAlphaData(arg1,arg2,arg3);
12739
12740 wxPyEndAllowThreads(__tstate);
12741 if (PyErr_Occurred()) SWIG_fail;
12742 }
12743 Py_INCREF(Py_None); resultobj = Py_None;
12744 return resultobj;
12745 fail:
12746 return NULL;
12747 }
12748
12749
12750 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12751 PyObject *resultobj;
12752 wxImage *arg1 = (wxImage *) 0 ;
12753 PyObject *result;
12754 PyObject * obj0 = 0 ;
12755 char *kwnames[] = {
12756 (char *) "self", NULL
12757 };
12758
12759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12761 if (SWIG_arg_fail(1)) SWIG_fail;
12762 {
12763 PyThreadState* __tstate = wxPyBeginAllowThreads();
12764 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12765
12766 wxPyEndAllowThreads(__tstate);
12767 if (PyErr_Occurred()) SWIG_fail;
12768 }
12769 resultobj = result;
12770 return resultobj;
12771 fail:
12772 return NULL;
12773 }
12774
12775
12776 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12777 PyObject *resultobj;
12778 wxImage *arg1 = (wxImage *) 0 ;
12779 buffer arg2 ;
12780 int arg3 ;
12781 PyObject * obj0 = 0 ;
12782 PyObject * obj1 = 0 ;
12783 char *kwnames[] = {
12784 (char *) "self",(char *) "alpha", NULL
12785 };
12786
12787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12789 if (SWIG_arg_fail(1)) SWIG_fail;
12790 {
12791 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12792 }
12793 {
12794 PyThreadState* __tstate = wxPyBeginAllowThreads();
12795 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
12796
12797 wxPyEndAllowThreads(__tstate);
12798 if (PyErr_Occurred()) SWIG_fail;
12799 }
12800 Py_INCREF(Py_None); resultobj = Py_None;
12801 return resultobj;
12802 fail:
12803 return NULL;
12804 }
12805
12806
12807 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12808 PyObject *resultobj;
12809 wxImage *arg1 = (wxImage *) 0 ;
12810 unsigned char arg2 ;
12811 unsigned char arg3 ;
12812 unsigned char arg4 ;
12813 PyObject * obj0 = 0 ;
12814 PyObject * obj1 = 0 ;
12815 PyObject * obj2 = 0 ;
12816 PyObject * obj3 = 0 ;
12817 char *kwnames[] = {
12818 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12819 };
12820
12821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12823 if (SWIG_arg_fail(1)) SWIG_fail;
12824 {
12825 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12826 if (SWIG_arg_fail(2)) SWIG_fail;
12827 }
12828 {
12829 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12830 if (SWIG_arg_fail(3)) SWIG_fail;
12831 }
12832 {
12833 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12834 if (SWIG_arg_fail(4)) SWIG_fail;
12835 }
12836 {
12837 PyThreadState* __tstate = wxPyBeginAllowThreads();
12838 (arg1)->SetMaskColour(arg2,arg3,arg4);
12839
12840 wxPyEndAllowThreads(__tstate);
12841 if (PyErr_Occurred()) SWIG_fail;
12842 }
12843 Py_INCREF(Py_None); resultobj = Py_None;
12844 return resultobj;
12845 fail:
12846 return NULL;
12847 }
12848
12849
12850 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12851 PyObject *resultobj;
12852 wxImage *arg1 = (wxImage *) 0 ;
12853 unsigned char *arg2 = (unsigned char *) 0 ;
12854 unsigned char *arg3 = (unsigned char *) 0 ;
12855 unsigned char *arg4 = (unsigned char *) 0 ;
12856 unsigned char temp2 ;
12857 int res2 = 0 ;
12858 unsigned char temp3 ;
12859 int res3 = 0 ;
12860 unsigned char temp4 ;
12861 int res4 = 0 ;
12862 PyObject * obj0 = 0 ;
12863 char *kwnames[] = {
12864 (char *) "self", NULL
12865 };
12866
12867 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12868 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12869 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
12871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12872 if (SWIG_arg_fail(1)) SWIG_fail;
12873 {
12874 PyThreadState* __tstate = wxPyBeginAllowThreads();
12875 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
12876
12877 wxPyEndAllowThreads(__tstate);
12878 if (PyErr_Occurred()) SWIG_fail;
12879 }
12880 Py_INCREF(Py_None); resultobj = Py_None;
12881 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12882 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12883 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12884 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12885 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12886 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12887 return resultobj;
12888 fail:
12889 return NULL;
12890 }
12891
12892
12893 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12894 PyObject *resultobj;
12895 wxImage *arg1 = (wxImage *) 0 ;
12896 unsigned char result;
12897 PyObject * obj0 = 0 ;
12898 char *kwnames[] = {
12899 (char *) "self", NULL
12900 };
12901
12902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12904 if (SWIG_arg_fail(1)) SWIG_fail;
12905 {
12906 PyThreadState* __tstate = wxPyBeginAllowThreads();
12907 result = (unsigned char)(arg1)->GetMaskRed();
12908
12909 wxPyEndAllowThreads(__tstate);
12910 if (PyErr_Occurred()) SWIG_fail;
12911 }
12912 {
12913 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12914 }
12915 return resultobj;
12916 fail:
12917 return NULL;
12918 }
12919
12920
12921 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12922 PyObject *resultobj;
12923 wxImage *arg1 = (wxImage *) 0 ;
12924 unsigned char result;
12925 PyObject * obj0 = 0 ;
12926 char *kwnames[] = {
12927 (char *) "self", NULL
12928 };
12929
12930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12932 if (SWIG_arg_fail(1)) SWIG_fail;
12933 {
12934 PyThreadState* __tstate = wxPyBeginAllowThreads();
12935 result = (unsigned char)(arg1)->GetMaskGreen();
12936
12937 wxPyEndAllowThreads(__tstate);
12938 if (PyErr_Occurred()) SWIG_fail;
12939 }
12940 {
12941 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12942 }
12943 return resultobj;
12944 fail:
12945 return NULL;
12946 }
12947
12948
12949 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12950 PyObject *resultobj;
12951 wxImage *arg1 = (wxImage *) 0 ;
12952 unsigned char result;
12953 PyObject * obj0 = 0 ;
12954 char *kwnames[] = {
12955 (char *) "self", NULL
12956 };
12957
12958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12960 if (SWIG_arg_fail(1)) SWIG_fail;
12961 {
12962 PyThreadState* __tstate = wxPyBeginAllowThreads();
12963 result = (unsigned char)(arg1)->GetMaskBlue();
12964
12965 wxPyEndAllowThreads(__tstate);
12966 if (PyErr_Occurred()) SWIG_fail;
12967 }
12968 {
12969 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12970 }
12971 return resultobj;
12972 fail:
12973 return NULL;
12974 }
12975
12976
12977 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12978 PyObject *resultobj;
12979 wxImage *arg1 = (wxImage *) 0 ;
12980 bool arg2 = (bool) true ;
12981 PyObject * obj0 = 0 ;
12982 PyObject * obj1 = 0 ;
12983 char *kwnames[] = {
12984 (char *) "self",(char *) "mask", NULL
12985 };
12986
12987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12989 if (SWIG_arg_fail(1)) SWIG_fail;
12990 if (obj1) {
12991 {
12992 arg2 = (bool)(SWIG_As_bool(obj1));
12993 if (SWIG_arg_fail(2)) SWIG_fail;
12994 }
12995 }
12996 {
12997 PyThreadState* __tstate = wxPyBeginAllowThreads();
12998 (arg1)->SetMask(arg2);
12999
13000 wxPyEndAllowThreads(__tstate);
13001 if (PyErr_Occurred()) SWIG_fail;
13002 }
13003 Py_INCREF(Py_None); resultobj = Py_None;
13004 return resultobj;
13005 fail:
13006 return NULL;
13007 }
13008
13009
13010 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13011 PyObject *resultobj;
13012 wxImage *arg1 = (wxImage *) 0 ;
13013 bool result;
13014 PyObject * obj0 = 0 ;
13015 char *kwnames[] = {
13016 (char *) "self", NULL
13017 };
13018
13019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13021 if (SWIG_arg_fail(1)) SWIG_fail;
13022 {
13023 PyThreadState* __tstate = wxPyBeginAllowThreads();
13024 result = (bool)(arg1)->HasMask();
13025
13026 wxPyEndAllowThreads(__tstate);
13027 if (PyErr_Occurred()) SWIG_fail;
13028 }
13029 {
13030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13031 }
13032 return resultobj;
13033 fail:
13034 return NULL;
13035 }
13036
13037
13038 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13039 PyObject *resultobj;
13040 wxImage *arg1 = (wxImage *) 0 ;
13041 double arg2 ;
13042 wxPoint *arg3 = 0 ;
13043 bool arg4 = (bool) true ;
13044 wxPoint *arg5 = (wxPoint *) NULL ;
13045 SwigValueWrapper<wxImage > result;
13046 wxPoint temp3 ;
13047 PyObject * obj0 = 0 ;
13048 PyObject * obj1 = 0 ;
13049 PyObject * obj2 = 0 ;
13050 PyObject * obj3 = 0 ;
13051 PyObject * obj4 = 0 ;
13052 char *kwnames[] = {
13053 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13054 };
13055
13056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13058 if (SWIG_arg_fail(1)) SWIG_fail;
13059 {
13060 arg2 = (double)(SWIG_As_double(obj1));
13061 if (SWIG_arg_fail(2)) SWIG_fail;
13062 }
13063 {
13064 arg3 = &temp3;
13065 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13066 }
13067 if (obj3) {
13068 {
13069 arg4 = (bool)(SWIG_As_bool(obj3));
13070 if (SWIG_arg_fail(4)) SWIG_fail;
13071 }
13072 }
13073 if (obj4) {
13074 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13075 if (SWIG_arg_fail(5)) SWIG_fail;
13076 }
13077 {
13078 PyThreadState* __tstate = wxPyBeginAllowThreads();
13079 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13080
13081 wxPyEndAllowThreads(__tstate);
13082 if (PyErr_Occurred()) SWIG_fail;
13083 }
13084 {
13085 wxImage * resultptr;
13086 resultptr = new wxImage((wxImage &)(result));
13087 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13088 }
13089 return resultobj;
13090 fail:
13091 return NULL;
13092 }
13093
13094
13095 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13096 PyObject *resultobj;
13097 wxImage *arg1 = (wxImage *) 0 ;
13098 bool arg2 = (bool) true ;
13099 SwigValueWrapper<wxImage > result;
13100 PyObject * obj0 = 0 ;
13101 PyObject * obj1 = 0 ;
13102 char *kwnames[] = {
13103 (char *) "self",(char *) "clockwise", NULL
13104 };
13105
13106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13108 if (SWIG_arg_fail(1)) SWIG_fail;
13109 if (obj1) {
13110 {
13111 arg2 = (bool)(SWIG_As_bool(obj1));
13112 if (SWIG_arg_fail(2)) SWIG_fail;
13113 }
13114 }
13115 {
13116 PyThreadState* __tstate = wxPyBeginAllowThreads();
13117 result = (arg1)->Rotate90(arg2);
13118
13119 wxPyEndAllowThreads(__tstate);
13120 if (PyErr_Occurred()) SWIG_fail;
13121 }
13122 {
13123 wxImage * resultptr;
13124 resultptr = new wxImage((wxImage &)(result));
13125 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13126 }
13127 return resultobj;
13128 fail:
13129 return NULL;
13130 }
13131
13132
13133 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13134 PyObject *resultobj;
13135 wxImage *arg1 = (wxImage *) 0 ;
13136 bool arg2 = (bool) true ;
13137 SwigValueWrapper<wxImage > result;
13138 PyObject * obj0 = 0 ;
13139 PyObject * obj1 = 0 ;
13140 char *kwnames[] = {
13141 (char *) "self",(char *) "horizontally", NULL
13142 };
13143
13144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13145 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13146 if (SWIG_arg_fail(1)) SWIG_fail;
13147 if (obj1) {
13148 {
13149 arg2 = (bool)(SWIG_As_bool(obj1));
13150 if (SWIG_arg_fail(2)) SWIG_fail;
13151 }
13152 }
13153 {
13154 PyThreadState* __tstate = wxPyBeginAllowThreads();
13155 result = (arg1)->Mirror(arg2);
13156
13157 wxPyEndAllowThreads(__tstate);
13158 if (PyErr_Occurred()) SWIG_fail;
13159 }
13160 {
13161 wxImage * resultptr;
13162 resultptr = new wxImage((wxImage &)(result));
13163 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13164 }
13165 return resultobj;
13166 fail:
13167 return NULL;
13168 }
13169
13170
13171 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13172 PyObject *resultobj;
13173 wxImage *arg1 = (wxImage *) 0 ;
13174 unsigned char arg2 ;
13175 unsigned char arg3 ;
13176 unsigned char arg4 ;
13177 unsigned char arg5 ;
13178 unsigned char arg6 ;
13179 unsigned char arg7 ;
13180 PyObject * obj0 = 0 ;
13181 PyObject * obj1 = 0 ;
13182 PyObject * obj2 = 0 ;
13183 PyObject * obj3 = 0 ;
13184 PyObject * obj4 = 0 ;
13185 PyObject * obj5 = 0 ;
13186 PyObject * obj6 = 0 ;
13187 char *kwnames[] = {
13188 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13189 };
13190
13191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13193 if (SWIG_arg_fail(1)) SWIG_fail;
13194 {
13195 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13196 if (SWIG_arg_fail(2)) SWIG_fail;
13197 }
13198 {
13199 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13200 if (SWIG_arg_fail(3)) SWIG_fail;
13201 }
13202 {
13203 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13204 if (SWIG_arg_fail(4)) SWIG_fail;
13205 }
13206 {
13207 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
13208 if (SWIG_arg_fail(5)) SWIG_fail;
13209 }
13210 {
13211 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
13212 if (SWIG_arg_fail(6)) SWIG_fail;
13213 }
13214 {
13215 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
13216 if (SWIG_arg_fail(7)) SWIG_fail;
13217 }
13218 {
13219 PyThreadState* __tstate = wxPyBeginAllowThreads();
13220 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13221
13222 wxPyEndAllowThreads(__tstate);
13223 if (PyErr_Occurred()) SWIG_fail;
13224 }
13225 Py_INCREF(Py_None); resultobj = Py_None;
13226 return resultobj;
13227 fail:
13228 return NULL;
13229 }
13230
13231
13232 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13233 PyObject *resultobj;
13234 wxImage *arg1 = (wxImage *) 0 ;
13235 unsigned char arg2 ;
13236 unsigned char arg3 ;
13237 unsigned char arg4 ;
13238 SwigValueWrapper<wxImage > result;
13239 PyObject * obj0 = 0 ;
13240 PyObject * obj1 = 0 ;
13241 PyObject * obj2 = 0 ;
13242 PyObject * obj3 = 0 ;
13243 char *kwnames[] = {
13244 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13245 };
13246
13247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13249 if (SWIG_arg_fail(1)) SWIG_fail;
13250 {
13251 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13252 if (SWIG_arg_fail(2)) SWIG_fail;
13253 }
13254 {
13255 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13256 if (SWIG_arg_fail(3)) SWIG_fail;
13257 }
13258 {
13259 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13260 if (SWIG_arg_fail(4)) SWIG_fail;
13261 }
13262 {
13263 PyThreadState* __tstate = wxPyBeginAllowThreads();
13264 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13265
13266 wxPyEndAllowThreads(__tstate);
13267 if (PyErr_Occurred()) SWIG_fail;
13268 }
13269 {
13270 wxImage * resultptr;
13271 resultptr = new wxImage((wxImage &)(result));
13272 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13273 }
13274 return resultobj;
13275 fail:
13276 return NULL;
13277 }
13278
13279
13280 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13281 PyObject *resultobj;
13282 wxImage *arg1 = (wxImage *) 0 ;
13283 wxString *arg2 = 0 ;
13284 wxString *arg3 = 0 ;
13285 bool temp2 = false ;
13286 bool temp3 = false ;
13287 PyObject * obj0 = 0 ;
13288 PyObject * obj1 = 0 ;
13289 PyObject * obj2 = 0 ;
13290 char *kwnames[] = {
13291 (char *) "self",(char *) "name",(char *) "value", NULL
13292 };
13293
13294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13296 if (SWIG_arg_fail(1)) SWIG_fail;
13297 {
13298 arg2 = wxString_in_helper(obj1);
13299 if (arg2 == NULL) SWIG_fail;
13300 temp2 = true;
13301 }
13302 {
13303 arg3 = wxString_in_helper(obj2);
13304 if (arg3 == NULL) SWIG_fail;
13305 temp3 = true;
13306 }
13307 {
13308 PyThreadState* __tstate = wxPyBeginAllowThreads();
13309 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13310
13311 wxPyEndAllowThreads(__tstate);
13312 if (PyErr_Occurred()) SWIG_fail;
13313 }
13314 Py_INCREF(Py_None); resultobj = Py_None;
13315 {
13316 if (temp2)
13317 delete arg2;
13318 }
13319 {
13320 if (temp3)
13321 delete arg3;
13322 }
13323 return resultobj;
13324 fail:
13325 {
13326 if (temp2)
13327 delete arg2;
13328 }
13329 {
13330 if (temp3)
13331 delete arg3;
13332 }
13333 return NULL;
13334 }
13335
13336
13337 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13338 PyObject *resultobj;
13339 wxImage *arg1 = (wxImage *) 0 ;
13340 wxString *arg2 = 0 ;
13341 int arg3 ;
13342 bool temp2 = false ;
13343 PyObject * obj0 = 0 ;
13344 PyObject * obj1 = 0 ;
13345 PyObject * obj2 = 0 ;
13346 char *kwnames[] = {
13347 (char *) "self",(char *) "name",(char *) "value", NULL
13348 };
13349
13350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13352 if (SWIG_arg_fail(1)) SWIG_fail;
13353 {
13354 arg2 = wxString_in_helper(obj1);
13355 if (arg2 == NULL) SWIG_fail;
13356 temp2 = true;
13357 }
13358 {
13359 arg3 = (int)(SWIG_As_int(obj2));
13360 if (SWIG_arg_fail(3)) SWIG_fail;
13361 }
13362 {
13363 PyThreadState* __tstate = wxPyBeginAllowThreads();
13364 (arg1)->SetOption((wxString const &)*arg2,arg3);
13365
13366 wxPyEndAllowThreads(__tstate);
13367 if (PyErr_Occurred()) SWIG_fail;
13368 }
13369 Py_INCREF(Py_None); resultobj = Py_None;
13370 {
13371 if (temp2)
13372 delete arg2;
13373 }
13374 return resultobj;
13375 fail:
13376 {
13377 if (temp2)
13378 delete arg2;
13379 }
13380 return NULL;
13381 }
13382
13383
13384 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13385 PyObject *resultobj;
13386 wxImage *arg1 = (wxImage *) 0 ;
13387 wxString *arg2 = 0 ;
13388 wxString result;
13389 bool temp2 = false ;
13390 PyObject * obj0 = 0 ;
13391 PyObject * obj1 = 0 ;
13392 char *kwnames[] = {
13393 (char *) "self",(char *) "name", NULL
13394 };
13395
13396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13398 if (SWIG_arg_fail(1)) SWIG_fail;
13399 {
13400 arg2 = wxString_in_helper(obj1);
13401 if (arg2 == NULL) SWIG_fail;
13402 temp2 = true;
13403 }
13404 {
13405 PyThreadState* __tstate = wxPyBeginAllowThreads();
13406 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13407
13408 wxPyEndAllowThreads(__tstate);
13409 if (PyErr_Occurred()) SWIG_fail;
13410 }
13411 {
13412 #if wxUSE_UNICODE
13413 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13414 #else
13415 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13416 #endif
13417 }
13418 {
13419 if (temp2)
13420 delete arg2;
13421 }
13422 return resultobj;
13423 fail:
13424 {
13425 if (temp2)
13426 delete arg2;
13427 }
13428 return NULL;
13429 }
13430
13431
13432 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13433 PyObject *resultobj;
13434 wxImage *arg1 = (wxImage *) 0 ;
13435 wxString *arg2 = 0 ;
13436 int result;
13437 bool temp2 = false ;
13438 PyObject * obj0 = 0 ;
13439 PyObject * obj1 = 0 ;
13440 char *kwnames[] = {
13441 (char *) "self",(char *) "name", NULL
13442 };
13443
13444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13446 if (SWIG_arg_fail(1)) SWIG_fail;
13447 {
13448 arg2 = wxString_in_helper(obj1);
13449 if (arg2 == NULL) SWIG_fail;
13450 temp2 = true;
13451 }
13452 {
13453 PyThreadState* __tstate = wxPyBeginAllowThreads();
13454 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13455
13456 wxPyEndAllowThreads(__tstate);
13457 if (PyErr_Occurred()) SWIG_fail;
13458 }
13459 {
13460 resultobj = SWIG_From_int((int)(result));
13461 }
13462 {
13463 if (temp2)
13464 delete arg2;
13465 }
13466 return resultobj;
13467 fail:
13468 {
13469 if (temp2)
13470 delete arg2;
13471 }
13472 return NULL;
13473 }
13474
13475
13476 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13477 PyObject *resultobj;
13478 wxImage *arg1 = (wxImage *) 0 ;
13479 wxString *arg2 = 0 ;
13480 bool result;
13481 bool temp2 = false ;
13482 PyObject * obj0 = 0 ;
13483 PyObject * obj1 = 0 ;
13484 char *kwnames[] = {
13485 (char *) "self",(char *) "name", NULL
13486 };
13487
13488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13490 if (SWIG_arg_fail(1)) SWIG_fail;
13491 {
13492 arg2 = wxString_in_helper(obj1);
13493 if (arg2 == NULL) SWIG_fail;
13494 temp2 = true;
13495 }
13496 {
13497 PyThreadState* __tstate = wxPyBeginAllowThreads();
13498 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13499
13500 wxPyEndAllowThreads(__tstate);
13501 if (PyErr_Occurred()) SWIG_fail;
13502 }
13503 {
13504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13505 }
13506 {
13507 if (temp2)
13508 delete arg2;
13509 }
13510 return resultobj;
13511 fail:
13512 {
13513 if (temp2)
13514 delete arg2;
13515 }
13516 return NULL;
13517 }
13518
13519
13520 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13521 PyObject *resultobj;
13522 wxImage *arg1 = (wxImage *) 0 ;
13523 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13524 unsigned long result;
13525 PyObject * obj0 = 0 ;
13526 PyObject * obj1 = 0 ;
13527 char *kwnames[] = {
13528 (char *) "self",(char *) "stopafter", NULL
13529 };
13530
13531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13533 if (SWIG_arg_fail(1)) SWIG_fail;
13534 if (obj1) {
13535 {
13536 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13537 if (SWIG_arg_fail(2)) SWIG_fail;
13538 }
13539 }
13540 {
13541 PyThreadState* __tstate = wxPyBeginAllowThreads();
13542 result = (unsigned long)(arg1)->CountColours(arg2);
13543
13544 wxPyEndAllowThreads(__tstate);
13545 if (PyErr_Occurred()) SWIG_fail;
13546 }
13547 {
13548 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13549 }
13550 return resultobj;
13551 fail:
13552 return NULL;
13553 }
13554
13555
13556 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13557 PyObject *resultobj;
13558 wxImage *arg1 = (wxImage *) 0 ;
13559 wxImageHistogram *arg2 = 0 ;
13560 unsigned long result;
13561 PyObject * obj0 = 0 ;
13562 PyObject * obj1 = 0 ;
13563 char *kwnames[] = {
13564 (char *) "self",(char *) "h", NULL
13565 };
13566
13567 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13568 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13569 if (SWIG_arg_fail(1)) SWIG_fail;
13570 {
13571 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13572 if (SWIG_arg_fail(2)) SWIG_fail;
13573 if (arg2 == NULL) {
13574 SWIG_null_ref("wxImageHistogram");
13575 }
13576 if (SWIG_arg_fail(2)) SWIG_fail;
13577 }
13578 {
13579 PyThreadState* __tstate = wxPyBeginAllowThreads();
13580 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13581
13582 wxPyEndAllowThreads(__tstate);
13583 if (PyErr_Occurred()) SWIG_fail;
13584 }
13585 {
13586 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13587 }
13588 return resultobj;
13589 fail:
13590 return NULL;
13591 }
13592
13593
13594 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13595 PyObject *resultobj;
13596 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13597 PyObject * obj0 = 0 ;
13598 char *kwnames[] = {
13599 (char *) "handler", NULL
13600 };
13601
13602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13604 if (SWIG_arg_fail(1)) SWIG_fail;
13605 {
13606 PyThreadState* __tstate = wxPyBeginAllowThreads();
13607 wxImage::AddHandler(arg1);
13608
13609 wxPyEndAllowThreads(__tstate);
13610 if (PyErr_Occurred()) SWIG_fail;
13611 }
13612 Py_INCREF(Py_None); resultobj = Py_None;
13613 return resultobj;
13614 fail:
13615 return NULL;
13616 }
13617
13618
13619 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13620 PyObject *resultobj;
13621 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13622 PyObject * obj0 = 0 ;
13623 char *kwnames[] = {
13624 (char *) "handler", NULL
13625 };
13626
13627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13629 if (SWIG_arg_fail(1)) SWIG_fail;
13630 {
13631 PyThreadState* __tstate = wxPyBeginAllowThreads();
13632 wxImage::InsertHandler(arg1);
13633
13634 wxPyEndAllowThreads(__tstate);
13635 if (PyErr_Occurred()) SWIG_fail;
13636 }
13637 Py_INCREF(Py_None); resultobj = Py_None;
13638 return resultobj;
13639 fail:
13640 return NULL;
13641 }
13642
13643
13644 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13645 PyObject *resultobj;
13646 wxString *arg1 = 0 ;
13647 bool result;
13648 bool temp1 = false ;
13649 PyObject * obj0 = 0 ;
13650 char *kwnames[] = {
13651 (char *) "name", NULL
13652 };
13653
13654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13655 {
13656 arg1 = wxString_in_helper(obj0);
13657 if (arg1 == NULL) SWIG_fail;
13658 temp1 = true;
13659 }
13660 {
13661 PyThreadState* __tstate = wxPyBeginAllowThreads();
13662 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13663
13664 wxPyEndAllowThreads(__tstate);
13665 if (PyErr_Occurred()) SWIG_fail;
13666 }
13667 {
13668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13669 }
13670 {
13671 if (temp1)
13672 delete arg1;
13673 }
13674 return resultobj;
13675 fail:
13676 {
13677 if (temp1)
13678 delete arg1;
13679 }
13680 return NULL;
13681 }
13682
13683
13684 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13685 PyObject *resultobj;
13686 wxString result;
13687 char *kwnames[] = {
13688 NULL
13689 };
13690
13691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13692 {
13693 PyThreadState* __tstate = wxPyBeginAllowThreads();
13694 result = wxImage::GetImageExtWildcard();
13695
13696 wxPyEndAllowThreads(__tstate);
13697 if (PyErr_Occurred()) SWIG_fail;
13698 }
13699 {
13700 #if wxUSE_UNICODE
13701 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13702 #else
13703 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13704 #endif
13705 }
13706 return resultobj;
13707 fail:
13708 return NULL;
13709 }
13710
13711
13712 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13713 PyObject *resultobj;
13714 wxImage *arg1 = (wxImage *) 0 ;
13715 int arg2 = (int) -1 ;
13716 wxBitmap result;
13717 PyObject * obj0 = 0 ;
13718 PyObject * obj1 = 0 ;
13719 char *kwnames[] = {
13720 (char *) "self",(char *) "depth", NULL
13721 };
13722
13723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13725 if (SWIG_arg_fail(1)) SWIG_fail;
13726 if (obj1) {
13727 {
13728 arg2 = (int)(SWIG_As_int(obj1));
13729 if (SWIG_arg_fail(2)) SWIG_fail;
13730 }
13731 }
13732 {
13733 if (!wxPyCheckForApp()) SWIG_fail;
13734 PyThreadState* __tstate = wxPyBeginAllowThreads();
13735 result = wxImage_ConvertToBitmap(arg1,arg2);
13736
13737 wxPyEndAllowThreads(__tstate);
13738 if (PyErr_Occurred()) SWIG_fail;
13739 }
13740 {
13741 wxBitmap * resultptr;
13742 resultptr = new wxBitmap((wxBitmap &)(result));
13743 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13744 }
13745 return resultobj;
13746 fail:
13747 return NULL;
13748 }
13749
13750
13751 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13752 PyObject *resultobj;
13753 wxImage *arg1 = (wxImage *) 0 ;
13754 unsigned char arg2 ;
13755 unsigned char arg3 ;
13756 unsigned char arg4 ;
13757 wxBitmap result;
13758 PyObject * obj0 = 0 ;
13759 PyObject * obj1 = 0 ;
13760 PyObject * obj2 = 0 ;
13761 PyObject * obj3 = 0 ;
13762 char *kwnames[] = {
13763 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13764 };
13765
13766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13768 if (SWIG_arg_fail(1)) SWIG_fail;
13769 {
13770 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13771 if (SWIG_arg_fail(2)) SWIG_fail;
13772 }
13773 {
13774 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13775 if (SWIG_arg_fail(3)) SWIG_fail;
13776 }
13777 {
13778 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13779 if (SWIG_arg_fail(4)) SWIG_fail;
13780 }
13781 {
13782 if (!wxPyCheckForApp()) SWIG_fail;
13783 PyThreadState* __tstate = wxPyBeginAllowThreads();
13784 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13785
13786 wxPyEndAllowThreads(__tstate);
13787 if (PyErr_Occurred()) SWIG_fail;
13788 }
13789 {
13790 wxBitmap * resultptr;
13791 resultptr = new wxBitmap((wxBitmap &)(result));
13792 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13793 }
13794 return resultobj;
13795 fail:
13796 return NULL;
13797 }
13798
13799
13800 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13801 PyObject *obj;
13802 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13803 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13804 Py_INCREF(obj);
13805 return Py_BuildValue((char *)"");
13806 }
13807 static int _wrap_NullImage_set(PyObject *) {
13808 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13809 return 1;
13810 }
13811
13812
13813 static PyObject *_wrap_NullImage_get(void) {
13814 PyObject *pyobj;
13815
13816 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13817 return pyobj;
13818 }
13819
13820
13821 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13822 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13823 return 1;
13824 }
13825
13826
13827 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13828 PyObject *pyobj;
13829
13830 {
13831 #if wxUSE_UNICODE
13832 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13833 #else
13834 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13835 #endif
13836 }
13837 return pyobj;
13838 }
13839
13840
13841 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13842 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13843 return 1;
13844 }
13845
13846
13847 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13848 PyObject *pyobj;
13849
13850 {
13851 #if wxUSE_UNICODE
13852 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13853 #else
13854 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13855 #endif
13856 }
13857 return pyobj;
13858 }
13859
13860
13861 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13862 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13863 return 1;
13864 }
13865
13866
13867 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13868 PyObject *pyobj;
13869
13870 {
13871 #if wxUSE_UNICODE
13872 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13873 #else
13874 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13875 #endif
13876 }
13877 return pyobj;
13878 }
13879
13880
13881 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13882 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13883 return 1;
13884 }
13885
13886
13887 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13888 PyObject *pyobj;
13889
13890 {
13891 #if wxUSE_UNICODE
13892 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13893 #else
13894 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13895 #endif
13896 }
13897 return pyobj;
13898 }
13899
13900
13901 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13902 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13903 return 1;
13904 }
13905
13906
13907 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13908 PyObject *pyobj;
13909
13910 {
13911 #if wxUSE_UNICODE
13912 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13913 #else
13914 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13915 #endif
13916 }
13917 return pyobj;
13918 }
13919
13920
13921 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13922 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13923 return 1;
13924 }
13925
13926
13927 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13928 PyObject *pyobj;
13929
13930 {
13931 #if wxUSE_UNICODE
13932 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13933 #else
13934 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13935 #endif
13936 }
13937 return pyobj;
13938 }
13939
13940
13941 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13942 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13943 return 1;
13944 }
13945
13946
13947 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13948 PyObject *pyobj;
13949
13950 {
13951 #if wxUSE_UNICODE
13952 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13953 #else
13954 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13955 #endif
13956 }
13957 return pyobj;
13958 }
13959
13960
13961 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13962 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13963 return 1;
13964 }
13965
13966
13967 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13968 PyObject *pyobj;
13969
13970 {
13971 #if wxUSE_UNICODE
13972 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13973 #else
13974 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13975 #endif
13976 }
13977 return pyobj;
13978 }
13979
13980
13981 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
13982 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
13983 return 1;
13984 }
13985
13986
13987 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
13988 PyObject *pyobj;
13989
13990 {
13991 #if wxUSE_UNICODE
13992 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13993 #else
13994 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
13995 #endif
13996 }
13997 return pyobj;
13998 }
13999
14000
14001 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14002 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14003 return 1;
14004 }
14005
14006
14007 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14008 PyObject *pyobj;
14009
14010 {
14011 #if wxUSE_UNICODE
14012 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14013 #else
14014 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14015 #endif
14016 }
14017 return pyobj;
14018 }
14019
14020
14021 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14022 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14023 return 1;
14024 }
14025
14026
14027 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14028 PyObject *pyobj;
14029
14030 {
14031 #if wxUSE_UNICODE
14032 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14033 #else
14034 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14035 #endif
14036 }
14037 return pyobj;
14038 }
14039
14040
14041 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14042 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14043 return 1;
14044 }
14045
14046
14047 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14048 PyObject *pyobj;
14049
14050 {
14051 #if wxUSE_UNICODE
14052 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14053 #else
14054 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14055 #endif
14056 }
14057 return pyobj;
14058 }
14059
14060
14061 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14062 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14063 return 1;
14064 }
14065
14066
14067 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14068 PyObject *pyobj;
14069
14070 {
14071 #if wxUSE_UNICODE
14072 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14073 #else
14074 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14075 #endif
14076 }
14077 return pyobj;
14078 }
14079
14080
14081 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14082 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14083 return 1;
14084 }
14085
14086
14087 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14088 PyObject *pyobj;
14089
14090 {
14091 #if wxUSE_UNICODE
14092 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14093 #else
14094 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14095 #endif
14096 }
14097 return pyobj;
14098 }
14099
14100
14101 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14102 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14103 return 1;
14104 }
14105
14106
14107 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14108 PyObject *pyobj;
14109
14110 {
14111 #if wxUSE_UNICODE
14112 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14113 #else
14114 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14115 #endif
14116 }
14117 return pyobj;
14118 }
14119
14120
14121 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14122 PyObject *resultobj;
14123 wxBMPHandler *result;
14124 char *kwnames[] = {
14125 NULL
14126 };
14127
14128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14129 {
14130 PyThreadState* __tstate = wxPyBeginAllowThreads();
14131 result = (wxBMPHandler *)new wxBMPHandler();
14132
14133 wxPyEndAllowThreads(__tstate);
14134 if (PyErr_Occurred()) SWIG_fail;
14135 }
14136 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14137 return resultobj;
14138 fail:
14139 return NULL;
14140 }
14141
14142
14143 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14144 PyObject *obj;
14145 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14146 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14147 Py_INCREF(obj);
14148 return Py_BuildValue((char *)"");
14149 }
14150 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14151 PyObject *resultobj;
14152 wxICOHandler *result;
14153 char *kwnames[] = {
14154 NULL
14155 };
14156
14157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14158 {
14159 PyThreadState* __tstate = wxPyBeginAllowThreads();
14160 result = (wxICOHandler *)new wxICOHandler();
14161
14162 wxPyEndAllowThreads(__tstate);
14163 if (PyErr_Occurred()) SWIG_fail;
14164 }
14165 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14166 return resultobj;
14167 fail:
14168 return NULL;
14169 }
14170
14171
14172 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14173 PyObject *obj;
14174 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14175 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14176 Py_INCREF(obj);
14177 return Py_BuildValue((char *)"");
14178 }
14179 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14180 PyObject *resultobj;
14181 wxCURHandler *result;
14182 char *kwnames[] = {
14183 NULL
14184 };
14185
14186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14187 {
14188 PyThreadState* __tstate = wxPyBeginAllowThreads();
14189 result = (wxCURHandler *)new wxCURHandler();
14190
14191 wxPyEndAllowThreads(__tstate);
14192 if (PyErr_Occurred()) SWIG_fail;
14193 }
14194 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14195 return resultobj;
14196 fail:
14197 return NULL;
14198 }
14199
14200
14201 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14202 PyObject *obj;
14203 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14204 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14205 Py_INCREF(obj);
14206 return Py_BuildValue((char *)"");
14207 }
14208 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14209 PyObject *resultobj;
14210 wxANIHandler *result;
14211 char *kwnames[] = {
14212 NULL
14213 };
14214
14215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14216 {
14217 PyThreadState* __tstate = wxPyBeginAllowThreads();
14218 result = (wxANIHandler *)new wxANIHandler();
14219
14220 wxPyEndAllowThreads(__tstate);
14221 if (PyErr_Occurred()) SWIG_fail;
14222 }
14223 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14224 return resultobj;
14225 fail:
14226 return NULL;
14227 }
14228
14229
14230 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14231 PyObject *obj;
14232 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14233 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14234 Py_INCREF(obj);
14235 return Py_BuildValue((char *)"");
14236 }
14237 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14238 PyObject *resultobj;
14239 wxPNGHandler *result;
14240 char *kwnames[] = {
14241 NULL
14242 };
14243
14244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14245 {
14246 PyThreadState* __tstate = wxPyBeginAllowThreads();
14247 result = (wxPNGHandler *)new wxPNGHandler();
14248
14249 wxPyEndAllowThreads(__tstate);
14250 if (PyErr_Occurred()) SWIG_fail;
14251 }
14252 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14253 return resultobj;
14254 fail:
14255 return NULL;
14256 }
14257
14258
14259 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14260 PyObject *obj;
14261 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14262 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14263 Py_INCREF(obj);
14264 return Py_BuildValue((char *)"");
14265 }
14266 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14267 PyObject *resultobj;
14268 wxGIFHandler *result;
14269 char *kwnames[] = {
14270 NULL
14271 };
14272
14273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14274 {
14275 PyThreadState* __tstate = wxPyBeginAllowThreads();
14276 result = (wxGIFHandler *)new wxGIFHandler();
14277
14278 wxPyEndAllowThreads(__tstate);
14279 if (PyErr_Occurred()) SWIG_fail;
14280 }
14281 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14282 return resultobj;
14283 fail:
14284 return NULL;
14285 }
14286
14287
14288 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14289 PyObject *obj;
14290 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14291 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14292 Py_INCREF(obj);
14293 return Py_BuildValue((char *)"");
14294 }
14295 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14296 PyObject *resultobj;
14297 wxPCXHandler *result;
14298 char *kwnames[] = {
14299 NULL
14300 };
14301
14302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14303 {
14304 PyThreadState* __tstate = wxPyBeginAllowThreads();
14305 result = (wxPCXHandler *)new wxPCXHandler();
14306
14307 wxPyEndAllowThreads(__tstate);
14308 if (PyErr_Occurred()) SWIG_fail;
14309 }
14310 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14311 return resultobj;
14312 fail:
14313 return NULL;
14314 }
14315
14316
14317 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14318 PyObject *obj;
14319 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14320 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14321 Py_INCREF(obj);
14322 return Py_BuildValue((char *)"");
14323 }
14324 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14325 PyObject *resultobj;
14326 wxJPEGHandler *result;
14327 char *kwnames[] = {
14328 NULL
14329 };
14330
14331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14332 {
14333 PyThreadState* __tstate = wxPyBeginAllowThreads();
14334 result = (wxJPEGHandler *)new wxJPEGHandler();
14335
14336 wxPyEndAllowThreads(__tstate);
14337 if (PyErr_Occurred()) SWIG_fail;
14338 }
14339 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14340 return resultobj;
14341 fail:
14342 return NULL;
14343 }
14344
14345
14346 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14347 PyObject *obj;
14348 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14349 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14350 Py_INCREF(obj);
14351 return Py_BuildValue((char *)"");
14352 }
14353 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14354 PyObject *resultobj;
14355 wxPNMHandler *result;
14356 char *kwnames[] = {
14357 NULL
14358 };
14359
14360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14361 {
14362 PyThreadState* __tstate = wxPyBeginAllowThreads();
14363 result = (wxPNMHandler *)new wxPNMHandler();
14364
14365 wxPyEndAllowThreads(__tstate);
14366 if (PyErr_Occurred()) SWIG_fail;
14367 }
14368 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14369 return resultobj;
14370 fail:
14371 return NULL;
14372 }
14373
14374
14375 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
14376 PyObject *obj;
14377 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14378 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14379 Py_INCREF(obj);
14380 return Py_BuildValue((char *)"");
14381 }
14382 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14383 PyObject *resultobj;
14384 wxXPMHandler *result;
14385 char *kwnames[] = {
14386 NULL
14387 };
14388
14389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
14390 {
14391 PyThreadState* __tstate = wxPyBeginAllowThreads();
14392 result = (wxXPMHandler *)new wxXPMHandler();
14393
14394 wxPyEndAllowThreads(__tstate);
14395 if (PyErr_Occurred()) SWIG_fail;
14396 }
14397 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
14398 return resultobj;
14399 fail:
14400 return NULL;
14401 }
14402
14403
14404 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
14405 PyObject *obj;
14406 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14407 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
14408 Py_INCREF(obj);
14409 return Py_BuildValue((char *)"");
14410 }
14411 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14412 PyObject *resultobj;
14413 wxTIFFHandler *result;
14414 char *kwnames[] = {
14415 NULL
14416 };
14417
14418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14419 {
14420 PyThreadState* __tstate = wxPyBeginAllowThreads();
14421 result = (wxTIFFHandler *)new wxTIFFHandler();
14422
14423 wxPyEndAllowThreads(__tstate);
14424 if (PyErr_Occurred()) SWIG_fail;
14425 }
14426 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14427 return resultobj;
14428 fail:
14429 return NULL;
14430 }
14431
14432
14433 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14434 PyObject *obj;
14435 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14436 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14437 Py_INCREF(obj);
14438 return Py_BuildValue((char *)"");
14439 }
14440 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14441 PyObject *resultobj;
14442 wxImage *arg1 = 0 ;
14443 wxImage *arg2 = 0 ;
14444 int arg3 = (int) 236 ;
14445 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14446 bool result;
14447 PyObject * obj0 = 0 ;
14448 PyObject * obj1 = 0 ;
14449 PyObject * obj2 = 0 ;
14450 PyObject * obj3 = 0 ;
14451 char *kwnames[] = {
14452 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14453 };
14454
14455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14456 {
14457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14458 if (SWIG_arg_fail(1)) SWIG_fail;
14459 if (arg1 == NULL) {
14460 SWIG_null_ref("wxImage");
14461 }
14462 if (SWIG_arg_fail(1)) SWIG_fail;
14463 }
14464 {
14465 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14466 if (SWIG_arg_fail(2)) SWIG_fail;
14467 if (arg2 == NULL) {
14468 SWIG_null_ref("wxImage");
14469 }
14470 if (SWIG_arg_fail(2)) SWIG_fail;
14471 }
14472 if (obj2) {
14473 {
14474 arg3 = (int)(SWIG_As_int(obj2));
14475 if (SWIG_arg_fail(3)) SWIG_fail;
14476 }
14477 }
14478 if (obj3) {
14479 {
14480 arg4 = (int)(SWIG_As_int(obj3));
14481 if (SWIG_arg_fail(4)) SWIG_fail;
14482 }
14483 }
14484 {
14485 PyThreadState* __tstate = wxPyBeginAllowThreads();
14486 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14487
14488 wxPyEndAllowThreads(__tstate);
14489 if (PyErr_Occurred()) SWIG_fail;
14490 }
14491 {
14492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14493 }
14494 return resultobj;
14495 fail:
14496 return NULL;
14497 }
14498
14499
14500 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14501 PyObject *obj;
14502 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14503 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14504 Py_INCREF(obj);
14505 return Py_BuildValue((char *)"");
14506 }
14507 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14508 PyObject *resultobj;
14509 wxEvtHandler *result;
14510 char *kwnames[] = {
14511 NULL
14512 };
14513
14514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14515 {
14516 PyThreadState* __tstate = wxPyBeginAllowThreads();
14517 result = (wxEvtHandler *)new wxEvtHandler();
14518
14519 wxPyEndAllowThreads(__tstate);
14520 if (PyErr_Occurred()) SWIG_fail;
14521 }
14522 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14523 return resultobj;
14524 fail:
14525 return NULL;
14526 }
14527
14528
14529 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14530 PyObject *resultobj;
14531 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14532 wxEvtHandler *result;
14533 PyObject * obj0 = 0 ;
14534 char *kwnames[] = {
14535 (char *) "self", NULL
14536 };
14537
14538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14540 if (SWIG_arg_fail(1)) SWIG_fail;
14541 {
14542 PyThreadState* __tstate = wxPyBeginAllowThreads();
14543 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14544
14545 wxPyEndAllowThreads(__tstate);
14546 if (PyErr_Occurred()) SWIG_fail;
14547 }
14548 {
14549 resultobj = wxPyMake_wxObject(result, 0);
14550 }
14551 return resultobj;
14552 fail:
14553 return NULL;
14554 }
14555
14556
14557 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14558 PyObject *resultobj;
14559 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14560 wxEvtHandler *result;
14561 PyObject * obj0 = 0 ;
14562 char *kwnames[] = {
14563 (char *) "self", NULL
14564 };
14565
14566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14568 if (SWIG_arg_fail(1)) SWIG_fail;
14569 {
14570 PyThreadState* __tstate = wxPyBeginAllowThreads();
14571 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14572
14573 wxPyEndAllowThreads(__tstate);
14574 if (PyErr_Occurred()) SWIG_fail;
14575 }
14576 {
14577 resultobj = wxPyMake_wxObject(result, 0);
14578 }
14579 return resultobj;
14580 fail:
14581 return NULL;
14582 }
14583
14584
14585 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14586 PyObject *resultobj;
14587 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14588 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14589 PyObject * obj0 = 0 ;
14590 PyObject * obj1 = 0 ;
14591 char *kwnames[] = {
14592 (char *) "self",(char *) "handler", NULL
14593 };
14594
14595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14597 if (SWIG_arg_fail(1)) SWIG_fail;
14598 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14599 if (SWIG_arg_fail(2)) SWIG_fail;
14600 {
14601 PyThreadState* __tstate = wxPyBeginAllowThreads();
14602 (arg1)->SetNextHandler(arg2);
14603
14604 wxPyEndAllowThreads(__tstate);
14605 if (PyErr_Occurred()) SWIG_fail;
14606 }
14607 Py_INCREF(Py_None); resultobj = Py_None;
14608 return resultobj;
14609 fail:
14610 return NULL;
14611 }
14612
14613
14614 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14615 PyObject *resultobj;
14616 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14617 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14618 PyObject * obj0 = 0 ;
14619 PyObject * obj1 = 0 ;
14620 char *kwnames[] = {
14621 (char *) "self",(char *) "handler", NULL
14622 };
14623
14624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14626 if (SWIG_arg_fail(1)) SWIG_fail;
14627 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14628 if (SWIG_arg_fail(2)) SWIG_fail;
14629 {
14630 PyThreadState* __tstate = wxPyBeginAllowThreads();
14631 (arg1)->SetPreviousHandler(arg2);
14632
14633 wxPyEndAllowThreads(__tstate);
14634 if (PyErr_Occurred()) SWIG_fail;
14635 }
14636 Py_INCREF(Py_None); resultobj = Py_None;
14637 return resultobj;
14638 fail:
14639 return NULL;
14640 }
14641
14642
14643 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14644 PyObject *resultobj;
14645 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14646 bool result;
14647 PyObject * obj0 = 0 ;
14648 char *kwnames[] = {
14649 (char *) "self", NULL
14650 };
14651
14652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14654 if (SWIG_arg_fail(1)) SWIG_fail;
14655 {
14656 PyThreadState* __tstate = wxPyBeginAllowThreads();
14657 result = (bool)(arg1)->GetEvtHandlerEnabled();
14658
14659 wxPyEndAllowThreads(__tstate);
14660 if (PyErr_Occurred()) SWIG_fail;
14661 }
14662 {
14663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14664 }
14665 return resultobj;
14666 fail:
14667 return NULL;
14668 }
14669
14670
14671 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14672 PyObject *resultobj;
14673 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14674 bool arg2 ;
14675 PyObject * obj0 = 0 ;
14676 PyObject * obj1 = 0 ;
14677 char *kwnames[] = {
14678 (char *) "self",(char *) "enabled", NULL
14679 };
14680
14681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14683 if (SWIG_arg_fail(1)) SWIG_fail;
14684 {
14685 arg2 = (bool)(SWIG_As_bool(obj1));
14686 if (SWIG_arg_fail(2)) SWIG_fail;
14687 }
14688 {
14689 PyThreadState* __tstate = wxPyBeginAllowThreads();
14690 (arg1)->SetEvtHandlerEnabled(arg2);
14691
14692 wxPyEndAllowThreads(__tstate);
14693 if (PyErr_Occurred()) SWIG_fail;
14694 }
14695 Py_INCREF(Py_None); resultobj = Py_None;
14696 return resultobj;
14697 fail:
14698 return NULL;
14699 }
14700
14701
14702 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14703 PyObject *resultobj;
14704 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14705 wxEvent *arg2 = 0 ;
14706 bool result;
14707 PyObject * obj0 = 0 ;
14708 PyObject * obj1 = 0 ;
14709 char *kwnames[] = {
14710 (char *) "self",(char *) "event", NULL
14711 };
14712
14713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14715 if (SWIG_arg_fail(1)) SWIG_fail;
14716 {
14717 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14718 if (SWIG_arg_fail(2)) SWIG_fail;
14719 if (arg2 == NULL) {
14720 SWIG_null_ref("wxEvent");
14721 }
14722 if (SWIG_arg_fail(2)) SWIG_fail;
14723 }
14724 {
14725 PyThreadState* __tstate = wxPyBeginAllowThreads();
14726 result = (bool)(arg1)->ProcessEvent(*arg2);
14727
14728 wxPyEndAllowThreads(__tstate);
14729 if (PyErr_Occurred()) SWIG_fail;
14730 }
14731 {
14732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14733 }
14734 return resultobj;
14735 fail:
14736 return NULL;
14737 }
14738
14739
14740 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14741 PyObject *resultobj;
14742 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14743 wxEvent *arg2 = 0 ;
14744 PyObject * obj0 = 0 ;
14745 PyObject * obj1 = 0 ;
14746 char *kwnames[] = {
14747 (char *) "self",(char *) "event", NULL
14748 };
14749
14750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14752 if (SWIG_arg_fail(1)) SWIG_fail;
14753 {
14754 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14755 if (SWIG_arg_fail(2)) SWIG_fail;
14756 if (arg2 == NULL) {
14757 SWIG_null_ref("wxEvent");
14758 }
14759 if (SWIG_arg_fail(2)) SWIG_fail;
14760 }
14761 {
14762 PyThreadState* __tstate = wxPyBeginAllowThreads();
14763 (arg1)->AddPendingEvent(*arg2);
14764
14765 wxPyEndAllowThreads(__tstate);
14766 if (PyErr_Occurred()) SWIG_fail;
14767 }
14768 Py_INCREF(Py_None); resultobj = Py_None;
14769 return resultobj;
14770 fail:
14771 return NULL;
14772 }
14773
14774
14775 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14776 PyObject *resultobj;
14777 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14778 PyObject * obj0 = 0 ;
14779 char *kwnames[] = {
14780 (char *) "self", NULL
14781 };
14782
14783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14785 if (SWIG_arg_fail(1)) SWIG_fail;
14786 {
14787 PyThreadState* __tstate = wxPyBeginAllowThreads();
14788 (arg1)->ProcessPendingEvents();
14789
14790 wxPyEndAllowThreads(__tstate);
14791 if (PyErr_Occurred()) SWIG_fail;
14792 }
14793 Py_INCREF(Py_None); resultobj = Py_None;
14794 return resultobj;
14795 fail:
14796 return NULL;
14797 }
14798
14799
14800 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14801 PyObject *resultobj;
14802 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14803 int arg2 ;
14804 int arg3 ;
14805 int arg4 ;
14806 PyObject *arg5 = (PyObject *) 0 ;
14807 PyObject * obj0 = 0 ;
14808 PyObject * obj1 = 0 ;
14809 PyObject * obj2 = 0 ;
14810 PyObject * obj3 = 0 ;
14811 PyObject * obj4 = 0 ;
14812 char *kwnames[] = {
14813 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14814 };
14815
14816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14818 if (SWIG_arg_fail(1)) SWIG_fail;
14819 {
14820 arg2 = (int)(SWIG_As_int(obj1));
14821 if (SWIG_arg_fail(2)) SWIG_fail;
14822 }
14823 {
14824 arg3 = (int)(SWIG_As_int(obj2));
14825 if (SWIG_arg_fail(3)) SWIG_fail;
14826 }
14827 {
14828 arg4 = (int)(SWIG_As_int(obj3));
14829 if (SWIG_arg_fail(4)) SWIG_fail;
14830 }
14831 arg5 = obj4;
14832 {
14833 PyThreadState* __tstate = wxPyBeginAllowThreads();
14834 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14835
14836 wxPyEndAllowThreads(__tstate);
14837 if (PyErr_Occurred()) SWIG_fail;
14838 }
14839 Py_INCREF(Py_None); resultobj = Py_None;
14840 return resultobj;
14841 fail:
14842 return NULL;
14843 }
14844
14845
14846 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14847 PyObject *resultobj;
14848 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14849 int arg2 ;
14850 int arg3 = (int) -1 ;
14851 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14852 bool result;
14853 PyObject * obj0 = 0 ;
14854 PyObject * obj1 = 0 ;
14855 PyObject * obj2 = 0 ;
14856 PyObject * obj3 = 0 ;
14857 char *kwnames[] = {
14858 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14859 };
14860
14861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14863 if (SWIG_arg_fail(1)) SWIG_fail;
14864 {
14865 arg2 = (int)(SWIG_As_int(obj1));
14866 if (SWIG_arg_fail(2)) SWIG_fail;
14867 }
14868 if (obj2) {
14869 {
14870 arg3 = (int)(SWIG_As_int(obj2));
14871 if (SWIG_arg_fail(3)) SWIG_fail;
14872 }
14873 }
14874 if (obj3) {
14875 {
14876 arg4 = (wxEventType)(SWIG_As_int(obj3));
14877 if (SWIG_arg_fail(4)) SWIG_fail;
14878 }
14879 }
14880 {
14881 PyThreadState* __tstate = wxPyBeginAllowThreads();
14882 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14883
14884 wxPyEndAllowThreads(__tstate);
14885 if (PyErr_Occurred()) SWIG_fail;
14886 }
14887 {
14888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14889 }
14890 return resultobj;
14891 fail:
14892 return NULL;
14893 }
14894
14895
14896 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14897 PyObject *resultobj;
14898 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14899 PyObject *arg2 = (PyObject *) 0 ;
14900 bool arg3 = (bool) true ;
14901 PyObject * obj0 = 0 ;
14902 PyObject * obj1 = 0 ;
14903 PyObject * obj2 = 0 ;
14904 char *kwnames[] = {
14905 (char *) "self",(char *) "_self",(char *) "incref", NULL
14906 };
14907
14908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14910 if (SWIG_arg_fail(1)) SWIG_fail;
14911 arg2 = obj1;
14912 if (obj2) {
14913 {
14914 arg3 = (bool)(SWIG_As_bool(obj2));
14915 if (SWIG_arg_fail(3)) SWIG_fail;
14916 }
14917 }
14918 {
14919 PyThreadState* __tstate = wxPyBeginAllowThreads();
14920 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14921
14922 wxPyEndAllowThreads(__tstate);
14923 if (PyErr_Occurred()) SWIG_fail;
14924 }
14925 Py_INCREF(Py_None); resultobj = Py_None;
14926 return resultobj;
14927 fail:
14928 return NULL;
14929 }
14930
14931
14932 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14933 PyObject *obj;
14934 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14935 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14936 Py_INCREF(obj);
14937 return Py_BuildValue((char *)"");
14938 }
14939 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14940 PyObject *resultobj;
14941 wxEventType result;
14942 char *kwnames[] = {
14943 NULL
14944 };
14945
14946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14947 {
14948 PyThreadState* __tstate = wxPyBeginAllowThreads();
14949 result = (wxEventType)wxNewEventType();
14950
14951 wxPyEndAllowThreads(__tstate);
14952 if (PyErr_Occurred()) SWIG_fail;
14953 }
14954 {
14955 resultobj = SWIG_From_int((int)(result));
14956 }
14957 return resultobj;
14958 fail:
14959 return NULL;
14960 }
14961
14962
14963 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14964 PyObject *resultobj;
14965 wxEvent *arg1 = (wxEvent *) 0 ;
14966 PyObject * obj0 = 0 ;
14967 char *kwnames[] = {
14968 (char *) "self", NULL
14969 };
14970
14971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14973 if (SWIG_arg_fail(1)) SWIG_fail;
14974 {
14975 PyThreadState* __tstate = wxPyBeginAllowThreads();
14976 delete arg1;
14977
14978 wxPyEndAllowThreads(__tstate);
14979 if (PyErr_Occurred()) SWIG_fail;
14980 }
14981 Py_INCREF(Py_None); resultobj = Py_None;
14982 return resultobj;
14983 fail:
14984 return NULL;
14985 }
14986
14987
14988 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14989 PyObject *resultobj;
14990 wxEvent *arg1 = (wxEvent *) 0 ;
14991 wxEventType arg2 ;
14992 PyObject * obj0 = 0 ;
14993 PyObject * obj1 = 0 ;
14994 char *kwnames[] = {
14995 (char *) "self",(char *) "typ", NULL
14996 };
14997
14998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15000 if (SWIG_arg_fail(1)) SWIG_fail;
15001 {
15002 arg2 = (wxEventType)(SWIG_As_int(obj1));
15003 if (SWIG_arg_fail(2)) SWIG_fail;
15004 }
15005 {
15006 PyThreadState* __tstate = wxPyBeginAllowThreads();
15007 (arg1)->SetEventType(arg2);
15008
15009 wxPyEndAllowThreads(__tstate);
15010 if (PyErr_Occurred()) SWIG_fail;
15011 }
15012 Py_INCREF(Py_None); resultobj = Py_None;
15013 return resultobj;
15014 fail:
15015 return NULL;
15016 }
15017
15018
15019 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15020 PyObject *resultobj;
15021 wxEvent *arg1 = (wxEvent *) 0 ;
15022 wxEventType result;
15023 PyObject * obj0 = 0 ;
15024 char *kwnames[] = {
15025 (char *) "self", NULL
15026 };
15027
15028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15030 if (SWIG_arg_fail(1)) SWIG_fail;
15031 {
15032 PyThreadState* __tstate = wxPyBeginAllowThreads();
15033 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15034
15035 wxPyEndAllowThreads(__tstate);
15036 if (PyErr_Occurred()) SWIG_fail;
15037 }
15038 {
15039 resultobj = SWIG_From_int((int)(result));
15040 }
15041 return resultobj;
15042 fail:
15043 return NULL;
15044 }
15045
15046
15047 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15048 PyObject *resultobj;
15049 wxEvent *arg1 = (wxEvent *) 0 ;
15050 wxObject *result;
15051 PyObject * obj0 = 0 ;
15052 char *kwnames[] = {
15053 (char *) "self", NULL
15054 };
15055
15056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15058 if (SWIG_arg_fail(1)) SWIG_fail;
15059 {
15060 PyThreadState* __tstate = wxPyBeginAllowThreads();
15061 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15062
15063 wxPyEndAllowThreads(__tstate);
15064 if (PyErr_Occurred()) SWIG_fail;
15065 }
15066 {
15067 resultobj = wxPyMake_wxObject(result, 0);
15068 }
15069 return resultobj;
15070 fail:
15071 return NULL;
15072 }
15073
15074
15075 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15076 PyObject *resultobj;
15077 wxEvent *arg1 = (wxEvent *) 0 ;
15078 wxObject *arg2 = (wxObject *) 0 ;
15079 PyObject * obj0 = 0 ;
15080 PyObject * obj1 = 0 ;
15081 char *kwnames[] = {
15082 (char *) "self",(char *) "obj", NULL
15083 };
15084
15085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15087 if (SWIG_arg_fail(1)) SWIG_fail;
15088 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15089 if (SWIG_arg_fail(2)) SWIG_fail;
15090 {
15091 PyThreadState* __tstate = wxPyBeginAllowThreads();
15092 (arg1)->SetEventObject(arg2);
15093
15094 wxPyEndAllowThreads(__tstate);
15095 if (PyErr_Occurred()) SWIG_fail;
15096 }
15097 Py_INCREF(Py_None); resultobj = Py_None;
15098 return resultobj;
15099 fail:
15100 return NULL;
15101 }
15102
15103
15104 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15105 PyObject *resultobj;
15106 wxEvent *arg1 = (wxEvent *) 0 ;
15107 long result;
15108 PyObject * obj0 = 0 ;
15109 char *kwnames[] = {
15110 (char *) "self", NULL
15111 };
15112
15113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15115 if (SWIG_arg_fail(1)) SWIG_fail;
15116 {
15117 PyThreadState* __tstate = wxPyBeginAllowThreads();
15118 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15119
15120 wxPyEndAllowThreads(__tstate);
15121 if (PyErr_Occurred()) SWIG_fail;
15122 }
15123 {
15124 resultobj = SWIG_From_long((long)(result));
15125 }
15126 return resultobj;
15127 fail:
15128 return NULL;
15129 }
15130
15131
15132 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15133 PyObject *resultobj;
15134 wxEvent *arg1 = (wxEvent *) 0 ;
15135 long arg2 = (long) 0 ;
15136 PyObject * obj0 = 0 ;
15137 PyObject * obj1 = 0 ;
15138 char *kwnames[] = {
15139 (char *) "self",(char *) "ts", NULL
15140 };
15141
15142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15144 if (SWIG_arg_fail(1)) SWIG_fail;
15145 if (obj1) {
15146 {
15147 arg2 = (long)(SWIG_As_long(obj1));
15148 if (SWIG_arg_fail(2)) SWIG_fail;
15149 }
15150 }
15151 {
15152 PyThreadState* __tstate = wxPyBeginAllowThreads();
15153 (arg1)->SetTimestamp(arg2);
15154
15155 wxPyEndAllowThreads(__tstate);
15156 if (PyErr_Occurred()) SWIG_fail;
15157 }
15158 Py_INCREF(Py_None); resultobj = Py_None;
15159 return resultobj;
15160 fail:
15161 return NULL;
15162 }
15163
15164
15165 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15166 PyObject *resultobj;
15167 wxEvent *arg1 = (wxEvent *) 0 ;
15168 int result;
15169 PyObject * obj0 = 0 ;
15170 char *kwnames[] = {
15171 (char *) "self", NULL
15172 };
15173
15174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15176 if (SWIG_arg_fail(1)) SWIG_fail;
15177 {
15178 PyThreadState* __tstate = wxPyBeginAllowThreads();
15179 result = (int)((wxEvent const *)arg1)->GetId();
15180
15181 wxPyEndAllowThreads(__tstate);
15182 if (PyErr_Occurred()) SWIG_fail;
15183 }
15184 {
15185 resultobj = SWIG_From_int((int)(result));
15186 }
15187 return resultobj;
15188 fail:
15189 return NULL;
15190 }
15191
15192
15193 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15194 PyObject *resultobj;
15195 wxEvent *arg1 = (wxEvent *) 0 ;
15196 int arg2 ;
15197 PyObject * obj0 = 0 ;
15198 PyObject * obj1 = 0 ;
15199 char *kwnames[] = {
15200 (char *) "self",(char *) "Id", NULL
15201 };
15202
15203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15205 if (SWIG_arg_fail(1)) SWIG_fail;
15206 {
15207 arg2 = (int)(SWIG_As_int(obj1));
15208 if (SWIG_arg_fail(2)) SWIG_fail;
15209 }
15210 {
15211 PyThreadState* __tstate = wxPyBeginAllowThreads();
15212 (arg1)->SetId(arg2);
15213
15214 wxPyEndAllowThreads(__tstate);
15215 if (PyErr_Occurred()) SWIG_fail;
15216 }
15217 Py_INCREF(Py_None); resultobj = Py_None;
15218 return resultobj;
15219 fail:
15220 return NULL;
15221 }
15222
15223
15224 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15225 PyObject *resultobj;
15226 wxEvent *arg1 = (wxEvent *) 0 ;
15227 bool result;
15228 PyObject * obj0 = 0 ;
15229 char *kwnames[] = {
15230 (char *) "self", NULL
15231 };
15232
15233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15235 if (SWIG_arg_fail(1)) SWIG_fail;
15236 {
15237 PyThreadState* __tstate = wxPyBeginAllowThreads();
15238 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15239
15240 wxPyEndAllowThreads(__tstate);
15241 if (PyErr_Occurred()) SWIG_fail;
15242 }
15243 {
15244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15245 }
15246 return resultobj;
15247 fail:
15248 return NULL;
15249 }
15250
15251
15252 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15253 PyObject *resultobj;
15254 wxEvent *arg1 = (wxEvent *) 0 ;
15255 bool arg2 = (bool) true ;
15256 PyObject * obj0 = 0 ;
15257 PyObject * obj1 = 0 ;
15258 char *kwnames[] = {
15259 (char *) "self",(char *) "skip", NULL
15260 };
15261
15262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15264 if (SWIG_arg_fail(1)) SWIG_fail;
15265 if (obj1) {
15266 {
15267 arg2 = (bool)(SWIG_As_bool(obj1));
15268 if (SWIG_arg_fail(2)) SWIG_fail;
15269 }
15270 }
15271 {
15272 PyThreadState* __tstate = wxPyBeginAllowThreads();
15273 (arg1)->Skip(arg2);
15274
15275 wxPyEndAllowThreads(__tstate);
15276 if (PyErr_Occurred()) SWIG_fail;
15277 }
15278 Py_INCREF(Py_None); resultobj = Py_None;
15279 return resultobj;
15280 fail:
15281 return NULL;
15282 }
15283
15284
15285 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15286 PyObject *resultobj;
15287 wxEvent *arg1 = (wxEvent *) 0 ;
15288 bool result;
15289 PyObject * obj0 = 0 ;
15290 char *kwnames[] = {
15291 (char *) "self", NULL
15292 };
15293
15294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15296 if (SWIG_arg_fail(1)) SWIG_fail;
15297 {
15298 PyThreadState* __tstate = wxPyBeginAllowThreads();
15299 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15300
15301 wxPyEndAllowThreads(__tstate);
15302 if (PyErr_Occurred()) SWIG_fail;
15303 }
15304 {
15305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15306 }
15307 return resultobj;
15308 fail:
15309 return NULL;
15310 }
15311
15312
15313 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15314 PyObject *resultobj;
15315 wxEvent *arg1 = (wxEvent *) 0 ;
15316 bool result;
15317 PyObject * obj0 = 0 ;
15318 char *kwnames[] = {
15319 (char *) "self", NULL
15320 };
15321
15322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15324 if (SWIG_arg_fail(1)) SWIG_fail;
15325 {
15326 PyThreadState* __tstate = wxPyBeginAllowThreads();
15327 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15328
15329 wxPyEndAllowThreads(__tstate);
15330 if (PyErr_Occurred()) SWIG_fail;
15331 }
15332 {
15333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15334 }
15335 return resultobj;
15336 fail:
15337 return NULL;
15338 }
15339
15340
15341 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15342 PyObject *resultobj;
15343 wxEvent *arg1 = (wxEvent *) 0 ;
15344 int result;
15345 PyObject * obj0 = 0 ;
15346 char *kwnames[] = {
15347 (char *) "self", NULL
15348 };
15349
15350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15352 if (SWIG_arg_fail(1)) SWIG_fail;
15353 {
15354 PyThreadState* __tstate = wxPyBeginAllowThreads();
15355 result = (int)(arg1)->StopPropagation();
15356
15357 wxPyEndAllowThreads(__tstate);
15358 if (PyErr_Occurred()) SWIG_fail;
15359 }
15360 {
15361 resultobj = SWIG_From_int((int)(result));
15362 }
15363 return resultobj;
15364 fail:
15365 return NULL;
15366 }
15367
15368
15369 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15370 PyObject *resultobj;
15371 wxEvent *arg1 = (wxEvent *) 0 ;
15372 int arg2 ;
15373 PyObject * obj0 = 0 ;
15374 PyObject * obj1 = 0 ;
15375 char *kwnames[] = {
15376 (char *) "self",(char *) "propagationLevel", NULL
15377 };
15378
15379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15381 if (SWIG_arg_fail(1)) SWIG_fail;
15382 {
15383 arg2 = (int)(SWIG_As_int(obj1));
15384 if (SWIG_arg_fail(2)) SWIG_fail;
15385 }
15386 {
15387 PyThreadState* __tstate = wxPyBeginAllowThreads();
15388 (arg1)->ResumePropagation(arg2);
15389
15390 wxPyEndAllowThreads(__tstate);
15391 if (PyErr_Occurred()) SWIG_fail;
15392 }
15393 Py_INCREF(Py_None); resultobj = Py_None;
15394 return resultobj;
15395 fail:
15396 return NULL;
15397 }
15398
15399
15400 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15401 PyObject *resultobj;
15402 wxEvent *arg1 = (wxEvent *) 0 ;
15403 wxEvent *result;
15404 PyObject * obj0 = 0 ;
15405 char *kwnames[] = {
15406 (char *) "self", NULL
15407 };
15408
15409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
15410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15411 if (SWIG_arg_fail(1)) SWIG_fail;
15412 {
15413 PyThreadState* __tstate = wxPyBeginAllowThreads();
15414 result = (wxEvent *)(arg1)->Clone();
15415
15416 wxPyEndAllowThreads(__tstate);
15417 if (PyErr_Occurred()) SWIG_fail;
15418 }
15419 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15420 return resultobj;
15421 fail:
15422 return NULL;
15423 }
15424
15425
15426 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
15427 PyObject *obj;
15428 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15429 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15430 Py_INCREF(obj);
15431 return Py_BuildValue((char *)"");
15432 }
15433 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15434 PyObject *resultobj;
15435 wxEvent *arg1 = 0 ;
15436 wxPropagationDisabler *result;
15437 PyObject * obj0 = 0 ;
15438 char *kwnames[] = {
15439 (char *) "event", NULL
15440 };
15441
15442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15443 {
15444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15445 if (SWIG_arg_fail(1)) SWIG_fail;
15446 if (arg1 == NULL) {
15447 SWIG_null_ref("wxEvent");
15448 }
15449 if (SWIG_arg_fail(1)) SWIG_fail;
15450 }
15451 {
15452 PyThreadState* __tstate = wxPyBeginAllowThreads();
15453 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15454
15455 wxPyEndAllowThreads(__tstate);
15456 if (PyErr_Occurred()) SWIG_fail;
15457 }
15458 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15459 return resultobj;
15460 fail:
15461 return NULL;
15462 }
15463
15464
15465 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15466 PyObject *resultobj;
15467 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15468 PyObject * obj0 = 0 ;
15469 char *kwnames[] = {
15470 (char *) "self", NULL
15471 };
15472
15473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15475 if (SWIG_arg_fail(1)) SWIG_fail;
15476 {
15477 PyThreadState* __tstate = wxPyBeginAllowThreads();
15478 delete arg1;
15479
15480 wxPyEndAllowThreads(__tstate);
15481 if (PyErr_Occurred()) SWIG_fail;
15482 }
15483 Py_INCREF(Py_None); resultobj = Py_None;
15484 return resultobj;
15485 fail:
15486 return NULL;
15487 }
15488
15489
15490 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15491 PyObject *obj;
15492 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15493 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15494 Py_INCREF(obj);
15495 return Py_BuildValue((char *)"");
15496 }
15497 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15498 PyObject *resultobj;
15499 wxEvent *arg1 = 0 ;
15500 wxPropagateOnce *result;
15501 PyObject * obj0 = 0 ;
15502 char *kwnames[] = {
15503 (char *) "event", NULL
15504 };
15505
15506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15507 {
15508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15509 if (SWIG_arg_fail(1)) SWIG_fail;
15510 if (arg1 == NULL) {
15511 SWIG_null_ref("wxEvent");
15512 }
15513 if (SWIG_arg_fail(1)) SWIG_fail;
15514 }
15515 {
15516 PyThreadState* __tstate = wxPyBeginAllowThreads();
15517 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15518
15519 wxPyEndAllowThreads(__tstate);
15520 if (PyErr_Occurred()) SWIG_fail;
15521 }
15522 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15523 return resultobj;
15524 fail:
15525 return NULL;
15526 }
15527
15528
15529 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15530 PyObject *resultobj;
15531 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15532 PyObject * obj0 = 0 ;
15533 char *kwnames[] = {
15534 (char *) "self", NULL
15535 };
15536
15537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15539 if (SWIG_arg_fail(1)) SWIG_fail;
15540 {
15541 PyThreadState* __tstate = wxPyBeginAllowThreads();
15542 delete arg1;
15543
15544 wxPyEndAllowThreads(__tstate);
15545 if (PyErr_Occurred()) SWIG_fail;
15546 }
15547 Py_INCREF(Py_None); resultobj = Py_None;
15548 return resultobj;
15549 fail:
15550 return NULL;
15551 }
15552
15553
15554 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15555 PyObject *obj;
15556 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15557 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15558 Py_INCREF(obj);
15559 return Py_BuildValue((char *)"");
15560 }
15561 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15562 PyObject *resultobj;
15563 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15564 int arg2 = (int) 0 ;
15565 wxCommandEvent *result;
15566 PyObject * obj0 = 0 ;
15567 PyObject * obj1 = 0 ;
15568 char *kwnames[] = {
15569 (char *) "commandType",(char *) "winid", NULL
15570 };
15571
15572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15573 if (obj0) {
15574 {
15575 arg1 = (wxEventType)(SWIG_As_int(obj0));
15576 if (SWIG_arg_fail(1)) SWIG_fail;
15577 }
15578 }
15579 if (obj1) {
15580 {
15581 arg2 = (int)(SWIG_As_int(obj1));
15582 if (SWIG_arg_fail(2)) SWIG_fail;
15583 }
15584 }
15585 {
15586 PyThreadState* __tstate = wxPyBeginAllowThreads();
15587 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15588
15589 wxPyEndAllowThreads(__tstate);
15590 if (PyErr_Occurred()) SWIG_fail;
15591 }
15592 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15593 return resultobj;
15594 fail:
15595 return NULL;
15596 }
15597
15598
15599 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15600 PyObject *resultobj;
15601 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15602 int result;
15603 PyObject * obj0 = 0 ;
15604 char *kwnames[] = {
15605 (char *) "self", NULL
15606 };
15607
15608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15610 if (SWIG_arg_fail(1)) SWIG_fail;
15611 {
15612 PyThreadState* __tstate = wxPyBeginAllowThreads();
15613 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15614
15615 wxPyEndAllowThreads(__tstate);
15616 if (PyErr_Occurred()) SWIG_fail;
15617 }
15618 {
15619 resultobj = SWIG_From_int((int)(result));
15620 }
15621 return resultobj;
15622 fail:
15623 return NULL;
15624 }
15625
15626
15627 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15628 PyObject *resultobj;
15629 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15630 wxString *arg2 = 0 ;
15631 bool temp2 = false ;
15632 PyObject * obj0 = 0 ;
15633 PyObject * obj1 = 0 ;
15634 char *kwnames[] = {
15635 (char *) "self",(char *) "s", NULL
15636 };
15637
15638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15640 if (SWIG_arg_fail(1)) SWIG_fail;
15641 {
15642 arg2 = wxString_in_helper(obj1);
15643 if (arg2 == NULL) SWIG_fail;
15644 temp2 = true;
15645 }
15646 {
15647 PyThreadState* __tstate = wxPyBeginAllowThreads();
15648 (arg1)->SetString((wxString const &)*arg2);
15649
15650 wxPyEndAllowThreads(__tstate);
15651 if (PyErr_Occurred()) SWIG_fail;
15652 }
15653 Py_INCREF(Py_None); resultobj = Py_None;
15654 {
15655 if (temp2)
15656 delete arg2;
15657 }
15658 return resultobj;
15659 fail:
15660 {
15661 if (temp2)
15662 delete arg2;
15663 }
15664 return NULL;
15665 }
15666
15667
15668 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15669 PyObject *resultobj;
15670 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15671 wxString result;
15672 PyObject * obj0 = 0 ;
15673 char *kwnames[] = {
15674 (char *) "self", NULL
15675 };
15676
15677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15679 if (SWIG_arg_fail(1)) SWIG_fail;
15680 {
15681 PyThreadState* __tstate = wxPyBeginAllowThreads();
15682 result = ((wxCommandEvent const *)arg1)->GetString();
15683
15684 wxPyEndAllowThreads(__tstate);
15685 if (PyErr_Occurred()) SWIG_fail;
15686 }
15687 {
15688 #if wxUSE_UNICODE
15689 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15690 #else
15691 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15692 #endif
15693 }
15694 return resultobj;
15695 fail:
15696 return NULL;
15697 }
15698
15699
15700 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15701 PyObject *resultobj;
15702 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15703 bool result;
15704 PyObject * obj0 = 0 ;
15705 char *kwnames[] = {
15706 (char *) "self", NULL
15707 };
15708
15709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15711 if (SWIG_arg_fail(1)) SWIG_fail;
15712 {
15713 PyThreadState* __tstate = wxPyBeginAllowThreads();
15714 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15715
15716 wxPyEndAllowThreads(__tstate);
15717 if (PyErr_Occurred()) SWIG_fail;
15718 }
15719 {
15720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15721 }
15722 return resultobj;
15723 fail:
15724 return NULL;
15725 }
15726
15727
15728 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15729 PyObject *resultobj;
15730 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15731 bool result;
15732 PyObject * obj0 = 0 ;
15733 char *kwnames[] = {
15734 (char *) "self", NULL
15735 };
15736
15737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15739 if (SWIG_arg_fail(1)) SWIG_fail;
15740 {
15741 PyThreadState* __tstate = wxPyBeginAllowThreads();
15742 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15743
15744 wxPyEndAllowThreads(__tstate);
15745 if (PyErr_Occurred()) SWIG_fail;
15746 }
15747 {
15748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15749 }
15750 return resultobj;
15751 fail:
15752 return NULL;
15753 }
15754
15755
15756 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15757 PyObject *resultobj;
15758 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15759 long arg2 ;
15760 PyObject * obj0 = 0 ;
15761 PyObject * obj1 = 0 ;
15762 char *kwnames[] = {
15763 (char *) "self",(char *) "extraLong", NULL
15764 };
15765
15766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15768 if (SWIG_arg_fail(1)) SWIG_fail;
15769 {
15770 arg2 = (long)(SWIG_As_long(obj1));
15771 if (SWIG_arg_fail(2)) SWIG_fail;
15772 }
15773 {
15774 PyThreadState* __tstate = wxPyBeginAllowThreads();
15775 (arg1)->SetExtraLong(arg2);
15776
15777 wxPyEndAllowThreads(__tstate);
15778 if (PyErr_Occurred()) SWIG_fail;
15779 }
15780 Py_INCREF(Py_None); resultobj = Py_None;
15781 return resultobj;
15782 fail:
15783 return NULL;
15784 }
15785
15786
15787 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15788 PyObject *resultobj;
15789 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15790 long result;
15791 PyObject * obj0 = 0 ;
15792 char *kwnames[] = {
15793 (char *) "self", NULL
15794 };
15795
15796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15798 if (SWIG_arg_fail(1)) SWIG_fail;
15799 {
15800 PyThreadState* __tstate = wxPyBeginAllowThreads();
15801 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15802
15803 wxPyEndAllowThreads(__tstate);
15804 if (PyErr_Occurred()) SWIG_fail;
15805 }
15806 {
15807 resultobj = SWIG_From_long((long)(result));
15808 }
15809 return resultobj;
15810 fail:
15811 return NULL;
15812 }
15813
15814
15815 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15816 PyObject *resultobj;
15817 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15818 int arg2 ;
15819 PyObject * obj0 = 0 ;
15820 PyObject * obj1 = 0 ;
15821 char *kwnames[] = {
15822 (char *) "self",(char *) "i", NULL
15823 };
15824
15825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15827 if (SWIG_arg_fail(1)) SWIG_fail;
15828 {
15829 arg2 = (int)(SWIG_As_int(obj1));
15830 if (SWIG_arg_fail(2)) SWIG_fail;
15831 }
15832 {
15833 PyThreadState* __tstate = wxPyBeginAllowThreads();
15834 (arg1)->SetInt(arg2);
15835
15836 wxPyEndAllowThreads(__tstate);
15837 if (PyErr_Occurred()) SWIG_fail;
15838 }
15839 Py_INCREF(Py_None); resultobj = Py_None;
15840 return resultobj;
15841 fail:
15842 return NULL;
15843 }
15844
15845
15846 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15847 PyObject *resultobj;
15848 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15849 long result;
15850 PyObject * obj0 = 0 ;
15851 char *kwnames[] = {
15852 (char *) "self", NULL
15853 };
15854
15855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15857 if (SWIG_arg_fail(1)) SWIG_fail;
15858 {
15859 PyThreadState* __tstate = wxPyBeginAllowThreads();
15860 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15861
15862 wxPyEndAllowThreads(__tstate);
15863 if (PyErr_Occurred()) SWIG_fail;
15864 }
15865 {
15866 resultobj = SWIG_From_long((long)(result));
15867 }
15868 return resultobj;
15869 fail:
15870 return NULL;
15871 }
15872
15873
15874 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15875 PyObject *resultobj;
15876 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15877 wxEvent *result;
15878 PyObject * obj0 = 0 ;
15879 char *kwnames[] = {
15880 (char *) "self", NULL
15881 };
15882
15883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15885 if (SWIG_arg_fail(1)) SWIG_fail;
15886 {
15887 PyThreadState* __tstate = wxPyBeginAllowThreads();
15888 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15889
15890 wxPyEndAllowThreads(__tstate);
15891 if (PyErr_Occurred()) SWIG_fail;
15892 }
15893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15894 return resultobj;
15895 fail:
15896 return NULL;
15897 }
15898
15899
15900 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15901 PyObject *obj;
15902 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15903 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15904 Py_INCREF(obj);
15905 return Py_BuildValue((char *)"");
15906 }
15907 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15908 PyObject *resultobj;
15909 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15910 int arg2 = (int) 0 ;
15911 wxNotifyEvent *result;
15912 PyObject * obj0 = 0 ;
15913 PyObject * obj1 = 0 ;
15914 char *kwnames[] = {
15915 (char *) "commandType",(char *) "winid", NULL
15916 };
15917
15918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15919 if (obj0) {
15920 {
15921 arg1 = (wxEventType)(SWIG_As_int(obj0));
15922 if (SWIG_arg_fail(1)) SWIG_fail;
15923 }
15924 }
15925 if (obj1) {
15926 {
15927 arg2 = (int)(SWIG_As_int(obj1));
15928 if (SWIG_arg_fail(2)) SWIG_fail;
15929 }
15930 }
15931 {
15932 PyThreadState* __tstate = wxPyBeginAllowThreads();
15933 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15934
15935 wxPyEndAllowThreads(__tstate);
15936 if (PyErr_Occurred()) SWIG_fail;
15937 }
15938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15939 return resultobj;
15940 fail:
15941 return NULL;
15942 }
15943
15944
15945 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15946 PyObject *resultobj;
15947 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15948 PyObject * obj0 = 0 ;
15949 char *kwnames[] = {
15950 (char *) "self", NULL
15951 };
15952
15953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15955 if (SWIG_arg_fail(1)) SWIG_fail;
15956 {
15957 PyThreadState* __tstate = wxPyBeginAllowThreads();
15958 (arg1)->Veto();
15959
15960 wxPyEndAllowThreads(__tstate);
15961 if (PyErr_Occurred()) SWIG_fail;
15962 }
15963 Py_INCREF(Py_None); resultobj = Py_None;
15964 return resultobj;
15965 fail:
15966 return NULL;
15967 }
15968
15969
15970 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15971 PyObject *resultobj;
15972 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15973 PyObject * obj0 = 0 ;
15974 char *kwnames[] = {
15975 (char *) "self", NULL
15976 };
15977
15978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15980 if (SWIG_arg_fail(1)) SWIG_fail;
15981 {
15982 PyThreadState* __tstate = wxPyBeginAllowThreads();
15983 (arg1)->Allow();
15984
15985 wxPyEndAllowThreads(__tstate);
15986 if (PyErr_Occurred()) SWIG_fail;
15987 }
15988 Py_INCREF(Py_None); resultobj = Py_None;
15989 return resultobj;
15990 fail:
15991 return NULL;
15992 }
15993
15994
15995 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15996 PyObject *resultobj;
15997 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15998 bool result;
15999 PyObject * obj0 = 0 ;
16000 char *kwnames[] = {
16001 (char *) "self", NULL
16002 };
16003
16004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16006 if (SWIG_arg_fail(1)) SWIG_fail;
16007 {
16008 PyThreadState* __tstate = wxPyBeginAllowThreads();
16009 result = (bool)(arg1)->IsAllowed();
16010
16011 wxPyEndAllowThreads(__tstate);
16012 if (PyErr_Occurred()) SWIG_fail;
16013 }
16014 {
16015 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16016 }
16017 return resultobj;
16018 fail:
16019 return NULL;
16020 }
16021
16022
16023 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16024 PyObject *obj;
16025 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16026 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16027 Py_INCREF(obj);
16028 return Py_BuildValue((char *)"");
16029 }
16030 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16031 PyObject *resultobj;
16032 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16033 int arg2 = (int) 0 ;
16034 int arg3 = (int) 0 ;
16035 int arg4 = (int) 0 ;
16036 wxScrollEvent *result;
16037 PyObject * obj0 = 0 ;
16038 PyObject * obj1 = 0 ;
16039 PyObject * obj2 = 0 ;
16040 PyObject * obj3 = 0 ;
16041 char *kwnames[] = {
16042 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16043 };
16044
16045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16046 if (obj0) {
16047 {
16048 arg1 = (wxEventType)(SWIG_As_int(obj0));
16049 if (SWIG_arg_fail(1)) SWIG_fail;
16050 }
16051 }
16052 if (obj1) {
16053 {
16054 arg2 = (int)(SWIG_As_int(obj1));
16055 if (SWIG_arg_fail(2)) SWIG_fail;
16056 }
16057 }
16058 if (obj2) {
16059 {
16060 arg3 = (int)(SWIG_As_int(obj2));
16061 if (SWIG_arg_fail(3)) SWIG_fail;
16062 }
16063 }
16064 if (obj3) {
16065 {
16066 arg4 = (int)(SWIG_As_int(obj3));
16067 if (SWIG_arg_fail(4)) SWIG_fail;
16068 }
16069 }
16070 {
16071 PyThreadState* __tstate = wxPyBeginAllowThreads();
16072 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16073
16074 wxPyEndAllowThreads(__tstate);
16075 if (PyErr_Occurred()) SWIG_fail;
16076 }
16077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16078 return resultobj;
16079 fail:
16080 return NULL;
16081 }
16082
16083
16084 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16085 PyObject *resultobj;
16086 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16087 int result;
16088 PyObject * obj0 = 0 ;
16089 char *kwnames[] = {
16090 (char *) "self", NULL
16091 };
16092
16093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16095 if (SWIG_arg_fail(1)) SWIG_fail;
16096 {
16097 PyThreadState* __tstate = wxPyBeginAllowThreads();
16098 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16099
16100 wxPyEndAllowThreads(__tstate);
16101 if (PyErr_Occurred()) SWIG_fail;
16102 }
16103 {
16104 resultobj = SWIG_From_int((int)(result));
16105 }
16106 return resultobj;
16107 fail:
16108 return NULL;
16109 }
16110
16111
16112 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16113 PyObject *resultobj;
16114 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16115 int result;
16116 PyObject * obj0 = 0 ;
16117 char *kwnames[] = {
16118 (char *) "self", NULL
16119 };
16120
16121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16123 if (SWIG_arg_fail(1)) SWIG_fail;
16124 {
16125 PyThreadState* __tstate = wxPyBeginAllowThreads();
16126 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16127
16128 wxPyEndAllowThreads(__tstate);
16129 if (PyErr_Occurred()) SWIG_fail;
16130 }
16131 {
16132 resultobj = SWIG_From_int((int)(result));
16133 }
16134 return resultobj;
16135 fail:
16136 return NULL;
16137 }
16138
16139
16140 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16141 PyObject *resultobj;
16142 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16143 int arg2 ;
16144 PyObject * obj0 = 0 ;
16145 PyObject * obj1 = 0 ;
16146 char *kwnames[] = {
16147 (char *) "self",(char *) "orient", NULL
16148 };
16149
16150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16152 if (SWIG_arg_fail(1)) SWIG_fail;
16153 {
16154 arg2 = (int)(SWIG_As_int(obj1));
16155 if (SWIG_arg_fail(2)) SWIG_fail;
16156 }
16157 {
16158 PyThreadState* __tstate = wxPyBeginAllowThreads();
16159 (arg1)->SetOrientation(arg2);
16160
16161 wxPyEndAllowThreads(__tstate);
16162 if (PyErr_Occurred()) SWIG_fail;
16163 }
16164 Py_INCREF(Py_None); resultobj = Py_None;
16165 return resultobj;
16166 fail:
16167 return NULL;
16168 }
16169
16170
16171 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16172 PyObject *resultobj;
16173 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16174 int arg2 ;
16175 PyObject * obj0 = 0 ;
16176 PyObject * obj1 = 0 ;
16177 char *kwnames[] = {
16178 (char *) "self",(char *) "pos", NULL
16179 };
16180
16181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16183 if (SWIG_arg_fail(1)) SWIG_fail;
16184 {
16185 arg2 = (int)(SWIG_As_int(obj1));
16186 if (SWIG_arg_fail(2)) SWIG_fail;
16187 }
16188 {
16189 PyThreadState* __tstate = wxPyBeginAllowThreads();
16190 (arg1)->SetPosition(arg2);
16191
16192 wxPyEndAllowThreads(__tstate);
16193 if (PyErr_Occurred()) SWIG_fail;
16194 }
16195 Py_INCREF(Py_None); resultobj = Py_None;
16196 return resultobj;
16197 fail:
16198 return NULL;
16199 }
16200
16201
16202 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16203 PyObject *obj;
16204 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16205 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16206 Py_INCREF(obj);
16207 return Py_BuildValue((char *)"");
16208 }
16209 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16210 PyObject *resultobj;
16211 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16212 int arg2 = (int) 0 ;
16213 int arg3 = (int) 0 ;
16214 wxScrollWinEvent *result;
16215 PyObject * obj0 = 0 ;
16216 PyObject * obj1 = 0 ;
16217 PyObject * obj2 = 0 ;
16218 char *kwnames[] = {
16219 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16220 };
16221
16222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16223 if (obj0) {
16224 {
16225 arg1 = (wxEventType)(SWIG_As_int(obj0));
16226 if (SWIG_arg_fail(1)) SWIG_fail;
16227 }
16228 }
16229 if (obj1) {
16230 {
16231 arg2 = (int)(SWIG_As_int(obj1));
16232 if (SWIG_arg_fail(2)) SWIG_fail;
16233 }
16234 }
16235 if (obj2) {
16236 {
16237 arg3 = (int)(SWIG_As_int(obj2));
16238 if (SWIG_arg_fail(3)) SWIG_fail;
16239 }
16240 }
16241 {
16242 PyThreadState* __tstate = wxPyBeginAllowThreads();
16243 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16244
16245 wxPyEndAllowThreads(__tstate);
16246 if (PyErr_Occurred()) SWIG_fail;
16247 }
16248 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16249 return resultobj;
16250 fail:
16251 return NULL;
16252 }
16253
16254
16255 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16256 PyObject *resultobj;
16257 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16258 int result;
16259 PyObject * obj0 = 0 ;
16260 char *kwnames[] = {
16261 (char *) "self", NULL
16262 };
16263
16264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16266 if (SWIG_arg_fail(1)) SWIG_fail;
16267 {
16268 PyThreadState* __tstate = wxPyBeginAllowThreads();
16269 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16270
16271 wxPyEndAllowThreads(__tstate);
16272 if (PyErr_Occurred()) SWIG_fail;
16273 }
16274 {
16275 resultobj = SWIG_From_int((int)(result));
16276 }
16277 return resultobj;
16278 fail:
16279 return NULL;
16280 }
16281
16282
16283 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16284 PyObject *resultobj;
16285 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16286 int result;
16287 PyObject * obj0 = 0 ;
16288 char *kwnames[] = {
16289 (char *) "self", NULL
16290 };
16291
16292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16294 if (SWIG_arg_fail(1)) SWIG_fail;
16295 {
16296 PyThreadState* __tstate = wxPyBeginAllowThreads();
16297 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16298
16299 wxPyEndAllowThreads(__tstate);
16300 if (PyErr_Occurred()) SWIG_fail;
16301 }
16302 {
16303 resultobj = SWIG_From_int((int)(result));
16304 }
16305 return resultobj;
16306 fail:
16307 return NULL;
16308 }
16309
16310
16311 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16312 PyObject *resultobj;
16313 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16314 int arg2 ;
16315 PyObject * obj0 = 0 ;
16316 PyObject * obj1 = 0 ;
16317 char *kwnames[] = {
16318 (char *) "self",(char *) "orient", NULL
16319 };
16320
16321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16323 if (SWIG_arg_fail(1)) SWIG_fail;
16324 {
16325 arg2 = (int)(SWIG_As_int(obj1));
16326 if (SWIG_arg_fail(2)) SWIG_fail;
16327 }
16328 {
16329 PyThreadState* __tstate = wxPyBeginAllowThreads();
16330 (arg1)->SetOrientation(arg2);
16331
16332 wxPyEndAllowThreads(__tstate);
16333 if (PyErr_Occurred()) SWIG_fail;
16334 }
16335 Py_INCREF(Py_None); resultobj = Py_None;
16336 return resultobj;
16337 fail:
16338 return NULL;
16339 }
16340
16341
16342 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16343 PyObject *resultobj;
16344 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16345 int arg2 ;
16346 PyObject * obj0 = 0 ;
16347 PyObject * obj1 = 0 ;
16348 char *kwnames[] = {
16349 (char *) "self",(char *) "pos", NULL
16350 };
16351
16352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16354 if (SWIG_arg_fail(1)) SWIG_fail;
16355 {
16356 arg2 = (int)(SWIG_As_int(obj1));
16357 if (SWIG_arg_fail(2)) SWIG_fail;
16358 }
16359 {
16360 PyThreadState* __tstate = wxPyBeginAllowThreads();
16361 (arg1)->SetPosition(arg2);
16362
16363 wxPyEndAllowThreads(__tstate);
16364 if (PyErr_Occurred()) SWIG_fail;
16365 }
16366 Py_INCREF(Py_None); resultobj = Py_None;
16367 return resultobj;
16368 fail:
16369 return NULL;
16370 }
16371
16372
16373 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16374 PyObject *obj;
16375 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16376 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16377 Py_INCREF(obj);
16378 return Py_BuildValue((char *)"");
16379 }
16380 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16381 PyObject *resultobj;
16382 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16383 wxMouseEvent *result;
16384 PyObject * obj0 = 0 ;
16385 char *kwnames[] = {
16386 (char *) "mouseType", NULL
16387 };
16388
16389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
16390 if (obj0) {
16391 {
16392 arg1 = (wxEventType)(SWIG_As_int(obj0));
16393 if (SWIG_arg_fail(1)) SWIG_fail;
16394 }
16395 }
16396 {
16397 PyThreadState* __tstate = wxPyBeginAllowThreads();
16398 result = (wxMouseEvent *)new wxMouseEvent(arg1);
16399
16400 wxPyEndAllowThreads(__tstate);
16401 if (PyErr_Occurred()) SWIG_fail;
16402 }
16403 {
16404 resultobj = wxPyMake_wxObject(result, 1);
16405 }
16406 return resultobj;
16407 fail:
16408 return NULL;
16409 }
16410
16411
16412 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
16413 PyObject *resultobj;
16414 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16415 bool result;
16416 PyObject * obj0 = 0 ;
16417 char *kwnames[] = {
16418 (char *) "self", NULL
16419 };
16420
16421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16423 if (SWIG_arg_fail(1)) SWIG_fail;
16424 {
16425 PyThreadState* __tstate = wxPyBeginAllowThreads();
16426 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16427
16428 wxPyEndAllowThreads(__tstate);
16429 if (PyErr_Occurred()) SWIG_fail;
16430 }
16431 {
16432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16433 }
16434 return resultobj;
16435 fail:
16436 return NULL;
16437 }
16438
16439
16440 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16441 PyObject *resultobj;
16442 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16443 int arg2 = (int) wxMOUSE_BTN_ANY ;
16444 bool result;
16445 PyObject * obj0 = 0 ;
16446 PyObject * obj1 = 0 ;
16447 char *kwnames[] = {
16448 (char *) "self",(char *) "but", NULL
16449 };
16450
16451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16453 if (SWIG_arg_fail(1)) SWIG_fail;
16454 if (obj1) {
16455 {
16456 arg2 = (int)(SWIG_As_int(obj1));
16457 if (SWIG_arg_fail(2)) SWIG_fail;
16458 }
16459 }
16460 {
16461 PyThreadState* __tstate = wxPyBeginAllowThreads();
16462 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16463
16464 wxPyEndAllowThreads(__tstate);
16465 if (PyErr_Occurred()) SWIG_fail;
16466 }
16467 {
16468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16469 }
16470 return resultobj;
16471 fail:
16472 return NULL;
16473 }
16474
16475
16476 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16477 PyObject *resultobj;
16478 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16479 int arg2 = (int) wxMOUSE_BTN_ANY ;
16480 bool result;
16481 PyObject * obj0 = 0 ;
16482 PyObject * obj1 = 0 ;
16483 char *kwnames[] = {
16484 (char *) "self",(char *) "but", NULL
16485 };
16486
16487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16489 if (SWIG_arg_fail(1)) SWIG_fail;
16490 if (obj1) {
16491 {
16492 arg2 = (int)(SWIG_As_int(obj1));
16493 if (SWIG_arg_fail(2)) SWIG_fail;
16494 }
16495 }
16496 {
16497 PyThreadState* __tstate = wxPyBeginAllowThreads();
16498 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16499
16500 wxPyEndAllowThreads(__tstate);
16501 if (PyErr_Occurred()) SWIG_fail;
16502 }
16503 {
16504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16505 }
16506 return resultobj;
16507 fail:
16508 return NULL;
16509 }
16510
16511
16512 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16513 PyObject *resultobj;
16514 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16515 int arg2 = (int) wxMOUSE_BTN_ANY ;
16516 bool result;
16517 PyObject * obj0 = 0 ;
16518 PyObject * obj1 = 0 ;
16519 char *kwnames[] = {
16520 (char *) "self",(char *) "but", NULL
16521 };
16522
16523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16525 if (SWIG_arg_fail(1)) SWIG_fail;
16526 if (obj1) {
16527 {
16528 arg2 = (int)(SWIG_As_int(obj1));
16529 if (SWIG_arg_fail(2)) SWIG_fail;
16530 }
16531 }
16532 {
16533 PyThreadState* __tstate = wxPyBeginAllowThreads();
16534 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16535
16536 wxPyEndAllowThreads(__tstate);
16537 if (PyErr_Occurred()) SWIG_fail;
16538 }
16539 {
16540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16541 }
16542 return resultobj;
16543 fail:
16544 return NULL;
16545 }
16546
16547
16548 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16549 PyObject *resultobj;
16550 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16551 int arg2 ;
16552 bool result;
16553 PyObject * obj0 = 0 ;
16554 PyObject * obj1 = 0 ;
16555 char *kwnames[] = {
16556 (char *) "self",(char *) "but", NULL
16557 };
16558
16559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16561 if (SWIG_arg_fail(1)) SWIG_fail;
16562 {
16563 arg2 = (int)(SWIG_As_int(obj1));
16564 if (SWIG_arg_fail(2)) SWIG_fail;
16565 }
16566 {
16567 PyThreadState* __tstate = wxPyBeginAllowThreads();
16568 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16569
16570 wxPyEndAllowThreads(__tstate);
16571 if (PyErr_Occurred()) SWIG_fail;
16572 }
16573 {
16574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16575 }
16576 return resultobj;
16577 fail:
16578 return NULL;
16579 }
16580
16581
16582 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16583 PyObject *resultobj;
16584 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16585 int arg2 ;
16586 bool result;
16587 PyObject * obj0 = 0 ;
16588 PyObject * obj1 = 0 ;
16589 char *kwnames[] = {
16590 (char *) "self",(char *) "but", NULL
16591 };
16592
16593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16595 if (SWIG_arg_fail(1)) SWIG_fail;
16596 {
16597 arg2 = (int)(SWIG_As_int(obj1));
16598 if (SWIG_arg_fail(2)) SWIG_fail;
16599 }
16600 {
16601 PyThreadState* __tstate = wxPyBeginAllowThreads();
16602 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16603
16604 wxPyEndAllowThreads(__tstate);
16605 if (PyErr_Occurred()) SWIG_fail;
16606 }
16607 {
16608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16609 }
16610 return resultobj;
16611 fail:
16612 return NULL;
16613 }
16614
16615
16616 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16617 PyObject *resultobj;
16618 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16619 int result;
16620 PyObject * obj0 = 0 ;
16621 char *kwnames[] = {
16622 (char *) "self", NULL
16623 };
16624
16625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16627 if (SWIG_arg_fail(1)) SWIG_fail;
16628 {
16629 PyThreadState* __tstate = wxPyBeginAllowThreads();
16630 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16631
16632 wxPyEndAllowThreads(__tstate);
16633 if (PyErr_Occurred()) SWIG_fail;
16634 }
16635 {
16636 resultobj = SWIG_From_int((int)(result));
16637 }
16638 return resultobj;
16639 fail:
16640 return NULL;
16641 }
16642
16643
16644 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16645 PyObject *resultobj;
16646 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16647 bool result;
16648 PyObject * obj0 = 0 ;
16649 char *kwnames[] = {
16650 (char *) "self", NULL
16651 };
16652
16653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16655 if (SWIG_arg_fail(1)) SWIG_fail;
16656 {
16657 PyThreadState* __tstate = wxPyBeginAllowThreads();
16658 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16659
16660 wxPyEndAllowThreads(__tstate);
16661 if (PyErr_Occurred()) SWIG_fail;
16662 }
16663 {
16664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16665 }
16666 return resultobj;
16667 fail:
16668 return NULL;
16669 }
16670
16671
16672 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16673 PyObject *resultobj;
16674 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16675 bool result;
16676 PyObject * obj0 = 0 ;
16677 char *kwnames[] = {
16678 (char *) "self", NULL
16679 };
16680
16681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16683 if (SWIG_arg_fail(1)) SWIG_fail;
16684 {
16685 PyThreadState* __tstate = wxPyBeginAllowThreads();
16686 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16687
16688 wxPyEndAllowThreads(__tstate);
16689 if (PyErr_Occurred()) SWIG_fail;
16690 }
16691 {
16692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16693 }
16694 return resultobj;
16695 fail:
16696 return NULL;
16697 }
16698
16699
16700 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16701 PyObject *resultobj;
16702 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16703 bool result;
16704 PyObject * obj0 = 0 ;
16705 char *kwnames[] = {
16706 (char *) "self", NULL
16707 };
16708
16709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16711 if (SWIG_arg_fail(1)) SWIG_fail;
16712 {
16713 PyThreadState* __tstate = wxPyBeginAllowThreads();
16714 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16715
16716 wxPyEndAllowThreads(__tstate);
16717 if (PyErr_Occurred()) SWIG_fail;
16718 }
16719 {
16720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16721 }
16722 return resultobj;
16723 fail:
16724 return NULL;
16725 }
16726
16727
16728 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16729 PyObject *resultobj;
16730 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16731 bool result;
16732 PyObject * obj0 = 0 ;
16733 char *kwnames[] = {
16734 (char *) "self", NULL
16735 };
16736
16737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16739 if (SWIG_arg_fail(1)) SWIG_fail;
16740 {
16741 PyThreadState* __tstate = wxPyBeginAllowThreads();
16742 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16743
16744 wxPyEndAllowThreads(__tstate);
16745 if (PyErr_Occurred()) SWIG_fail;
16746 }
16747 {
16748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16749 }
16750 return resultobj;
16751 fail:
16752 return NULL;
16753 }
16754
16755
16756 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16757 PyObject *resultobj;
16758 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16759 bool result;
16760 PyObject * obj0 = 0 ;
16761 char *kwnames[] = {
16762 (char *) "self", NULL
16763 };
16764
16765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16767 if (SWIG_arg_fail(1)) SWIG_fail;
16768 {
16769 PyThreadState* __tstate = wxPyBeginAllowThreads();
16770 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16771
16772 wxPyEndAllowThreads(__tstate);
16773 if (PyErr_Occurred()) SWIG_fail;
16774 }
16775 {
16776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16777 }
16778 return resultobj;
16779 fail:
16780 return NULL;
16781 }
16782
16783
16784 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16785 PyObject *resultobj;
16786 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16787 bool result;
16788 PyObject * obj0 = 0 ;
16789 char *kwnames[] = {
16790 (char *) "self", NULL
16791 };
16792
16793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16795 if (SWIG_arg_fail(1)) SWIG_fail;
16796 {
16797 PyThreadState* __tstate = wxPyBeginAllowThreads();
16798 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16799
16800 wxPyEndAllowThreads(__tstate);
16801 if (PyErr_Occurred()) SWIG_fail;
16802 }
16803 {
16804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16805 }
16806 return resultobj;
16807 fail:
16808 return NULL;
16809 }
16810
16811
16812 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16813 PyObject *resultobj;
16814 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16815 bool result;
16816 PyObject * obj0 = 0 ;
16817 char *kwnames[] = {
16818 (char *) "self", NULL
16819 };
16820
16821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16823 if (SWIG_arg_fail(1)) SWIG_fail;
16824 {
16825 PyThreadState* __tstate = wxPyBeginAllowThreads();
16826 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16827
16828 wxPyEndAllowThreads(__tstate);
16829 if (PyErr_Occurred()) SWIG_fail;
16830 }
16831 {
16832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16833 }
16834 return resultobj;
16835 fail:
16836 return NULL;
16837 }
16838
16839
16840 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16841 PyObject *resultobj;
16842 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16843 bool result;
16844 PyObject * obj0 = 0 ;
16845 char *kwnames[] = {
16846 (char *) "self", NULL
16847 };
16848
16849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16851 if (SWIG_arg_fail(1)) SWIG_fail;
16852 {
16853 PyThreadState* __tstate = wxPyBeginAllowThreads();
16854 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16855
16856 wxPyEndAllowThreads(__tstate);
16857 if (PyErr_Occurred()) SWIG_fail;
16858 }
16859 {
16860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16861 }
16862 return resultobj;
16863 fail:
16864 return NULL;
16865 }
16866
16867
16868 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16869 PyObject *resultobj;
16870 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16871 bool result;
16872 PyObject * obj0 = 0 ;
16873 char *kwnames[] = {
16874 (char *) "self", NULL
16875 };
16876
16877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16879 if (SWIG_arg_fail(1)) SWIG_fail;
16880 {
16881 PyThreadState* __tstate = wxPyBeginAllowThreads();
16882 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16883
16884 wxPyEndAllowThreads(__tstate);
16885 if (PyErr_Occurred()) SWIG_fail;
16886 }
16887 {
16888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16889 }
16890 return resultobj;
16891 fail:
16892 return NULL;
16893 }
16894
16895
16896 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16897 PyObject *resultobj;
16898 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16899 bool result;
16900 PyObject * obj0 = 0 ;
16901 char *kwnames[] = {
16902 (char *) "self", NULL
16903 };
16904
16905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16907 if (SWIG_arg_fail(1)) SWIG_fail;
16908 {
16909 PyThreadState* __tstate = wxPyBeginAllowThreads();
16910 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16911
16912 wxPyEndAllowThreads(__tstate);
16913 if (PyErr_Occurred()) SWIG_fail;
16914 }
16915 {
16916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16917 }
16918 return resultobj;
16919 fail:
16920 return NULL;
16921 }
16922
16923
16924 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16925 PyObject *resultobj;
16926 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16927 bool result;
16928 PyObject * obj0 = 0 ;
16929 char *kwnames[] = {
16930 (char *) "self", NULL
16931 };
16932
16933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16935 if (SWIG_arg_fail(1)) SWIG_fail;
16936 {
16937 PyThreadState* __tstate = wxPyBeginAllowThreads();
16938 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16939
16940 wxPyEndAllowThreads(__tstate);
16941 if (PyErr_Occurred()) SWIG_fail;
16942 }
16943 {
16944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16945 }
16946 return resultobj;
16947 fail:
16948 return NULL;
16949 }
16950
16951
16952 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16953 PyObject *resultobj;
16954 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16955 bool result;
16956 PyObject * obj0 = 0 ;
16957 char *kwnames[] = {
16958 (char *) "self", NULL
16959 };
16960
16961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16963 if (SWIG_arg_fail(1)) SWIG_fail;
16964 {
16965 PyThreadState* __tstate = wxPyBeginAllowThreads();
16966 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16967
16968 wxPyEndAllowThreads(__tstate);
16969 if (PyErr_Occurred()) SWIG_fail;
16970 }
16971 {
16972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16973 }
16974 return resultobj;
16975 fail:
16976 return NULL;
16977 }
16978
16979
16980 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16981 PyObject *resultobj;
16982 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16983 bool result;
16984 PyObject * obj0 = 0 ;
16985 char *kwnames[] = {
16986 (char *) "self", NULL
16987 };
16988
16989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16991 if (SWIG_arg_fail(1)) SWIG_fail;
16992 {
16993 PyThreadState* __tstate = wxPyBeginAllowThreads();
16994 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16995
16996 wxPyEndAllowThreads(__tstate);
16997 if (PyErr_Occurred()) SWIG_fail;
16998 }
16999 {
17000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17001 }
17002 return resultobj;
17003 fail:
17004 return NULL;
17005 }
17006
17007
17008 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17009 PyObject *resultobj;
17010 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17011 bool result;
17012 PyObject * obj0 = 0 ;
17013 char *kwnames[] = {
17014 (char *) "self", NULL
17015 };
17016
17017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17019 if (SWIG_arg_fail(1)) SWIG_fail;
17020 {
17021 PyThreadState* __tstate = wxPyBeginAllowThreads();
17022 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17023
17024 wxPyEndAllowThreads(__tstate);
17025 if (PyErr_Occurred()) SWIG_fail;
17026 }
17027 {
17028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17029 }
17030 return resultobj;
17031 fail:
17032 return NULL;
17033 }
17034
17035
17036 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17037 PyObject *resultobj;
17038 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17039 bool result;
17040 PyObject * obj0 = 0 ;
17041 char *kwnames[] = {
17042 (char *) "self", NULL
17043 };
17044
17045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17047 if (SWIG_arg_fail(1)) SWIG_fail;
17048 {
17049 PyThreadState* __tstate = wxPyBeginAllowThreads();
17050 result = (bool)(arg1)->LeftIsDown();
17051
17052 wxPyEndAllowThreads(__tstate);
17053 if (PyErr_Occurred()) SWIG_fail;
17054 }
17055 {
17056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17057 }
17058 return resultobj;
17059 fail:
17060 return NULL;
17061 }
17062
17063
17064 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17065 PyObject *resultobj;
17066 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17067 bool result;
17068 PyObject * obj0 = 0 ;
17069 char *kwnames[] = {
17070 (char *) "self", NULL
17071 };
17072
17073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17075 if (SWIG_arg_fail(1)) SWIG_fail;
17076 {
17077 PyThreadState* __tstate = wxPyBeginAllowThreads();
17078 result = (bool)(arg1)->MiddleIsDown();
17079
17080 wxPyEndAllowThreads(__tstate);
17081 if (PyErr_Occurred()) SWIG_fail;
17082 }
17083 {
17084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17085 }
17086 return resultobj;
17087 fail:
17088 return NULL;
17089 }
17090
17091
17092 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17093 PyObject *resultobj;
17094 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17095 bool result;
17096 PyObject * obj0 = 0 ;
17097 char *kwnames[] = {
17098 (char *) "self", NULL
17099 };
17100
17101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17103 if (SWIG_arg_fail(1)) SWIG_fail;
17104 {
17105 PyThreadState* __tstate = wxPyBeginAllowThreads();
17106 result = (bool)(arg1)->RightIsDown();
17107
17108 wxPyEndAllowThreads(__tstate);
17109 if (PyErr_Occurred()) SWIG_fail;
17110 }
17111 {
17112 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17113 }
17114 return resultobj;
17115 fail:
17116 return NULL;
17117 }
17118
17119
17120 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17121 PyObject *resultobj;
17122 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17123 bool result;
17124 PyObject * obj0 = 0 ;
17125 char *kwnames[] = {
17126 (char *) "self", NULL
17127 };
17128
17129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
17134 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17135
17136 wxPyEndAllowThreads(__tstate);
17137 if (PyErr_Occurred()) SWIG_fail;
17138 }
17139 {
17140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17141 }
17142 return resultobj;
17143 fail:
17144 return NULL;
17145 }
17146
17147
17148 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17149 PyObject *resultobj;
17150 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17151 bool result;
17152 PyObject * obj0 = 0 ;
17153 char *kwnames[] = {
17154 (char *) "self", NULL
17155 };
17156
17157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17159 if (SWIG_arg_fail(1)) SWIG_fail;
17160 {
17161 PyThreadState* __tstate = wxPyBeginAllowThreads();
17162 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17163
17164 wxPyEndAllowThreads(__tstate);
17165 if (PyErr_Occurred()) SWIG_fail;
17166 }
17167 {
17168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17169 }
17170 return resultobj;
17171 fail:
17172 return NULL;
17173 }
17174
17175
17176 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17177 PyObject *resultobj;
17178 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17179 bool result;
17180 PyObject * obj0 = 0 ;
17181 char *kwnames[] = {
17182 (char *) "self", NULL
17183 };
17184
17185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17187 if (SWIG_arg_fail(1)) SWIG_fail;
17188 {
17189 PyThreadState* __tstate = wxPyBeginAllowThreads();
17190 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17191
17192 wxPyEndAllowThreads(__tstate);
17193 if (PyErr_Occurred()) SWIG_fail;
17194 }
17195 {
17196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17197 }
17198 return resultobj;
17199 fail:
17200 return NULL;
17201 }
17202
17203
17204 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17205 PyObject *resultobj;
17206 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17207 bool result;
17208 PyObject * obj0 = 0 ;
17209 char *kwnames[] = {
17210 (char *) "self", NULL
17211 };
17212
17213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17215 if (SWIG_arg_fail(1)) SWIG_fail;
17216 {
17217 PyThreadState* __tstate = wxPyBeginAllowThreads();
17218 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17219
17220 wxPyEndAllowThreads(__tstate);
17221 if (PyErr_Occurred()) SWIG_fail;
17222 }
17223 {
17224 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17225 }
17226 return resultobj;
17227 fail:
17228 return NULL;
17229 }
17230
17231
17232 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17233 PyObject *resultobj;
17234 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17235 wxPoint result;
17236 PyObject * obj0 = 0 ;
17237 char *kwnames[] = {
17238 (char *) "self", NULL
17239 };
17240
17241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17243 if (SWIG_arg_fail(1)) SWIG_fail;
17244 {
17245 PyThreadState* __tstate = wxPyBeginAllowThreads();
17246 result = (arg1)->GetPosition();
17247
17248 wxPyEndAllowThreads(__tstate);
17249 if (PyErr_Occurred()) SWIG_fail;
17250 }
17251 {
17252 wxPoint * resultptr;
17253 resultptr = new wxPoint((wxPoint &)(result));
17254 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17255 }
17256 return resultobj;
17257 fail:
17258 return NULL;
17259 }
17260
17261
17262 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17263 PyObject *resultobj;
17264 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17265 long *arg2 = (long *) 0 ;
17266 long *arg3 = (long *) 0 ;
17267 long temp2 ;
17268 int res2 = 0 ;
17269 long temp3 ;
17270 int res3 = 0 ;
17271 PyObject * obj0 = 0 ;
17272 char *kwnames[] = {
17273 (char *) "self", NULL
17274 };
17275
17276 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17277 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17280 if (SWIG_arg_fail(1)) SWIG_fail;
17281 {
17282 PyThreadState* __tstate = wxPyBeginAllowThreads();
17283 (arg1)->GetPosition(arg2,arg3);
17284
17285 wxPyEndAllowThreads(__tstate);
17286 if (PyErr_Occurred()) SWIG_fail;
17287 }
17288 Py_INCREF(Py_None); resultobj = Py_None;
17289 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17290 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17291 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17292 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17293 return resultobj;
17294 fail:
17295 return NULL;
17296 }
17297
17298
17299 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17300 PyObject *resultobj;
17301 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17302 wxDC *arg2 = 0 ;
17303 wxPoint result;
17304 PyObject * obj0 = 0 ;
17305 PyObject * obj1 = 0 ;
17306 char *kwnames[] = {
17307 (char *) "self",(char *) "dc", NULL
17308 };
17309
17310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17312 if (SWIG_arg_fail(1)) SWIG_fail;
17313 {
17314 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17315 if (SWIG_arg_fail(2)) SWIG_fail;
17316 if (arg2 == NULL) {
17317 SWIG_null_ref("wxDC");
17318 }
17319 if (SWIG_arg_fail(2)) SWIG_fail;
17320 }
17321 {
17322 PyThreadState* __tstate = wxPyBeginAllowThreads();
17323 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17324
17325 wxPyEndAllowThreads(__tstate);
17326 if (PyErr_Occurred()) SWIG_fail;
17327 }
17328 {
17329 wxPoint * resultptr;
17330 resultptr = new wxPoint((wxPoint &)(result));
17331 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17332 }
17333 return resultobj;
17334 fail:
17335 return NULL;
17336 }
17337
17338
17339 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17340 PyObject *resultobj;
17341 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17342 int result;
17343 PyObject * obj0 = 0 ;
17344 char *kwnames[] = {
17345 (char *) "self", NULL
17346 };
17347
17348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17350 if (SWIG_arg_fail(1)) SWIG_fail;
17351 {
17352 PyThreadState* __tstate = wxPyBeginAllowThreads();
17353 result = (int)((wxMouseEvent const *)arg1)->GetX();
17354
17355 wxPyEndAllowThreads(__tstate);
17356 if (PyErr_Occurred()) SWIG_fail;
17357 }
17358 {
17359 resultobj = SWIG_From_int((int)(result));
17360 }
17361 return resultobj;
17362 fail:
17363 return NULL;
17364 }
17365
17366
17367 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17368 PyObject *resultobj;
17369 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17370 int result;
17371 PyObject * obj0 = 0 ;
17372 char *kwnames[] = {
17373 (char *) "self", NULL
17374 };
17375
17376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
17377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17378 if (SWIG_arg_fail(1)) SWIG_fail;
17379 {
17380 PyThreadState* __tstate = wxPyBeginAllowThreads();
17381 result = (int)((wxMouseEvent const *)arg1)->GetY();
17382
17383 wxPyEndAllowThreads(__tstate);
17384 if (PyErr_Occurred()) SWIG_fail;
17385 }
17386 {
17387 resultobj = SWIG_From_int((int)(result));
17388 }
17389 return resultobj;
17390 fail:
17391 return NULL;
17392 }
17393
17394
17395 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
17396 PyObject *resultobj;
17397 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17398 int result;
17399 PyObject * obj0 = 0 ;
17400 char *kwnames[] = {
17401 (char *) "self", NULL
17402 };
17403
17404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
17405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17406 if (SWIG_arg_fail(1)) SWIG_fail;
17407 {
17408 PyThreadState* __tstate = wxPyBeginAllowThreads();
17409 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
17410
17411 wxPyEndAllowThreads(__tstate);
17412 if (PyErr_Occurred()) SWIG_fail;
17413 }
17414 {
17415 resultobj = SWIG_From_int((int)(result));
17416 }
17417 return resultobj;
17418 fail:
17419 return NULL;
17420 }
17421
17422
17423 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17424 PyObject *resultobj;
17425 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17426 int result;
17427 PyObject * obj0 = 0 ;
17428 char *kwnames[] = {
17429 (char *) "self", NULL
17430 };
17431
17432 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17433 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17434 if (SWIG_arg_fail(1)) SWIG_fail;
17435 {
17436 PyThreadState* __tstate = wxPyBeginAllowThreads();
17437 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17438
17439 wxPyEndAllowThreads(__tstate);
17440 if (PyErr_Occurred()) SWIG_fail;
17441 }
17442 {
17443 resultobj = SWIG_From_int((int)(result));
17444 }
17445 return resultobj;
17446 fail:
17447 return NULL;
17448 }
17449
17450
17451 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17452 PyObject *resultobj;
17453 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17454 int result;
17455 PyObject * obj0 = 0 ;
17456 char *kwnames[] = {
17457 (char *) "self", NULL
17458 };
17459
17460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17462 if (SWIG_arg_fail(1)) SWIG_fail;
17463 {
17464 PyThreadState* __tstate = wxPyBeginAllowThreads();
17465 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17466
17467 wxPyEndAllowThreads(__tstate);
17468 if (PyErr_Occurred()) SWIG_fail;
17469 }
17470 {
17471 resultobj = SWIG_From_int((int)(result));
17472 }
17473 return resultobj;
17474 fail:
17475 return NULL;
17476 }
17477
17478
17479 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17480 PyObject *resultobj;
17481 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17482 bool result;
17483 PyObject * obj0 = 0 ;
17484 char *kwnames[] = {
17485 (char *) "self", NULL
17486 };
17487
17488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17490 if (SWIG_arg_fail(1)) SWIG_fail;
17491 {
17492 PyThreadState* __tstate = wxPyBeginAllowThreads();
17493 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17494
17495 wxPyEndAllowThreads(__tstate);
17496 if (PyErr_Occurred()) SWIG_fail;
17497 }
17498 {
17499 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17500 }
17501 return resultobj;
17502 fail:
17503 return NULL;
17504 }
17505
17506
17507 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17508 PyObject *resultobj;
17509 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17510 int arg2 ;
17511 PyObject * obj0 = 0 ;
17512 PyObject * obj1 = 0 ;
17513 char *kwnames[] = {
17514 (char *) "self",(char *) "m_x", NULL
17515 };
17516
17517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17519 if (SWIG_arg_fail(1)) SWIG_fail;
17520 {
17521 arg2 = (int)(SWIG_As_int(obj1));
17522 if (SWIG_arg_fail(2)) SWIG_fail;
17523 }
17524 if (arg1) (arg1)->m_x = arg2;
17525
17526 Py_INCREF(Py_None); resultobj = Py_None;
17527 return resultobj;
17528 fail:
17529 return NULL;
17530 }
17531
17532
17533 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17534 PyObject *resultobj;
17535 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17536 int result;
17537 PyObject * obj0 = 0 ;
17538 char *kwnames[] = {
17539 (char *) "self", NULL
17540 };
17541
17542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17544 if (SWIG_arg_fail(1)) SWIG_fail;
17545 result = (int) ((arg1)->m_x);
17546
17547 {
17548 resultobj = SWIG_From_int((int)(result));
17549 }
17550 return resultobj;
17551 fail:
17552 return NULL;
17553 }
17554
17555
17556 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17557 PyObject *resultobj;
17558 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17559 int arg2 ;
17560 PyObject * obj0 = 0 ;
17561 PyObject * obj1 = 0 ;
17562 char *kwnames[] = {
17563 (char *) "self",(char *) "m_y", NULL
17564 };
17565
17566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17568 if (SWIG_arg_fail(1)) SWIG_fail;
17569 {
17570 arg2 = (int)(SWIG_As_int(obj1));
17571 if (SWIG_arg_fail(2)) SWIG_fail;
17572 }
17573 if (arg1) (arg1)->m_y = arg2;
17574
17575 Py_INCREF(Py_None); resultobj = Py_None;
17576 return resultobj;
17577 fail:
17578 return NULL;
17579 }
17580
17581
17582 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17583 PyObject *resultobj;
17584 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17585 int result;
17586 PyObject * obj0 = 0 ;
17587 char *kwnames[] = {
17588 (char *) "self", NULL
17589 };
17590
17591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17593 if (SWIG_arg_fail(1)) SWIG_fail;
17594 result = (int) ((arg1)->m_y);
17595
17596 {
17597 resultobj = SWIG_From_int((int)(result));
17598 }
17599 return resultobj;
17600 fail:
17601 return NULL;
17602 }
17603
17604
17605 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17606 PyObject *resultobj;
17607 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17608 bool arg2 ;
17609 PyObject * obj0 = 0 ;
17610 PyObject * obj1 = 0 ;
17611 char *kwnames[] = {
17612 (char *) "self",(char *) "m_leftDown", NULL
17613 };
17614
17615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17617 if (SWIG_arg_fail(1)) SWIG_fail;
17618 {
17619 arg2 = (bool)(SWIG_As_bool(obj1));
17620 if (SWIG_arg_fail(2)) SWIG_fail;
17621 }
17622 if (arg1) (arg1)->m_leftDown = arg2;
17623
17624 Py_INCREF(Py_None); resultobj = Py_None;
17625 return resultobj;
17626 fail:
17627 return NULL;
17628 }
17629
17630
17631 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17632 PyObject *resultobj;
17633 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17634 bool result;
17635 PyObject * obj0 = 0 ;
17636 char *kwnames[] = {
17637 (char *) "self", NULL
17638 };
17639
17640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17642 if (SWIG_arg_fail(1)) SWIG_fail;
17643 result = (bool) ((arg1)->m_leftDown);
17644
17645 {
17646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17647 }
17648 return resultobj;
17649 fail:
17650 return NULL;
17651 }
17652
17653
17654 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17655 PyObject *resultobj;
17656 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17657 bool arg2 ;
17658 PyObject * obj0 = 0 ;
17659 PyObject * obj1 = 0 ;
17660 char *kwnames[] = {
17661 (char *) "self",(char *) "m_middleDown", NULL
17662 };
17663
17664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17666 if (SWIG_arg_fail(1)) SWIG_fail;
17667 {
17668 arg2 = (bool)(SWIG_As_bool(obj1));
17669 if (SWIG_arg_fail(2)) SWIG_fail;
17670 }
17671 if (arg1) (arg1)->m_middleDown = arg2;
17672
17673 Py_INCREF(Py_None); resultobj = Py_None;
17674 return resultobj;
17675 fail:
17676 return NULL;
17677 }
17678
17679
17680 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17681 PyObject *resultobj;
17682 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17683 bool result;
17684 PyObject * obj0 = 0 ;
17685 char *kwnames[] = {
17686 (char *) "self", NULL
17687 };
17688
17689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17691 if (SWIG_arg_fail(1)) SWIG_fail;
17692 result = (bool) ((arg1)->m_middleDown);
17693
17694 {
17695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17696 }
17697 return resultobj;
17698 fail:
17699 return NULL;
17700 }
17701
17702
17703 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17704 PyObject *resultobj;
17705 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17706 bool arg2 ;
17707 PyObject * obj0 = 0 ;
17708 PyObject * obj1 = 0 ;
17709 char *kwnames[] = {
17710 (char *) "self",(char *) "m_rightDown", NULL
17711 };
17712
17713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17715 if (SWIG_arg_fail(1)) SWIG_fail;
17716 {
17717 arg2 = (bool)(SWIG_As_bool(obj1));
17718 if (SWIG_arg_fail(2)) SWIG_fail;
17719 }
17720 if (arg1) (arg1)->m_rightDown = arg2;
17721
17722 Py_INCREF(Py_None); resultobj = Py_None;
17723 return resultobj;
17724 fail:
17725 return NULL;
17726 }
17727
17728
17729 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17730 PyObject *resultobj;
17731 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17732 bool result;
17733 PyObject * obj0 = 0 ;
17734 char *kwnames[] = {
17735 (char *) "self", NULL
17736 };
17737
17738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17740 if (SWIG_arg_fail(1)) SWIG_fail;
17741 result = (bool) ((arg1)->m_rightDown);
17742
17743 {
17744 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17745 }
17746 return resultobj;
17747 fail:
17748 return NULL;
17749 }
17750
17751
17752 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17753 PyObject *resultobj;
17754 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17755 bool arg2 ;
17756 PyObject * obj0 = 0 ;
17757 PyObject * obj1 = 0 ;
17758 char *kwnames[] = {
17759 (char *) "self",(char *) "m_controlDown", NULL
17760 };
17761
17762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17764 if (SWIG_arg_fail(1)) SWIG_fail;
17765 {
17766 arg2 = (bool)(SWIG_As_bool(obj1));
17767 if (SWIG_arg_fail(2)) SWIG_fail;
17768 }
17769 if (arg1) (arg1)->m_controlDown = arg2;
17770
17771 Py_INCREF(Py_None); resultobj = Py_None;
17772 return resultobj;
17773 fail:
17774 return NULL;
17775 }
17776
17777
17778 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17779 PyObject *resultobj;
17780 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17781 bool result;
17782 PyObject * obj0 = 0 ;
17783 char *kwnames[] = {
17784 (char *) "self", NULL
17785 };
17786
17787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17789 if (SWIG_arg_fail(1)) SWIG_fail;
17790 result = (bool) ((arg1)->m_controlDown);
17791
17792 {
17793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17794 }
17795 return resultobj;
17796 fail:
17797 return NULL;
17798 }
17799
17800
17801 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17802 PyObject *resultobj;
17803 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17804 bool arg2 ;
17805 PyObject * obj0 = 0 ;
17806 PyObject * obj1 = 0 ;
17807 char *kwnames[] = {
17808 (char *) "self",(char *) "m_shiftDown", NULL
17809 };
17810
17811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17813 if (SWIG_arg_fail(1)) SWIG_fail;
17814 {
17815 arg2 = (bool)(SWIG_As_bool(obj1));
17816 if (SWIG_arg_fail(2)) SWIG_fail;
17817 }
17818 if (arg1) (arg1)->m_shiftDown = arg2;
17819
17820 Py_INCREF(Py_None); resultobj = Py_None;
17821 return resultobj;
17822 fail:
17823 return NULL;
17824 }
17825
17826
17827 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17828 PyObject *resultobj;
17829 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17830 bool result;
17831 PyObject * obj0 = 0 ;
17832 char *kwnames[] = {
17833 (char *) "self", NULL
17834 };
17835
17836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17838 if (SWIG_arg_fail(1)) SWIG_fail;
17839 result = (bool) ((arg1)->m_shiftDown);
17840
17841 {
17842 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17843 }
17844 return resultobj;
17845 fail:
17846 return NULL;
17847 }
17848
17849
17850 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17851 PyObject *resultobj;
17852 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17853 bool arg2 ;
17854 PyObject * obj0 = 0 ;
17855 PyObject * obj1 = 0 ;
17856 char *kwnames[] = {
17857 (char *) "self",(char *) "m_altDown", NULL
17858 };
17859
17860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17862 if (SWIG_arg_fail(1)) SWIG_fail;
17863 {
17864 arg2 = (bool)(SWIG_As_bool(obj1));
17865 if (SWIG_arg_fail(2)) SWIG_fail;
17866 }
17867 if (arg1) (arg1)->m_altDown = arg2;
17868
17869 Py_INCREF(Py_None); resultobj = Py_None;
17870 return resultobj;
17871 fail:
17872 return NULL;
17873 }
17874
17875
17876 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17877 PyObject *resultobj;
17878 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17879 bool result;
17880 PyObject * obj0 = 0 ;
17881 char *kwnames[] = {
17882 (char *) "self", NULL
17883 };
17884
17885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17887 if (SWIG_arg_fail(1)) SWIG_fail;
17888 result = (bool) ((arg1)->m_altDown);
17889
17890 {
17891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17892 }
17893 return resultobj;
17894 fail:
17895 return NULL;
17896 }
17897
17898
17899 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17900 PyObject *resultobj;
17901 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17902 bool arg2 ;
17903 PyObject * obj0 = 0 ;
17904 PyObject * obj1 = 0 ;
17905 char *kwnames[] = {
17906 (char *) "self",(char *) "m_metaDown", NULL
17907 };
17908
17909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17911 if (SWIG_arg_fail(1)) SWIG_fail;
17912 {
17913 arg2 = (bool)(SWIG_As_bool(obj1));
17914 if (SWIG_arg_fail(2)) SWIG_fail;
17915 }
17916 if (arg1) (arg1)->m_metaDown = arg2;
17917
17918 Py_INCREF(Py_None); resultobj = Py_None;
17919 return resultobj;
17920 fail:
17921 return NULL;
17922 }
17923
17924
17925 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17926 PyObject *resultobj;
17927 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17928 bool result;
17929 PyObject * obj0 = 0 ;
17930 char *kwnames[] = {
17931 (char *) "self", NULL
17932 };
17933
17934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17936 if (SWIG_arg_fail(1)) SWIG_fail;
17937 result = (bool) ((arg1)->m_metaDown);
17938
17939 {
17940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17941 }
17942 return resultobj;
17943 fail:
17944 return NULL;
17945 }
17946
17947
17948 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17949 PyObject *resultobj;
17950 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17951 int arg2 ;
17952 PyObject * obj0 = 0 ;
17953 PyObject * obj1 = 0 ;
17954 char *kwnames[] = {
17955 (char *) "self",(char *) "m_wheelRotation", NULL
17956 };
17957
17958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17960 if (SWIG_arg_fail(1)) SWIG_fail;
17961 {
17962 arg2 = (int)(SWIG_As_int(obj1));
17963 if (SWIG_arg_fail(2)) SWIG_fail;
17964 }
17965 if (arg1) (arg1)->m_wheelRotation = arg2;
17966
17967 Py_INCREF(Py_None); resultobj = Py_None;
17968 return resultobj;
17969 fail:
17970 return NULL;
17971 }
17972
17973
17974 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17975 PyObject *resultobj;
17976 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17977 int result;
17978 PyObject * obj0 = 0 ;
17979 char *kwnames[] = {
17980 (char *) "self", NULL
17981 };
17982
17983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17985 if (SWIG_arg_fail(1)) SWIG_fail;
17986 result = (int) ((arg1)->m_wheelRotation);
17987
17988 {
17989 resultobj = SWIG_From_int((int)(result));
17990 }
17991 return resultobj;
17992 fail:
17993 return NULL;
17994 }
17995
17996
17997 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17998 PyObject *resultobj;
17999 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18000 int arg2 ;
18001 PyObject * obj0 = 0 ;
18002 PyObject * obj1 = 0 ;
18003 char *kwnames[] = {
18004 (char *) "self",(char *) "m_wheelDelta", NULL
18005 };
18006
18007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18009 if (SWIG_arg_fail(1)) SWIG_fail;
18010 {
18011 arg2 = (int)(SWIG_As_int(obj1));
18012 if (SWIG_arg_fail(2)) SWIG_fail;
18013 }
18014 if (arg1) (arg1)->m_wheelDelta = arg2;
18015
18016 Py_INCREF(Py_None); resultobj = Py_None;
18017 return resultobj;
18018 fail:
18019 return NULL;
18020 }
18021
18022
18023 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18024 PyObject *resultobj;
18025 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18026 int result;
18027 PyObject * obj0 = 0 ;
18028 char *kwnames[] = {
18029 (char *) "self", NULL
18030 };
18031
18032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18034 if (SWIG_arg_fail(1)) SWIG_fail;
18035 result = (int) ((arg1)->m_wheelDelta);
18036
18037 {
18038 resultobj = SWIG_From_int((int)(result));
18039 }
18040 return resultobj;
18041 fail:
18042 return NULL;
18043 }
18044
18045
18046 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18047 PyObject *resultobj;
18048 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18049 int arg2 ;
18050 PyObject * obj0 = 0 ;
18051 PyObject * obj1 = 0 ;
18052 char *kwnames[] = {
18053 (char *) "self",(char *) "m_linesPerAction", NULL
18054 };
18055
18056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18058 if (SWIG_arg_fail(1)) SWIG_fail;
18059 {
18060 arg2 = (int)(SWIG_As_int(obj1));
18061 if (SWIG_arg_fail(2)) SWIG_fail;
18062 }
18063 if (arg1) (arg1)->m_linesPerAction = arg2;
18064
18065 Py_INCREF(Py_None); resultobj = Py_None;
18066 return resultobj;
18067 fail:
18068 return NULL;
18069 }
18070
18071
18072 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18073 PyObject *resultobj;
18074 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18075 int result;
18076 PyObject * obj0 = 0 ;
18077 char *kwnames[] = {
18078 (char *) "self", NULL
18079 };
18080
18081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18083 if (SWIG_arg_fail(1)) SWIG_fail;
18084 result = (int) ((arg1)->m_linesPerAction);
18085
18086 {
18087 resultobj = SWIG_From_int((int)(result));
18088 }
18089 return resultobj;
18090 fail:
18091 return NULL;
18092 }
18093
18094
18095 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18096 PyObject *obj;
18097 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18098 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18099 Py_INCREF(obj);
18100 return Py_BuildValue((char *)"");
18101 }
18102 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18103 PyObject *resultobj;
18104 int arg1 = (int) 0 ;
18105 int arg2 = (int) 0 ;
18106 wxSetCursorEvent *result;
18107 PyObject * obj0 = 0 ;
18108 PyObject * obj1 = 0 ;
18109 char *kwnames[] = {
18110 (char *) "x",(char *) "y", NULL
18111 };
18112
18113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18114 if (obj0) {
18115 {
18116 arg1 = (int)(SWIG_As_int(obj0));
18117 if (SWIG_arg_fail(1)) SWIG_fail;
18118 }
18119 }
18120 if (obj1) {
18121 {
18122 arg2 = (int)(SWIG_As_int(obj1));
18123 if (SWIG_arg_fail(2)) SWIG_fail;
18124 }
18125 }
18126 {
18127 PyThreadState* __tstate = wxPyBeginAllowThreads();
18128 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18129
18130 wxPyEndAllowThreads(__tstate);
18131 if (PyErr_Occurred()) SWIG_fail;
18132 }
18133 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18134 return resultobj;
18135 fail:
18136 return NULL;
18137 }
18138
18139
18140 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18141 PyObject *resultobj;
18142 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18143 int result;
18144 PyObject * obj0 = 0 ;
18145 char *kwnames[] = {
18146 (char *) "self", NULL
18147 };
18148
18149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18151 if (SWIG_arg_fail(1)) SWIG_fail;
18152 {
18153 PyThreadState* __tstate = wxPyBeginAllowThreads();
18154 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18155
18156 wxPyEndAllowThreads(__tstate);
18157 if (PyErr_Occurred()) SWIG_fail;
18158 }
18159 {
18160 resultobj = SWIG_From_int((int)(result));
18161 }
18162 return resultobj;
18163 fail:
18164 return NULL;
18165 }
18166
18167
18168 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18169 PyObject *resultobj;
18170 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18171 int result;
18172 PyObject * obj0 = 0 ;
18173 char *kwnames[] = {
18174 (char *) "self", NULL
18175 };
18176
18177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18179 if (SWIG_arg_fail(1)) SWIG_fail;
18180 {
18181 PyThreadState* __tstate = wxPyBeginAllowThreads();
18182 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18183
18184 wxPyEndAllowThreads(__tstate);
18185 if (PyErr_Occurred()) SWIG_fail;
18186 }
18187 {
18188 resultobj = SWIG_From_int((int)(result));
18189 }
18190 return resultobj;
18191 fail:
18192 return NULL;
18193 }
18194
18195
18196 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18197 PyObject *resultobj;
18198 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18199 wxCursor *arg2 = 0 ;
18200 PyObject * obj0 = 0 ;
18201 PyObject * obj1 = 0 ;
18202 char *kwnames[] = {
18203 (char *) "self",(char *) "cursor", NULL
18204 };
18205
18206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18208 if (SWIG_arg_fail(1)) SWIG_fail;
18209 {
18210 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18211 if (SWIG_arg_fail(2)) SWIG_fail;
18212 if (arg2 == NULL) {
18213 SWIG_null_ref("wxCursor");
18214 }
18215 if (SWIG_arg_fail(2)) SWIG_fail;
18216 }
18217 {
18218 PyThreadState* __tstate = wxPyBeginAllowThreads();
18219 (arg1)->SetCursor((wxCursor const &)*arg2);
18220
18221 wxPyEndAllowThreads(__tstate);
18222 if (PyErr_Occurred()) SWIG_fail;
18223 }
18224 Py_INCREF(Py_None); resultobj = Py_None;
18225 return resultobj;
18226 fail:
18227 return NULL;
18228 }
18229
18230
18231 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18232 PyObject *resultobj;
18233 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18234 wxCursor *result;
18235 PyObject * obj0 = 0 ;
18236 char *kwnames[] = {
18237 (char *) "self", NULL
18238 };
18239
18240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18242 if (SWIG_arg_fail(1)) SWIG_fail;
18243 {
18244 PyThreadState* __tstate = wxPyBeginAllowThreads();
18245 {
18246 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18247 result = (wxCursor *) &_result_ref;
18248 }
18249
18250 wxPyEndAllowThreads(__tstate);
18251 if (PyErr_Occurred()) SWIG_fail;
18252 }
18253 {
18254 wxCursor* resultptr = new wxCursor(*result);
18255 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18256 }
18257 return resultobj;
18258 fail:
18259 return NULL;
18260 }
18261
18262
18263 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18264 PyObject *resultobj;
18265 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18266 bool result;
18267 PyObject * obj0 = 0 ;
18268 char *kwnames[] = {
18269 (char *) "self", NULL
18270 };
18271
18272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18274 if (SWIG_arg_fail(1)) SWIG_fail;
18275 {
18276 PyThreadState* __tstate = wxPyBeginAllowThreads();
18277 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18278
18279 wxPyEndAllowThreads(__tstate);
18280 if (PyErr_Occurred()) SWIG_fail;
18281 }
18282 {
18283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18284 }
18285 return resultobj;
18286 fail:
18287 return NULL;
18288 }
18289
18290
18291 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18292 PyObject *obj;
18293 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18294 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18295 Py_INCREF(obj);
18296 return Py_BuildValue((char *)"");
18297 }
18298 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18299 PyObject *resultobj;
18300 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18301 wxKeyEvent *result;
18302 PyObject * obj0 = 0 ;
18303 char *kwnames[] = {
18304 (char *) "keyType", NULL
18305 };
18306
18307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18308 if (obj0) {
18309 {
18310 arg1 = (wxEventType)(SWIG_As_int(obj0));
18311 if (SWIG_arg_fail(1)) SWIG_fail;
18312 }
18313 }
18314 {
18315 PyThreadState* __tstate = wxPyBeginAllowThreads();
18316 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18317
18318 wxPyEndAllowThreads(__tstate);
18319 if (PyErr_Occurred()) SWIG_fail;
18320 }
18321 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18322 return resultobj;
18323 fail:
18324 return NULL;
18325 }
18326
18327
18328 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18329 PyObject *resultobj;
18330 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18331 bool result;
18332 PyObject * obj0 = 0 ;
18333 char *kwnames[] = {
18334 (char *) "self", NULL
18335 };
18336
18337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18339 if (SWIG_arg_fail(1)) SWIG_fail;
18340 {
18341 PyThreadState* __tstate = wxPyBeginAllowThreads();
18342 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18343
18344 wxPyEndAllowThreads(__tstate);
18345 if (PyErr_Occurred()) SWIG_fail;
18346 }
18347 {
18348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18349 }
18350 return resultobj;
18351 fail:
18352 return NULL;
18353 }
18354
18355
18356 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18357 PyObject *resultobj;
18358 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18359 bool result;
18360 PyObject * obj0 = 0 ;
18361 char *kwnames[] = {
18362 (char *) "self", NULL
18363 };
18364
18365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18367 if (SWIG_arg_fail(1)) SWIG_fail;
18368 {
18369 PyThreadState* __tstate = wxPyBeginAllowThreads();
18370 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18371
18372 wxPyEndAllowThreads(__tstate);
18373 if (PyErr_Occurred()) SWIG_fail;
18374 }
18375 {
18376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18377 }
18378 return resultobj;
18379 fail:
18380 return NULL;
18381 }
18382
18383
18384 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
18385 PyObject *resultobj;
18386 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18387 bool result;
18388 PyObject * obj0 = 0 ;
18389 char *kwnames[] = {
18390 (char *) "self", NULL
18391 };
18392
18393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
18394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18395 if (SWIG_arg_fail(1)) SWIG_fail;
18396 {
18397 PyThreadState* __tstate = wxPyBeginAllowThreads();
18398 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
18399
18400 wxPyEndAllowThreads(__tstate);
18401 if (PyErr_Occurred()) SWIG_fail;
18402 }
18403 {
18404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18405 }
18406 return resultobj;
18407 fail:
18408 return NULL;
18409 }
18410
18411
18412 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
18413 PyObject *resultobj;
18414 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18415 bool result;
18416 PyObject * obj0 = 0 ;
18417 char *kwnames[] = {
18418 (char *) "self", NULL
18419 };
18420
18421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
18422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18423 if (SWIG_arg_fail(1)) SWIG_fail;
18424 {
18425 PyThreadState* __tstate = wxPyBeginAllowThreads();
18426 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18427
18428 wxPyEndAllowThreads(__tstate);
18429 if (PyErr_Occurred()) SWIG_fail;
18430 }
18431 {
18432 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18433 }
18434 return resultobj;
18435 fail:
18436 return NULL;
18437 }
18438
18439
18440 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18441 PyObject *resultobj;
18442 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18443 bool result;
18444 PyObject * obj0 = 0 ;
18445 char *kwnames[] = {
18446 (char *) "self", NULL
18447 };
18448
18449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18451 if (SWIG_arg_fail(1)) SWIG_fail;
18452 {
18453 PyThreadState* __tstate = wxPyBeginAllowThreads();
18454 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18455
18456 wxPyEndAllowThreads(__tstate);
18457 if (PyErr_Occurred()) SWIG_fail;
18458 }
18459 {
18460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18461 }
18462 return resultobj;
18463 fail:
18464 return NULL;
18465 }
18466
18467
18468 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18469 PyObject *resultobj;
18470 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18471 bool result;
18472 PyObject * obj0 = 0 ;
18473 char *kwnames[] = {
18474 (char *) "self", NULL
18475 };
18476
18477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18479 if (SWIG_arg_fail(1)) SWIG_fail;
18480 {
18481 PyThreadState* __tstate = wxPyBeginAllowThreads();
18482 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18483
18484 wxPyEndAllowThreads(__tstate);
18485 if (PyErr_Occurred()) SWIG_fail;
18486 }
18487 {
18488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18489 }
18490 return resultobj;
18491 fail:
18492 return NULL;
18493 }
18494
18495
18496 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18497 PyObject *resultobj;
18498 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18499 int result;
18500 PyObject * obj0 = 0 ;
18501 char *kwnames[] = {
18502 (char *) "self", NULL
18503 };
18504
18505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18507 if (SWIG_arg_fail(1)) SWIG_fail;
18508 {
18509 PyThreadState* __tstate = wxPyBeginAllowThreads();
18510 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18511
18512 wxPyEndAllowThreads(__tstate);
18513 if (PyErr_Occurred()) SWIG_fail;
18514 }
18515 {
18516 resultobj = SWIG_From_int((int)(result));
18517 }
18518 return resultobj;
18519 fail:
18520 return NULL;
18521 }
18522
18523
18524 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18525 PyObject *resultobj;
18526 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18527 int result;
18528 PyObject * obj0 = 0 ;
18529 char *kwnames[] = {
18530 (char *) "self", NULL
18531 };
18532
18533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18535 if (SWIG_arg_fail(1)) SWIG_fail;
18536 {
18537 PyThreadState* __tstate = wxPyBeginAllowThreads();
18538 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18539
18540 wxPyEndAllowThreads(__tstate);
18541 if (PyErr_Occurred()) SWIG_fail;
18542 }
18543 {
18544 resultobj = SWIG_From_int((int)(result));
18545 }
18546 return resultobj;
18547 fail:
18548 return NULL;
18549 }
18550
18551
18552 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18553 PyObject *resultobj;
18554 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18555 unsigned int result;
18556 PyObject * obj0 = 0 ;
18557 char *kwnames[] = {
18558 (char *) "self", NULL
18559 };
18560
18561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18563 if (SWIG_arg_fail(1)) SWIG_fail;
18564 {
18565 PyThreadState* __tstate = wxPyBeginAllowThreads();
18566 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18567
18568 wxPyEndAllowThreads(__tstate);
18569 if (PyErr_Occurred()) SWIG_fail;
18570 }
18571 {
18572 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18573 }
18574 return resultobj;
18575 fail:
18576 return NULL;
18577 }
18578
18579
18580 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18581 PyObject *resultobj;
18582 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18583 unsigned int result;
18584 PyObject * obj0 = 0 ;
18585 char *kwnames[] = {
18586 (char *) "self", NULL
18587 };
18588
18589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18591 if (SWIG_arg_fail(1)) SWIG_fail;
18592 {
18593 PyThreadState* __tstate = wxPyBeginAllowThreads();
18594 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18595
18596 wxPyEndAllowThreads(__tstate);
18597 if (PyErr_Occurred()) SWIG_fail;
18598 }
18599 {
18600 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18601 }
18602 return resultobj;
18603 fail:
18604 return NULL;
18605 }
18606
18607
18608 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18609 PyObject *resultobj;
18610 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18611 wxPoint result;
18612 PyObject * obj0 = 0 ;
18613 char *kwnames[] = {
18614 (char *) "self", NULL
18615 };
18616
18617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18619 if (SWIG_arg_fail(1)) SWIG_fail;
18620 {
18621 PyThreadState* __tstate = wxPyBeginAllowThreads();
18622 result = (arg1)->GetPosition();
18623
18624 wxPyEndAllowThreads(__tstate);
18625 if (PyErr_Occurred()) SWIG_fail;
18626 }
18627 {
18628 wxPoint * resultptr;
18629 resultptr = new wxPoint((wxPoint &)(result));
18630 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18631 }
18632 return resultobj;
18633 fail:
18634 return NULL;
18635 }
18636
18637
18638 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18639 PyObject *resultobj;
18640 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18641 long *arg2 = (long *) 0 ;
18642 long *arg3 = (long *) 0 ;
18643 long temp2 ;
18644 int res2 = 0 ;
18645 long temp3 ;
18646 int res3 = 0 ;
18647 PyObject * obj0 = 0 ;
18648 char *kwnames[] = {
18649 (char *) "self", NULL
18650 };
18651
18652 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18653 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18656 if (SWIG_arg_fail(1)) SWIG_fail;
18657 {
18658 PyThreadState* __tstate = wxPyBeginAllowThreads();
18659 (arg1)->GetPosition(arg2,arg3);
18660
18661 wxPyEndAllowThreads(__tstate);
18662 if (PyErr_Occurred()) SWIG_fail;
18663 }
18664 Py_INCREF(Py_None); resultobj = Py_None;
18665 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18666 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18667 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18668 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18669 return resultobj;
18670 fail:
18671 return NULL;
18672 }
18673
18674
18675 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18676 PyObject *resultobj;
18677 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18678 int result;
18679 PyObject * obj0 = 0 ;
18680 char *kwnames[] = {
18681 (char *) "self", NULL
18682 };
18683
18684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18686 if (SWIG_arg_fail(1)) SWIG_fail;
18687 {
18688 PyThreadState* __tstate = wxPyBeginAllowThreads();
18689 result = (int)((wxKeyEvent const *)arg1)->GetX();
18690
18691 wxPyEndAllowThreads(__tstate);
18692 if (PyErr_Occurred()) SWIG_fail;
18693 }
18694 {
18695 resultobj = SWIG_From_int((int)(result));
18696 }
18697 return resultobj;
18698 fail:
18699 return NULL;
18700 }
18701
18702
18703 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18704 PyObject *resultobj;
18705 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18706 int result;
18707 PyObject * obj0 = 0 ;
18708 char *kwnames[] = {
18709 (char *) "self", NULL
18710 };
18711
18712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18714 if (SWIG_arg_fail(1)) SWIG_fail;
18715 {
18716 PyThreadState* __tstate = wxPyBeginAllowThreads();
18717 result = (int)((wxKeyEvent const *)arg1)->GetY();
18718
18719 wxPyEndAllowThreads(__tstate);
18720 if (PyErr_Occurred()) SWIG_fail;
18721 }
18722 {
18723 resultobj = SWIG_From_int((int)(result));
18724 }
18725 return resultobj;
18726 fail:
18727 return NULL;
18728 }
18729
18730
18731 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18732 PyObject *resultobj;
18733 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18734 int arg2 ;
18735 PyObject * obj0 = 0 ;
18736 PyObject * obj1 = 0 ;
18737 char *kwnames[] = {
18738 (char *) "self",(char *) "m_x", NULL
18739 };
18740
18741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18743 if (SWIG_arg_fail(1)) SWIG_fail;
18744 {
18745 arg2 = (int)(SWIG_As_int(obj1));
18746 if (SWIG_arg_fail(2)) SWIG_fail;
18747 }
18748 if (arg1) (arg1)->m_x = arg2;
18749
18750 Py_INCREF(Py_None); resultobj = Py_None;
18751 return resultobj;
18752 fail:
18753 return NULL;
18754 }
18755
18756
18757 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18758 PyObject *resultobj;
18759 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18760 int result;
18761 PyObject * obj0 = 0 ;
18762 char *kwnames[] = {
18763 (char *) "self", NULL
18764 };
18765
18766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18768 if (SWIG_arg_fail(1)) SWIG_fail;
18769 result = (int) ((arg1)->m_x);
18770
18771 {
18772 resultobj = SWIG_From_int((int)(result));
18773 }
18774 return resultobj;
18775 fail:
18776 return NULL;
18777 }
18778
18779
18780 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18781 PyObject *resultobj;
18782 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18783 int arg2 ;
18784 PyObject * obj0 = 0 ;
18785 PyObject * obj1 = 0 ;
18786 char *kwnames[] = {
18787 (char *) "self",(char *) "m_y", NULL
18788 };
18789
18790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18792 if (SWIG_arg_fail(1)) SWIG_fail;
18793 {
18794 arg2 = (int)(SWIG_As_int(obj1));
18795 if (SWIG_arg_fail(2)) SWIG_fail;
18796 }
18797 if (arg1) (arg1)->m_y = arg2;
18798
18799 Py_INCREF(Py_None); resultobj = Py_None;
18800 return resultobj;
18801 fail:
18802 return NULL;
18803 }
18804
18805
18806 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18807 PyObject *resultobj;
18808 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18809 int result;
18810 PyObject * obj0 = 0 ;
18811 char *kwnames[] = {
18812 (char *) "self", NULL
18813 };
18814
18815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18817 if (SWIG_arg_fail(1)) SWIG_fail;
18818 result = (int) ((arg1)->m_y);
18819
18820 {
18821 resultobj = SWIG_From_int((int)(result));
18822 }
18823 return resultobj;
18824 fail:
18825 return NULL;
18826 }
18827
18828
18829 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18830 PyObject *resultobj;
18831 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18832 long arg2 ;
18833 PyObject * obj0 = 0 ;
18834 PyObject * obj1 = 0 ;
18835 char *kwnames[] = {
18836 (char *) "self",(char *) "m_keyCode", NULL
18837 };
18838
18839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18841 if (SWIG_arg_fail(1)) SWIG_fail;
18842 {
18843 arg2 = (long)(SWIG_As_long(obj1));
18844 if (SWIG_arg_fail(2)) SWIG_fail;
18845 }
18846 if (arg1) (arg1)->m_keyCode = arg2;
18847
18848 Py_INCREF(Py_None); resultobj = Py_None;
18849 return resultobj;
18850 fail:
18851 return NULL;
18852 }
18853
18854
18855 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18856 PyObject *resultobj;
18857 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18858 long result;
18859 PyObject * obj0 = 0 ;
18860 char *kwnames[] = {
18861 (char *) "self", NULL
18862 };
18863
18864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18866 if (SWIG_arg_fail(1)) SWIG_fail;
18867 result = (long) ((arg1)->m_keyCode);
18868
18869 {
18870 resultobj = SWIG_From_long((long)(result));
18871 }
18872 return resultobj;
18873 fail:
18874 return NULL;
18875 }
18876
18877
18878 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18879 PyObject *resultobj;
18880 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18881 bool arg2 ;
18882 PyObject * obj0 = 0 ;
18883 PyObject * obj1 = 0 ;
18884 char *kwnames[] = {
18885 (char *) "self",(char *) "m_controlDown", NULL
18886 };
18887
18888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18890 if (SWIG_arg_fail(1)) SWIG_fail;
18891 {
18892 arg2 = (bool)(SWIG_As_bool(obj1));
18893 if (SWIG_arg_fail(2)) SWIG_fail;
18894 }
18895 if (arg1) (arg1)->m_controlDown = arg2;
18896
18897 Py_INCREF(Py_None); resultobj = Py_None;
18898 return resultobj;
18899 fail:
18900 return NULL;
18901 }
18902
18903
18904 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18905 PyObject *resultobj;
18906 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18907 bool result;
18908 PyObject * obj0 = 0 ;
18909 char *kwnames[] = {
18910 (char *) "self", NULL
18911 };
18912
18913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18915 if (SWIG_arg_fail(1)) SWIG_fail;
18916 result = (bool) ((arg1)->m_controlDown);
18917
18918 {
18919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18920 }
18921 return resultobj;
18922 fail:
18923 return NULL;
18924 }
18925
18926
18927 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18928 PyObject *resultobj;
18929 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18930 bool arg2 ;
18931 PyObject * obj0 = 0 ;
18932 PyObject * obj1 = 0 ;
18933 char *kwnames[] = {
18934 (char *) "self",(char *) "m_shiftDown", NULL
18935 };
18936
18937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18939 if (SWIG_arg_fail(1)) SWIG_fail;
18940 {
18941 arg2 = (bool)(SWIG_As_bool(obj1));
18942 if (SWIG_arg_fail(2)) SWIG_fail;
18943 }
18944 if (arg1) (arg1)->m_shiftDown = arg2;
18945
18946 Py_INCREF(Py_None); resultobj = Py_None;
18947 return resultobj;
18948 fail:
18949 return NULL;
18950 }
18951
18952
18953 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18954 PyObject *resultobj;
18955 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18956 bool result;
18957 PyObject * obj0 = 0 ;
18958 char *kwnames[] = {
18959 (char *) "self", NULL
18960 };
18961
18962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18964 if (SWIG_arg_fail(1)) SWIG_fail;
18965 result = (bool) ((arg1)->m_shiftDown);
18966
18967 {
18968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18969 }
18970 return resultobj;
18971 fail:
18972 return NULL;
18973 }
18974
18975
18976 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18977 PyObject *resultobj;
18978 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18979 bool arg2 ;
18980 PyObject * obj0 = 0 ;
18981 PyObject * obj1 = 0 ;
18982 char *kwnames[] = {
18983 (char *) "self",(char *) "m_altDown", NULL
18984 };
18985
18986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18988 if (SWIG_arg_fail(1)) SWIG_fail;
18989 {
18990 arg2 = (bool)(SWIG_As_bool(obj1));
18991 if (SWIG_arg_fail(2)) SWIG_fail;
18992 }
18993 if (arg1) (arg1)->m_altDown = arg2;
18994
18995 Py_INCREF(Py_None); resultobj = Py_None;
18996 return resultobj;
18997 fail:
18998 return NULL;
18999 }
19000
19001
19002 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19003 PyObject *resultobj;
19004 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19005 bool result;
19006 PyObject * obj0 = 0 ;
19007 char *kwnames[] = {
19008 (char *) "self", NULL
19009 };
19010
19011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19013 if (SWIG_arg_fail(1)) SWIG_fail;
19014 result = (bool) ((arg1)->m_altDown);
19015
19016 {
19017 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19018 }
19019 return resultobj;
19020 fail:
19021 return NULL;
19022 }
19023
19024
19025 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19026 PyObject *resultobj;
19027 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19028 bool arg2 ;
19029 PyObject * obj0 = 0 ;
19030 PyObject * obj1 = 0 ;
19031 char *kwnames[] = {
19032 (char *) "self",(char *) "m_metaDown", NULL
19033 };
19034
19035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19037 if (SWIG_arg_fail(1)) SWIG_fail;
19038 {
19039 arg2 = (bool)(SWIG_As_bool(obj1));
19040 if (SWIG_arg_fail(2)) SWIG_fail;
19041 }
19042 if (arg1) (arg1)->m_metaDown = arg2;
19043
19044 Py_INCREF(Py_None); resultobj = Py_None;
19045 return resultobj;
19046 fail:
19047 return NULL;
19048 }
19049
19050
19051 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19052 PyObject *resultobj;
19053 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19054 bool result;
19055 PyObject * obj0 = 0 ;
19056 char *kwnames[] = {
19057 (char *) "self", NULL
19058 };
19059
19060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19062 if (SWIG_arg_fail(1)) SWIG_fail;
19063 result = (bool) ((arg1)->m_metaDown);
19064
19065 {
19066 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19067 }
19068 return resultobj;
19069 fail:
19070 return NULL;
19071 }
19072
19073
19074 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19075 PyObject *resultobj;
19076 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19077 bool arg2 ;
19078 PyObject * obj0 = 0 ;
19079 PyObject * obj1 = 0 ;
19080 char *kwnames[] = {
19081 (char *) "self",(char *) "m_scanCode", NULL
19082 };
19083
19084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19086 if (SWIG_arg_fail(1)) SWIG_fail;
19087 {
19088 arg2 = (bool)(SWIG_As_bool(obj1));
19089 if (SWIG_arg_fail(2)) SWIG_fail;
19090 }
19091 if (arg1) (arg1)->m_scanCode = arg2;
19092
19093 Py_INCREF(Py_None); resultobj = Py_None;
19094 return resultobj;
19095 fail:
19096 return NULL;
19097 }
19098
19099
19100 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19101 PyObject *resultobj;
19102 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19103 bool result;
19104 PyObject * obj0 = 0 ;
19105 char *kwnames[] = {
19106 (char *) "self", NULL
19107 };
19108
19109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19111 if (SWIG_arg_fail(1)) SWIG_fail;
19112 result = (bool) ((arg1)->m_scanCode);
19113
19114 {
19115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19116 }
19117 return resultobj;
19118 fail:
19119 return NULL;
19120 }
19121
19122
19123 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19124 PyObject *resultobj;
19125 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19126 unsigned int arg2 ;
19127 PyObject * obj0 = 0 ;
19128 PyObject * obj1 = 0 ;
19129 char *kwnames[] = {
19130 (char *) "self",(char *) "m_rawCode", NULL
19131 };
19132
19133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19135 if (SWIG_arg_fail(1)) SWIG_fail;
19136 {
19137 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19138 if (SWIG_arg_fail(2)) SWIG_fail;
19139 }
19140 if (arg1) (arg1)->m_rawCode = arg2;
19141
19142 Py_INCREF(Py_None); resultobj = Py_None;
19143 return resultobj;
19144 fail:
19145 return NULL;
19146 }
19147
19148
19149 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19150 PyObject *resultobj;
19151 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19152 unsigned int result;
19153 PyObject * obj0 = 0 ;
19154 char *kwnames[] = {
19155 (char *) "self", NULL
19156 };
19157
19158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19160 if (SWIG_arg_fail(1)) SWIG_fail;
19161 result = (unsigned int) ((arg1)->m_rawCode);
19162
19163 {
19164 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19165 }
19166 return resultobj;
19167 fail:
19168 return NULL;
19169 }
19170
19171
19172 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19173 PyObject *resultobj;
19174 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19175 unsigned int arg2 ;
19176 PyObject * obj0 = 0 ;
19177 PyObject * obj1 = 0 ;
19178 char *kwnames[] = {
19179 (char *) "self",(char *) "m_rawFlags", NULL
19180 };
19181
19182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19184 if (SWIG_arg_fail(1)) SWIG_fail;
19185 {
19186 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19187 if (SWIG_arg_fail(2)) SWIG_fail;
19188 }
19189 if (arg1) (arg1)->m_rawFlags = arg2;
19190
19191 Py_INCREF(Py_None); resultobj = Py_None;
19192 return resultobj;
19193 fail:
19194 return NULL;
19195 }
19196
19197
19198 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19199 PyObject *resultobj;
19200 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19201 unsigned int result;
19202 PyObject * obj0 = 0 ;
19203 char *kwnames[] = {
19204 (char *) "self", NULL
19205 };
19206
19207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19209 if (SWIG_arg_fail(1)) SWIG_fail;
19210 result = (unsigned int) ((arg1)->m_rawFlags);
19211
19212 {
19213 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19214 }
19215 return resultobj;
19216 fail:
19217 return NULL;
19218 }
19219
19220
19221 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19222 PyObject *obj;
19223 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19224 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19225 Py_INCREF(obj);
19226 return Py_BuildValue((char *)"");
19227 }
19228 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19229 PyObject *resultobj;
19230 wxSize const &arg1_defvalue = wxDefaultSize ;
19231 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19232 int arg2 = (int) 0 ;
19233 wxSizeEvent *result;
19234 wxSize temp1 ;
19235 PyObject * obj0 = 0 ;
19236 PyObject * obj1 = 0 ;
19237 char *kwnames[] = {
19238 (char *) "sz",(char *) "winid", NULL
19239 };
19240
19241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19242 if (obj0) {
19243 {
19244 arg1 = &temp1;
19245 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19246 }
19247 }
19248 if (obj1) {
19249 {
19250 arg2 = (int)(SWIG_As_int(obj1));
19251 if (SWIG_arg_fail(2)) SWIG_fail;
19252 }
19253 }
19254 {
19255 PyThreadState* __tstate = wxPyBeginAllowThreads();
19256 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19257
19258 wxPyEndAllowThreads(__tstate);
19259 if (PyErr_Occurred()) SWIG_fail;
19260 }
19261 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19262 return resultobj;
19263 fail:
19264 return NULL;
19265 }
19266
19267
19268 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19269 PyObject *resultobj;
19270 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19271 wxSize result;
19272 PyObject * obj0 = 0 ;
19273 char *kwnames[] = {
19274 (char *) "self", NULL
19275 };
19276
19277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19279 if (SWIG_arg_fail(1)) SWIG_fail;
19280 {
19281 PyThreadState* __tstate = wxPyBeginAllowThreads();
19282 result = ((wxSizeEvent const *)arg1)->GetSize();
19283
19284 wxPyEndAllowThreads(__tstate);
19285 if (PyErr_Occurred()) SWIG_fail;
19286 }
19287 {
19288 wxSize * resultptr;
19289 resultptr = new wxSize((wxSize &)(result));
19290 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19291 }
19292 return resultobj;
19293 fail:
19294 return NULL;
19295 }
19296
19297
19298 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19299 PyObject *resultobj;
19300 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19301 wxRect result;
19302 PyObject * obj0 = 0 ;
19303 char *kwnames[] = {
19304 (char *) "self", NULL
19305 };
19306
19307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19309 if (SWIG_arg_fail(1)) SWIG_fail;
19310 {
19311 PyThreadState* __tstate = wxPyBeginAllowThreads();
19312 result = ((wxSizeEvent const *)arg1)->GetRect();
19313
19314 wxPyEndAllowThreads(__tstate);
19315 if (PyErr_Occurred()) SWIG_fail;
19316 }
19317 {
19318 wxRect * resultptr;
19319 resultptr = new wxRect((wxRect &)(result));
19320 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19321 }
19322 return resultobj;
19323 fail:
19324 return NULL;
19325 }
19326
19327
19328 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19329 PyObject *resultobj;
19330 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19331 wxRect arg2 ;
19332 PyObject * obj0 = 0 ;
19333 PyObject * obj1 = 0 ;
19334 char *kwnames[] = {
19335 (char *) "self",(char *) "rect", NULL
19336 };
19337
19338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19340 if (SWIG_arg_fail(1)) SWIG_fail;
19341 {
19342 wxRect * argp;
19343 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19344 if (SWIG_arg_fail(2)) SWIG_fail;
19345 if (argp == NULL) {
19346 SWIG_null_ref("wxRect");
19347 }
19348 if (SWIG_arg_fail(2)) SWIG_fail;
19349 arg2 = *argp;
19350 }
19351 {
19352 PyThreadState* __tstate = wxPyBeginAllowThreads();
19353 (arg1)->SetRect(arg2);
19354
19355 wxPyEndAllowThreads(__tstate);
19356 if (PyErr_Occurred()) SWIG_fail;
19357 }
19358 Py_INCREF(Py_None); resultobj = Py_None;
19359 return resultobj;
19360 fail:
19361 return NULL;
19362 }
19363
19364
19365 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19366 PyObject *resultobj;
19367 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19368 wxSize arg2 ;
19369 PyObject * obj0 = 0 ;
19370 PyObject * obj1 = 0 ;
19371 char *kwnames[] = {
19372 (char *) "self",(char *) "size", NULL
19373 };
19374
19375 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19376 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19377 if (SWIG_arg_fail(1)) SWIG_fail;
19378 {
19379 wxSize * argp;
19380 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19381 if (SWIG_arg_fail(2)) SWIG_fail;
19382 if (argp == NULL) {
19383 SWIG_null_ref("wxSize");
19384 }
19385 if (SWIG_arg_fail(2)) SWIG_fail;
19386 arg2 = *argp;
19387 }
19388 {
19389 PyThreadState* __tstate = wxPyBeginAllowThreads();
19390 wxSizeEvent_SetSize(arg1,arg2);
19391
19392 wxPyEndAllowThreads(__tstate);
19393 if (PyErr_Occurred()) SWIG_fail;
19394 }
19395 Py_INCREF(Py_None); resultobj = Py_None;
19396 return resultobj;
19397 fail:
19398 return NULL;
19399 }
19400
19401
19402 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
19403 PyObject *resultobj;
19404 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19405 wxSize *arg2 = (wxSize *) 0 ;
19406 PyObject * obj0 = 0 ;
19407 PyObject * obj1 = 0 ;
19408 char *kwnames[] = {
19409 (char *) "self",(char *) "m_size", NULL
19410 };
19411
19412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
19413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19414 if (SWIG_arg_fail(1)) SWIG_fail;
19415 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
19416 if (SWIG_arg_fail(2)) SWIG_fail;
19417 if (arg1) (arg1)->m_size = *arg2;
19418
19419 Py_INCREF(Py_None); resultobj = Py_None;
19420 return resultobj;
19421 fail:
19422 return NULL;
19423 }
19424
19425
19426 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19427 PyObject *resultobj;
19428 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19429 wxSize *result;
19430 PyObject * obj0 = 0 ;
19431 char *kwnames[] = {
19432 (char *) "self", NULL
19433 };
19434
19435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19437 if (SWIG_arg_fail(1)) SWIG_fail;
19438 result = (wxSize *)& ((arg1)->m_size);
19439
19440 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19441 return resultobj;
19442 fail:
19443 return NULL;
19444 }
19445
19446
19447 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19448 PyObject *resultobj;
19449 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19450 wxRect *arg2 = (wxRect *) 0 ;
19451 PyObject * obj0 = 0 ;
19452 PyObject * obj1 = 0 ;
19453 char *kwnames[] = {
19454 (char *) "self",(char *) "m_rect", NULL
19455 };
19456
19457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19459 if (SWIG_arg_fail(1)) SWIG_fail;
19460 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19461 if (SWIG_arg_fail(2)) SWIG_fail;
19462 if (arg1) (arg1)->m_rect = *arg2;
19463
19464 Py_INCREF(Py_None); resultobj = Py_None;
19465 return resultobj;
19466 fail:
19467 return NULL;
19468 }
19469
19470
19471 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19472 PyObject *resultobj;
19473 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19474 wxRect *result;
19475 PyObject * obj0 = 0 ;
19476 char *kwnames[] = {
19477 (char *) "self", NULL
19478 };
19479
19480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19482 if (SWIG_arg_fail(1)) SWIG_fail;
19483 result = (wxRect *)& ((arg1)->m_rect);
19484
19485 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19486 return resultobj;
19487 fail:
19488 return NULL;
19489 }
19490
19491
19492 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19493 PyObject *obj;
19494 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19495 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19496 Py_INCREF(obj);
19497 return Py_BuildValue((char *)"");
19498 }
19499 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19500 PyObject *resultobj;
19501 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19502 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19503 int arg2 = (int) 0 ;
19504 wxMoveEvent *result;
19505 wxPoint temp1 ;
19506 PyObject * obj0 = 0 ;
19507 PyObject * obj1 = 0 ;
19508 char *kwnames[] = {
19509 (char *) "pos",(char *) "winid", NULL
19510 };
19511
19512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19513 if (obj0) {
19514 {
19515 arg1 = &temp1;
19516 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19517 }
19518 }
19519 if (obj1) {
19520 {
19521 arg2 = (int)(SWIG_As_int(obj1));
19522 if (SWIG_arg_fail(2)) SWIG_fail;
19523 }
19524 }
19525 {
19526 PyThreadState* __tstate = wxPyBeginAllowThreads();
19527 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19528
19529 wxPyEndAllowThreads(__tstate);
19530 if (PyErr_Occurred()) SWIG_fail;
19531 }
19532 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19533 return resultobj;
19534 fail:
19535 return NULL;
19536 }
19537
19538
19539 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19540 PyObject *resultobj;
19541 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19542 wxPoint result;
19543 PyObject * obj0 = 0 ;
19544 char *kwnames[] = {
19545 (char *) "self", NULL
19546 };
19547
19548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19550 if (SWIG_arg_fail(1)) SWIG_fail;
19551 {
19552 PyThreadState* __tstate = wxPyBeginAllowThreads();
19553 result = ((wxMoveEvent const *)arg1)->GetPosition();
19554
19555 wxPyEndAllowThreads(__tstate);
19556 if (PyErr_Occurred()) SWIG_fail;
19557 }
19558 {
19559 wxPoint * resultptr;
19560 resultptr = new wxPoint((wxPoint &)(result));
19561 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19562 }
19563 return resultobj;
19564 fail:
19565 return NULL;
19566 }
19567
19568
19569 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19570 PyObject *resultobj;
19571 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19572 wxRect result;
19573 PyObject * obj0 = 0 ;
19574 char *kwnames[] = {
19575 (char *) "self", NULL
19576 };
19577
19578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19580 if (SWIG_arg_fail(1)) SWIG_fail;
19581 {
19582 PyThreadState* __tstate = wxPyBeginAllowThreads();
19583 result = ((wxMoveEvent const *)arg1)->GetRect();
19584
19585 wxPyEndAllowThreads(__tstate);
19586 if (PyErr_Occurred()) SWIG_fail;
19587 }
19588 {
19589 wxRect * resultptr;
19590 resultptr = new wxRect((wxRect &)(result));
19591 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19592 }
19593 return resultobj;
19594 fail:
19595 return NULL;
19596 }
19597
19598
19599 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19600 PyObject *resultobj;
19601 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19602 wxRect *arg2 = 0 ;
19603 wxRect temp2 ;
19604 PyObject * obj0 = 0 ;
19605 PyObject * obj1 = 0 ;
19606 char *kwnames[] = {
19607 (char *) "self",(char *) "rect", NULL
19608 };
19609
19610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19612 if (SWIG_arg_fail(1)) SWIG_fail;
19613 {
19614 arg2 = &temp2;
19615 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19616 }
19617 {
19618 PyThreadState* __tstate = wxPyBeginAllowThreads();
19619 (arg1)->SetRect((wxRect const &)*arg2);
19620
19621 wxPyEndAllowThreads(__tstate);
19622 if (PyErr_Occurred()) SWIG_fail;
19623 }
19624 Py_INCREF(Py_None); resultobj = Py_None;
19625 return resultobj;
19626 fail:
19627 return NULL;
19628 }
19629
19630
19631 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19632 PyObject *resultobj;
19633 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19634 wxPoint *arg2 = 0 ;
19635 wxPoint temp2 ;
19636 PyObject * obj0 = 0 ;
19637 PyObject * obj1 = 0 ;
19638 char *kwnames[] = {
19639 (char *) "self",(char *) "pos", NULL
19640 };
19641
19642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19644 if (SWIG_arg_fail(1)) SWIG_fail;
19645 {
19646 arg2 = &temp2;
19647 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19648 }
19649 {
19650 PyThreadState* __tstate = wxPyBeginAllowThreads();
19651 (arg1)->SetPosition((wxPoint const &)*arg2);
19652
19653 wxPyEndAllowThreads(__tstate);
19654 if (PyErr_Occurred()) SWIG_fail;
19655 }
19656 Py_INCREF(Py_None); resultobj = Py_None;
19657 return resultobj;
19658 fail:
19659 return NULL;
19660 }
19661
19662
19663 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19664 PyObject *obj;
19665 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19666 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19667 Py_INCREF(obj);
19668 return Py_BuildValue((char *)"");
19669 }
19670 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19671 PyObject *resultobj;
19672 int arg1 = (int) 0 ;
19673 wxPaintEvent *result;
19674 PyObject * obj0 = 0 ;
19675 char *kwnames[] = {
19676 (char *) "Id", NULL
19677 };
19678
19679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19680 if (obj0) {
19681 {
19682 arg1 = (int)(SWIG_As_int(obj0));
19683 if (SWIG_arg_fail(1)) SWIG_fail;
19684 }
19685 }
19686 {
19687 PyThreadState* __tstate = wxPyBeginAllowThreads();
19688 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19689
19690 wxPyEndAllowThreads(__tstate);
19691 if (PyErr_Occurred()) SWIG_fail;
19692 }
19693 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19694 return resultobj;
19695 fail:
19696 return NULL;
19697 }
19698
19699
19700 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19701 PyObject *obj;
19702 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19703 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19704 Py_INCREF(obj);
19705 return Py_BuildValue((char *)"");
19706 }
19707 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19708 PyObject *resultobj;
19709 int arg1 = (int) 0 ;
19710 wxNcPaintEvent *result;
19711 PyObject * obj0 = 0 ;
19712 char *kwnames[] = {
19713 (char *) "winid", NULL
19714 };
19715
19716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19717 if (obj0) {
19718 {
19719 arg1 = (int)(SWIG_As_int(obj0));
19720 if (SWIG_arg_fail(1)) SWIG_fail;
19721 }
19722 }
19723 {
19724 PyThreadState* __tstate = wxPyBeginAllowThreads();
19725 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19726
19727 wxPyEndAllowThreads(__tstate);
19728 if (PyErr_Occurred()) SWIG_fail;
19729 }
19730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19731 return resultobj;
19732 fail:
19733 return NULL;
19734 }
19735
19736
19737 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19738 PyObject *obj;
19739 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19740 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19741 Py_INCREF(obj);
19742 return Py_BuildValue((char *)"");
19743 }
19744 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19745 PyObject *resultobj;
19746 int arg1 = (int) 0 ;
19747 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19748 wxEraseEvent *result;
19749 PyObject * obj0 = 0 ;
19750 PyObject * obj1 = 0 ;
19751 char *kwnames[] = {
19752 (char *) "Id",(char *) "dc", NULL
19753 };
19754
19755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19756 if (obj0) {
19757 {
19758 arg1 = (int)(SWIG_As_int(obj0));
19759 if (SWIG_arg_fail(1)) SWIG_fail;
19760 }
19761 }
19762 if (obj1) {
19763 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19764 if (SWIG_arg_fail(2)) SWIG_fail;
19765 }
19766 {
19767 PyThreadState* __tstate = wxPyBeginAllowThreads();
19768 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19769
19770 wxPyEndAllowThreads(__tstate);
19771 if (PyErr_Occurred()) SWIG_fail;
19772 }
19773 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19774 return resultobj;
19775 fail:
19776 return NULL;
19777 }
19778
19779
19780 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19781 PyObject *resultobj;
19782 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19783 wxDC *result;
19784 PyObject * obj0 = 0 ;
19785 char *kwnames[] = {
19786 (char *) "self", NULL
19787 };
19788
19789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19791 if (SWIG_arg_fail(1)) SWIG_fail;
19792 {
19793 PyThreadState* __tstate = wxPyBeginAllowThreads();
19794 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19795
19796 wxPyEndAllowThreads(__tstate);
19797 if (PyErr_Occurred()) SWIG_fail;
19798 }
19799 {
19800 resultobj = wxPyMake_wxObject(result, 0);
19801 }
19802 return resultobj;
19803 fail:
19804 return NULL;
19805 }
19806
19807
19808 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19809 PyObject *obj;
19810 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19811 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19812 Py_INCREF(obj);
19813 return Py_BuildValue((char *)"");
19814 }
19815 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19816 PyObject *resultobj;
19817 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19818 int arg2 = (int) 0 ;
19819 wxFocusEvent *result;
19820 PyObject * obj0 = 0 ;
19821 PyObject * obj1 = 0 ;
19822 char *kwnames[] = {
19823 (char *) "type",(char *) "winid", NULL
19824 };
19825
19826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19827 if (obj0) {
19828 {
19829 arg1 = (wxEventType)(SWIG_As_int(obj0));
19830 if (SWIG_arg_fail(1)) SWIG_fail;
19831 }
19832 }
19833 if (obj1) {
19834 {
19835 arg2 = (int)(SWIG_As_int(obj1));
19836 if (SWIG_arg_fail(2)) SWIG_fail;
19837 }
19838 }
19839 {
19840 PyThreadState* __tstate = wxPyBeginAllowThreads();
19841 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19842
19843 wxPyEndAllowThreads(__tstate);
19844 if (PyErr_Occurred()) SWIG_fail;
19845 }
19846 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19847 return resultobj;
19848 fail:
19849 return NULL;
19850 }
19851
19852
19853 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19854 PyObject *resultobj;
19855 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19856 wxWindow *result;
19857 PyObject * obj0 = 0 ;
19858 char *kwnames[] = {
19859 (char *) "self", NULL
19860 };
19861
19862 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19864 if (SWIG_arg_fail(1)) SWIG_fail;
19865 {
19866 PyThreadState* __tstate = wxPyBeginAllowThreads();
19867 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19868
19869 wxPyEndAllowThreads(__tstate);
19870 if (PyErr_Occurred()) SWIG_fail;
19871 }
19872 {
19873 resultobj = wxPyMake_wxObject(result, 0);
19874 }
19875 return resultobj;
19876 fail:
19877 return NULL;
19878 }
19879
19880
19881 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19882 PyObject *resultobj;
19883 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19884 wxWindow *arg2 = (wxWindow *) 0 ;
19885 PyObject * obj0 = 0 ;
19886 PyObject * obj1 = 0 ;
19887 char *kwnames[] = {
19888 (char *) "self",(char *) "win", NULL
19889 };
19890
19891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19893 if (SWIG_arg_fail(1)) SWIG_fail;
19894 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19895 if (SWIG_arg_fail(2)) SWIG_fail;
19896 {
19897 PyThreadState* __tstate = wxPyBeginAllowThreads();
19898 (arg1)->SetWindow(arg2);
19899
19900 wxPyEndAllowThreads(__tstate);
19901 if (PyErr_Occurred()) SWIG_fail;
19902 }
19903 Py_INCREF(Py_None); resultobj = Py_None;
19904 return resultobj;
19905 fail:
19906 return NULL;
19907 }
19908
19909
19910 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19911 PyObject *obj;
19912 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19913 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19914 Py_INCREF(obj);
19915 return Py_BuildValue((char *)"");
19916 }
19917 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19918 PyObject *resultobj;
19919 wxWindow *arg1 = (wxWindow *) NULL ;
19920 wxChildFocusEvent *result;
19921 PyObject * obj0 = 0 ;
19922 char *kwnames[] = {
19923 (char *) "win", NULL
19924 };
19925
19926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19927 if (obj0) {
19928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19929 if (SWIG_arg_fail(1)) SWIG_fail;
19930 }
19931 {
19932 PyThreadState* __tstate = wxPyBeginAllowThreads();
19933 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19934
19935 wxPyEndAllowThreads(__tstate);
19936 if (PyErr_Occurred()) SWIG_fail;
19937 }
19938 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19939 return resultobj;
19940 fail:
19941 return NULL;
19942 }
19943
19944
19945 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19946 PyObject *resultobj;
19947 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19948 wxWindow *result;
19949 PyObject * obj0 = 0 ;
19950 char *kwnames[] = {
19951 (char *) "self", NULL
19952 };
19953
19954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19956 if (SWIG_arg_fail(1)) SWIG_fail;
19957 {
19958 PyThreadState* __tstate = wxPyBeginAllowThreads();
19959 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19960
19961 wxPyEndAllowThreads(__tstate);
19962 if (PyErr_Occurred()) SWIG_fail;
19963 }
19964 {
19965 resultobj = wxPyMake_wxObject(result, 0);
19966 }
19967 return resultobj;
19968 fail:
19969 return NULL;
19970 }
19971
19972
19973 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19974 PyObject *obj;
19975 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19976 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19977 Py_INCREF(obj);
19978 return Py_BuildValue((char *)"");
19979 }
19980 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19981 PyObject *resultobj;
19982 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19983 bool arg2 = (bool) true ;
19984 int arg3 = (int) 0 ;
19985 wxActivateEvent *result;
19986 PyObject * obj0 = 0 ;
19987 PyObject * obj1 = 0 ;
19988 PyObject * obj2 = 0 ;
19989 char *kwnames[] = {
19990 (char *) "type",(char *) "active",(char *) "Id", NULL
19991 };
19992
19993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19994 if (obj0) {
19995 {
19996 arg1 = (wxEventType)(SWIG_As_int(obj0));
19997 if (SWIG_arg_fail(1)) SWIG_fail;
19998 }
19999 }
20000 if (obj1) {
20001 {
20002 arg2 = (bool)(SWIG_As_bool(obj1));
20003 if (SWIG_arg_fail(2)) SWIG_fail;
20004 }
20005 }
20006 if (obj2) {
20007 {
20008 arg3 = (int)(SWIG_As_int(obj2));
20009 if (SWIG_arg_fail(3)) SWIG_fail;
20010 }
20011 }
20012 {
20013 PyThreadState* __tstate = wxPyBeginAllowThreads();
20014 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20015
20016 wxPyEndAllowThreads(__tstate);
20017 if (PyErr_Occurred()) SWIG_fail;
20018 }
20019 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20020 return resultobj;
20021 fail:
20022 return NULL;
20023 }
20024
20025
20026 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20027 PyObject *resultobj;
20028 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20029 bool result;
20030 PyObject * obj0 = 0 ;
20031 char *kwnames[] = {
20032 (char *) "self", NULL
20033 };
20034
20035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20037 if (SWIG_arg_fail(1)) SWIG_fail;
20038 {
20039 PyThreadState* __tstate = wxPyBeginAllowThreads();
20040 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20041
20042 wxPyEndAllowThreads(__tstate);
20043 if (PyErr_Occurred()) SWIG_fail;
20044 }
20045 {
20046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20047 }
20048 return resultobj;
20049 fail:
20050 return NULL;
20051 }
20052
20053
20054 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20055 PyObject *obj;
20056 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20057 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20058 Py_INCREF(obj);
20059 return Py_BuildValue((char *)"");
20060 }
20061 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20062 PyObject *resultobj;
20063 int arg1 = (int) 0 ;
20064 wxInitDialogEvent *result;
20065 PyObject * obj0 = 0 ;
20066 char *kwnames[] = {
20067 (char *) "Id", NULL
20068 };
20069
20070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20071 if (obj0) {
20072 {
20073 arg1 = (int)(SWIG_As_int(obj0));
20074 if (SWIG_arg_fail(1)) SWIG_fail;
20075 }
20076 }
20077 {
20078 PyThreadState* __tstate = wxPyBeginAllowThreads();
20079 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20080
20081 wxPyEndAllowThreads(__tstate);
20082 if (PyErr_Occurred()) SWIG_fail;
20083 }
20084 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20085 return resultobj;
20086 fail:
20087 return NULL;
20088 }
20089
20090
20091 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20092 PyObject *obj;
20093 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20094 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20095 Py_INCREF(obj);
20096 return Py_BuildValue((char *)"");
20097 }
20098 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20099 PyObject *resultobj;
20100 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20101 int arg2 = (int) 0 ;
20102 wxMenu *arg3 = (wxMenu *) NULL ;
20103 wxMenuEvent *result;
20104 PyObject * obj0 = 0 ;
20105 PyObject * obj1 = 0 ;
20106 PyObject * obj2 = 0 ;
20107 char *kwnames[] = {
20108 (char *) "type",(char *) "winid",(char *) "menu", NULL
20109 };
20110
20111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20112 if (obj0) {
20113 {
20114 arg1 = (wxEventType)(SWIG_As_int(obj0));
20115 if (SWIG_arg_fail(1)) SWIG_fail;
20116 }
20117 }
20118 if (obj1) {
20119 {
20120 arg2 = (int)(SWIG_As_int(obj1));
20121 if (SWIG_arg_fail(2)) SWIG_fail;
20122 }
20123 }
20124 if (obj2) {
20125 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20126 if (SWIG_arg_fail(3)) SWIG_fail;
20127 }
20128 {
20129 PyThreadState* __tstate = wxPyBeginAllowThreads();
20130 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20131
20132 wxPyEndAllowThreads(__tstate);
20133 if (PyErr_Occurred()) SWIG_fail;
20134 }
20135 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20136 return resultobj;
20137 fail:
20138 return NULL;
20139 }
20140
20141
20142 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20143 PyObject *resultobj;
20144 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20145 int result;
20146 PyObject * obj0 = 0 ;
20147 char *kwnames[] = {
20148 (char *) "self", NULL
20149 };
20150
20151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20152 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20153 if (SWIG_arg_fail(1)) SWIG_fail;
20154 {
20155 PyThreadState* __tstate = wxPyBeginAllowThreads();
20156 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20157
20158 wxPyEndAllowThreads(__tstate);
20159 if (PyErr_Occurred()) SWIG_fail;
20160 }
20161 {
20162 resultobj = SWIG_From_int((int)(result));
20163 }
20164 return resultobj;
20165 fail:
20166 return NULL;
20167 }
20168
20169
20170 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20171 PyObject *resultobj;
20172 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20173 bool result;
20174 PyObject * obj0 = 0 ;
20175 char *kwnames[] = {
20176 (char *) "self", NULL
20177 };
20178
20179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20181 if (SWIG_arg_fail(1)) SWIG_fail;
20182 {
20183 PyThreadState* __tstate = wxPyBeginAllowThreads();
20184 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20185
20186 wxPyEndAllowThreads(__tstate);
20187 if (PyErr_Occurred()) SWIG_fail;
20188 }
20189 {
20190 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20191 }
20192 return resultobj;
20193 fail:
20194 return NULL;
20195 }
20196
20197
20198 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20199 PyObject *resultobj;
20200 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20201 wxMenu *result;
20202 PyObject * obj0 = 0 ;
20203 char *kwnames[] = {
20204 (char *) "self", NULL
20205 };
20206
20207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20209 if (SWIG_arg_fail(1)) SWIG_fail;
20210 {
20211 PyThreadState* __tstate = wxPyBeginAllowThreads();
20212 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20213
20214 wxPyEndAllowThreads(__tstate);
20215 if (PyErr_Occurred()) SWIG_fail;
20216 }
20217 {
20218 resultobj = wxPyMake_wxObject(result, 0);
20219 }
20220 return resultobj;
20221 fail:
20222 return NULL;
20223 }
20224
20225
20226 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20227 PyObject *obj;
20228 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20229 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20230 Py_INCREF(obj);
20231 return Py_BuildValue((char *)"");
20232 }
20233 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20234 PyObject *resultobj;
20235 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20236 int arg2 = (int) 0 ;
20237 wxCloseEvent *result;
20238 PyObject * obj0 = 0 ;
20239 PyObject * obj1 = 0 ;
20240 char *kwnames[] = {
20241 (char *) "type",(char *) "winid", NULL
20242 };
20243
20244 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20245 if (obj0) {
20246 {
20247 arg1 = (wxEventType)(SWIG_As_int(obj0));
20248 if (SWIG_arg_fail(1)) SWIG_fail;
20249 }
20250 }
20251 if (obj1) {
20252 {
20253 arg2 = (int)(SWIG_As_int(obj1));
20254 if (SWIG_arg_fail(2)) SWIG_fail;
20255 }
20256 }
20257 {
20258 PyThreadState* __tstate = wxPyBeginAllowThreads();
20259 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20260
20261 wxPyEndAllowThreads(__tstate);
20262 if (PyErr_Occurred()) SWIG_fail;
20263 }
20264 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20265 return resultobj;
20266 fail:
20267 return NULL;
20268 }
20269
20270
20271 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20272 PyObject *resultobj;
20273 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20274 bool arg2 ;
20275 PyObject * obj0 = 0 ;
20276 PyObject * obj1 = 0 ;
20277 char *kwnames[] = {
20278 (char *) "self",(char *) "logOff", NULL
20279 };
20280
20281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20283 if (SWIG_arg_fail(1)) SWIG_fail;
20284 {
20285 arg2 = (bool)(SWIG_As_bool(obj1));
20286 if (SWIG_arg_fail(2)) SWIG_fail;
20287 }
20288 {
20289 PyThreadState* __tstate = wxPyBeginAllowThreads();
20290 (arg1)->SetLoggingOff(arg2);
20291
20292 wxPyEndAllowThreads(__tstate);
20293 if (PyErr_Occurred()) SWIG_fail;
20294 }
20295 Py_INCREF(Py_None); resultobj = Py_None;
20296 return resultobj;
20297 fail:
20298 return NULL;
20299 }
20300
20301
20302 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20303 PyObject *resultobj;
20304 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20305 bool result;
20306 PyObject * obj0 = 0 ;
20307 char *kwnames[] = {
20308 (char *) "self", NULL
20309 };
20310
20311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20313 if (SWIG_arg_fail(1)) SWIG_fail;
20314 {
20315 PyThreadState* __tstate = wxPyBeginAllowThreads();
20316 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20317
20318 wxPyEndAllowThreads(__tstate);
20319 if (PyErr_Occurred()) SWIG_fail;
20320 }
20321 {
20322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20323 }
20324 return resultobj;
20325 fail:
20326 return NULL;
20327 }
20328
20329
20330 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20331 PyObject *resultobj;
20332 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20333 bool arg2 = (bool) true ;
20334 PyObject * obj0 = 0 ;
20335 PyObject * obj1 = 0 ;
20336 char *kwnames[] = {
20337 (char *) "self",(char *) "veto", NULL
20338 };
20339
20340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20342 if (SWIG_arg_fail(1)) SWIG_fail;
20343 if (obj1) {
20344 {
20345 arg2 = (bool)(SWIG_As_bool(obj1));
20346 if (SWIG_arg_fail(2)) SWIG_fail;
20347 }
20348 }
20349 {
20350 PyThreadState* __tstate = wxPyBeginAllowThreads();
20351 (arg1)->Veto(arg2);
20352
20353 wxPyEndAllowThreads(__tstate);
20354 if (PyErr_Occurred()) SWIG_fail;
20355 }
20356 Py_INCREF(Py_None); resultobj = Py_None;
20357 return resultobj;
20358 fail:
20359 return NULL;
20360 }
20361
20362
20363 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20364 PyObject *resultobj;
20365 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20366 bool arg2 ;
20367 PyObject * obj0 = 0 ;
20368 PyObject * obj1 = 0 ;
20369 char *kwnames[] = {
20370 (char *) "self",(char *) "canVeto", NULL
20371 };
20372
20373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
20374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20375 if (SWIG_arg_fail(1)) SWIG_fail;
20376 {
20377 arg2 = (bool)(SWIG_As_bool(obj1));
20378 if (SWIG_arg_fail(2)) SWIG_fail;
20379 }
20380 {
20381 PyThreadState* __tstate = wxPyBeginAllowThreads();
20382 (arg1)->SetCanVeto(arg2);
20383
20384 wxPyEndAllowThreads(__tstate);
20385 if (PyErr_Occurred()) SWIG_fail;
20386 }
20387 Py_INCREF(Py_None); resultobj = Py_None;
20388 return resultobj;
20389 fail:
20390 return NULL;
20391 }
20392
20393
20394 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20395 PyObject *resultobj;
20396 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20397 bool result;
20398 PyObject * obj0 = 0 ;
20399 char *kwnames[] = {
20400 (char *) "self", NULL
20401 };
20402
20403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
20404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20405 if (SWIG_arg_fail(1)) SWIG_fail;
20406 {
20407 PyThreadState* __tstate = wxPyBeginAllowThreads();
20408 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
20409
20410 wxPyEndAllowThreads(__tstate);
20411 if (PyErr_Occurred()) SWIG_fail;
20412 }
20413 {
20414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20415 }
20416 return resultobj;
20417 fail:
20418 return NULL;
20419 }
20420
20421
20422 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20423 PyObject *resultobj;
20424 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20425 bool result;
20426 PyObject * obj0 = 0 ;
20427 char *kwnames[] = {
20428 (char *) "self", NULL
20429 };
20430
20431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20433 if (SWIG_arg_fail(1)) SWIG_fail;
20434 {
20435 PyThreadState* __tstate = wxPyBeginAllowThreads();
20436 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20437
20438 wxPyEndAllowThreads(__tstate);
20439 if (PyErr_Occurred()) SWIG_fail;
20440 }
20441 {
20442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20443 }
20444 return resultobj;
20445 fail:
20446 return NULL;
20447 }
20448
20449
20450 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20451 PyObject *obj;
20452 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20453 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20454 Py_INCREF(obj);
20455 return Py_BuildValue((char *)"");
20456 }
20457 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20458 PyObject *resultobj;
20459 int arg1 = (int) 0 ;
20460 bool arg2 = (bool) false ;
20461 wxShowEvent *result;
20462 PyObject * obj0 = 0 ;
20463 PyObject * obj1 = 0 ;
20464 char *kwnames[] = {
20465 (char *) "winid",(char *) "show", NULL
20466 };
20467
20468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20469 if (obj0) {
20470 {
20471 arg1 = (int)(SWIG_As_int(obj0));
20472 if (SWIG_arg_fail(1)) SWIG_fail;
20473 }
20474 }
20475 if (obj1) {
20476 {
20477 arg2 = (bool)(SWIG_As_bool(obj1));
20478 if (SWIG_arg_fail(2)) SWIG_fail;
20479 }
20480 }
20481 {
20482 PyThreadState* __tstate = wxPyBeginAllowThreads();
20483 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20484
20485 wxPyEndAllowThreads(__tstate);
20486 if (PyErr_Occurred()) SWIG_fail;
20487 }
20488 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20489 return resultobj;
20490 fail:
20491 return NULL;
20492 }
20493
20494
20495 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20496 PyObject *resultobj;
20497 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20498 bool arg2 ;
20499 PyObject * obj0 = 0 ;
20500 PyObject * obj1 = 0 ;
20501 char *kwnames[] = {
20502 (char *) "self",(char *) "show", NULL
20503 };
20504
20505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20507 if (SWIG_arg_fail(1)) SWIG_fail;
20508 {
20509 arg2 = (bool)(SWIG_As_bool(obj1));
20510 if (SWIG_arg_fail(2)) SWIG_fail;
20511 }
20512 {
20513 PyThreadState* __tstate = wxPyBeginAllowThreads();
20514 (arg1)->SetShow(arg2);
20515
20516 wxPyEndAllowThreads(__tstate);
20517 if (PyErr_Occurred()) SWIG_fail;
20518 }
20519 Py_INCREF(Py_None); resultobj = Py_None;
20520 return resultobj;
20521 fail:
20522 return NULL;
20523 }
20524
20525
20526 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20527 PyObject *resultobj;
20528 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20529 bool result;
20530 PyObject * obj0 = 0 ;
20531 char *kwnames[] = {
20532 (char *) "self", NULL
20533 };
20534
20535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20537 if (SWIG_arg_fail(1)) SWIG_fail;
20538 {
20539 PyThreadState* __tstate = wxPyBeginAllowThreads();
20540 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20541
20542 wxPyEndAllowThreads(__tstate);
20543 if (PyErr_Occurred()) SWIG_fail;
20544 }
20545 {
20546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20547 }
20548 return resultobj;
20549 fail:
20550 return NULL;
20551 }
20552
20553
20554 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20555 PyObject *obj;
20556 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20557 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20558 Py_INCREF(obj);
20559 return Py_BuildValue((char *)"");
20560 }
20561 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20562 PyObject *resultobj;
20563 int arg1 = (int) 0 ;
20564 bool arg2 = (bool) true ;
20565 wxIconizeEvent *result;
20566 PyObject * obj0 = 0 ;
20567 PyObject * obj1 = 0 ;
20568 char *kwnames[] = {
20569 (char *) "id",(char *) "iconized", NULL
20570 };
20571
20572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20573 if (obj0) {
20574 {
20575 arg1 = (int)(SWIG_As_int(obj0));
20576 if (SWIG_arg_fail(1)) SWIG_fail;
20577 }
20578 }
20579 if (obj1) {
20580 {
20581 arg2 = (bool)(SWIG_As_bool(obj1));
20582 if (SWIG_arg_fail(2)) SWIG_fail;
20583 }
20584 }
20585 {
20586 PyThreadState* __tstate = wxPyBeginAllowThreads();
20587 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20588
20589 wxPyEndAllowThreads(__tstate);
20590 if (PyErr_Occurred()) SWIG_fail;
20591 }
20592 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20593 return resultobj;
20594 fail:
20595 return NULL;
20596 }
20597
20598
20599 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20600 PyObject *resultobj;
20601 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20602 bool result;
20603 PyObject * obj0 = 0 ;
20604 char *kwnames[] = {
20605 (char *) "self", NULL
20606 };
20607
20608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20610 if (SWIG_arg_fail(1)) SWIG_fail;
20611 {
20612 PyThreadState* __tstate = wxPyBeginAllowThreads();
20613 result = (bool)(arg1)->Iconized();
20614
20615 wxPyEndAllowThreads(__tstate);
20616 if (PyErr_Occurred()) SWIG_fail;
20617 }
20618 {
20619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20620 }
20621 return resultobj;
20622 fail:
20623 return NULL;
20624 }
20625
20626
20627 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20628 PyObject *obj;
20629 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20630 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20631 Py_INCREF(obj);
20632 return Py_BuildValue((char *)"");
20633 }
20634 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20635 PyObject *resultobj;
20636 int arg1 = (int) 0 ;
20637 wxMaximizeEvent *result;
20638 PyObject * obj0 = 0 ;
20639 char *kwnames[] = {
20640 (char *) "id", NULL
20641 };
20642
20643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20644 if (obj0) {
20645 {
20646 arg1 = (int)(SWIG_As_int(obj0));
20647 if (SWIG_arg_fail(1)) SWIG_fail;
20648 }
20649 }
20650 {
20651 PyThreadState* __tstate = wxPyBeginAllowThreads();
20652 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20653
20654 wxPyEndAllowThreads(__tstate);
20655 if (PyErr_Occurred()) SWIG_fail;
20656 }
20657 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20658 return resultobj;
20659 fail:
20660 return NULL;
20661 }
20662
20663
20664 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20665 PyObject *obj;
20666 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20667 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20668 Py_INCREF(obj);
20669 return Py_BuildValue((char *)"");
20670 }
20671 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20672 PyObject *resultobj;
20673 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20674 wxPoint result;
20675 PyObject * obj0 = 0 ;
20676 char *kwnames[] = {
20677 (char *) "self", NULL
20678 };
20679
20680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20682 if (SWIG_arg_fail(1)) SWIG_fail;
20683 {
20684 PyThreadState* __tstate = wxPyBeginAllowThreads();
20685 result = (arg1)->GetPosition();
20686
20687 wxPyEndAllowThreads(__tstate);
20688 if (PyErr_Occurred()) SWIG_fail;
20689 }
20690 {
20691 wxPoint * resultptr;
20692 resultptr = new wxPoint((wxPoint &)(result));
20693 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20694 }
20695 return resultobj;
20696 fail:
20697 return NULL;
20698 }
20699
20700
20701 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20702 PyObject *resultobj;
20703 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20704 int result;
20705 PyObject * obj0 = 0 ;
20706 char *kwnames[] = {
20707 (char *) "self", NULL
20708 };
20709
20710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20712 if (SWIG_arg_fail(1)) SWIG_fail;
20713 {
20714 PyThreadState* __tstate = wxPyBeginAllowThreads();
20715 result = (int)(arg1)->GetNumberOfFiles();
20716
20717 wxPyEndAllowThreads(__tstate);
20718 if (PyErr_Occurred()) SWIG_fail;
20719 }
20720 {
20721 resultobj = SWIG_From_int((int)(result));
20722 }
20723 return resultobj;
20724 fail:
20725 return NULL;
20726 }
20727
20728
20729 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20730 PyObject *resultobj;
20731 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20732 PyObject *result;
20733 PyObject * obj0 = 0 ;
20734 char *kwnames[] = {
20735 (char *) "self", NULL
20736 };
20737
20738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20740 if (SWIG_arg_fail(1)) SWIG_fail;
20741 {
20742 PyThreadState* __tstate = wxPyBeginAllowThreads();
20743 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20744
20745 wxPyEndAllowThreads(__tstate);
20746 if (PyErr_Occurred()) SWIG_fail;
20747 }
20748 resultobj = result;
20749 return resultobj;
20750 fail:
20751 return NULL;
20752 }
20753
20754
20755 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20756 PyObject *obj;
20757 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20758 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20759 Py_INCREF(obj);
20760 return Py_BuildValue((char *)"");
20761 }
20762 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20763 PyObject *resultobj;
20764 int arg1 = (int) 0 ;
20765 wxUpdateUIEvent *result;
20766 PyObject * obj0 = 0 ;
20767 char *kwnames[] = {
20768 (char *) "commandId", NULL
20769 };
20770
20771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20772 if (obj0) {
20773 {
20774 arg1 = (int)(SWIG_As_int(obj0));
20775 if (SWIG_arg_fail(1)) SWIG_fail;
20776 }
20777 }
20778 {
20779 PyThreadState* __tstate = wxPyBeginAllowThreads();
20780 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20781
20782 wxPyEndAllowThreads(__tstate);
20783 if (PyErr_Occurred()) SWIG_fail;
20784 }
20785 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20786 return resultobj;
20787 fail:
20788 return NULL;
20789 }
20790
20791
20792 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20793 PyObject *resultobj;
20794 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20795 bool result;
20796 PyObject * obj0 = 0 ;
20797 char *kwnames[] = {
20798 (char *) "self", NULL
20799 };
20800
20801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20803 if (SWIG_arg_fail(1)) SWIG_fail;
20804 {
20805 PyThreadState* __tstate = wxPyBeginAllowThreads();
20806 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20807
20808 wxPyEndAllowThreads(__tstate);
20809 if (PyErr_Occurred()) SWIG_fail;
20810 }
20811 {
20812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20813 }
20814 return resultobj;
20815 fail:
20816 return NULL;
20817 }
20818
20819
20820 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20821 PyObject *resultobj;
20822 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20823 bool result;
20824 PyObject * obj0 = 0 ;
20825 char *kwnames[] = {
20826 (char *) "self", NULL
20827 };
20828
20829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20831 if (SWIG_arg_fail(1)) SWIG_fail;
20832 {
20833 PyThreadState* __tstate = wxPyBeginAllowThreads();
20834 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20835
20836 wxPyEndAllowThreads(__tstate);
20837 if (PyErr_Occurred()) SWIG_fail;
20838 }
20839 {
20840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20841 }
20842 return resultobj;
20843 fail:
20844 return NULL;
20845 }
20846
20847
20848 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20849 PyObject *resultobj;
20850 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20851 wxString result;
20852 PyObject * obj0 = 0 ;
20853 char *kwnames[] = {
20854 (char *) "self", NULL
20855 };
20856
20857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20859 if (SWIG_arg_fail(1)) SWIG_fail;
20860 {
20861 PyThreadState* __tstate = wxPyBeginAllowThreads();
20862 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20863
20864 wxPyEndAllowThreads(__tstate);
20865 if (PyErr_Occurred()) SWIG_fail;
20866 }
20867 {
20868 #if wxUSE_UNICODE
20869 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20870 #else
20871 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20872 #endif
20873 }
20874 return resultobj;
20875 fail:
20876 return NULL;
20877 }
20878
20879
20880 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20881 PyObject *resultobj;
20882 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20883 bool result;
20884 PyObject * obj0 = 0 ;
20885 char *kwnames[] = {
20886 (char *) "self", NULL
20887 };
20888
20889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20891 if (SWIG_arg_fail(1)) SWIG_fail;
20892 {
20893 PyThreadState* __tstate = wxPyBeginAllowThreads();
20894 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20895
20896 wxPyEndAllowThreads(__tstate);
20897 if (PyErr_Occurred()) SWIG_fail;
20898 }
20899 {
20900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20901 }
20902 return resultobj;
20903 fail:
20904 return NULL;
20905 }
20906
20907
20908 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20909 PyObject *resultobj;
20910 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20911 bool result;
20912 PyObject * obj0 = 0 ;
20913 char *kwnames[] = {
20914 (char *) "self", NULL
20915 };
20916
20917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20919 if (SWIG_arg_fail(1)) SWIG_fail;
20920 {
20921 PyThreadState* __tstate = wxPyBeginAllowThreads();
20922 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20923
20924 wxPyEndAllowThreads(__tstate);
20925 if (PyErr_Occurred()) SWIG_fail;
20926 }
20927 {
20928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20929 }
20930 return resultobj;
20931 fail:
20932 return NULL;
20933 }
20934
20935
20936 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20937 PyObject *resultobj;
20938 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20939 bool result;
20940 PyObject * obj0 = 0 ;
20941 char *kwnames[] = {
20942 (char *) "self", NULL
20943 };
20944
20945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20947 if (SWIG_arg_fail(1)) SWIG_fail;
20948 {
20949 PyThreadState* __tstate = wxPyBeginAllowThreads();
20950 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20951
20952 wxPyEndAllowThreads(__tstate);
20953 if (PyErr_Occurred()) SWIG_fail;
20954 }
20955 {
20956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20957 }
20958 return resultobj;
20959 fail:
20960 return NULL;
20961 }
20962
20963
20964 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20965 PyObject *resultobj;
20966 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20967 bool arg2 ;
20968 PyObject * obj0 = 0 ;
20969 PyObject * obj1 = 0 ;
20970 char *kwnames[] = {
20971 (char *) "self",(char *) "check", NULL
20972 };
20973
20974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20976 if (SWIG_arg_fail(1)) SWIG_fail;
20977 {
20978 arg2 = (bool)(SWIG_As_bool(obj1));
20979 if (SWIG_arg_fail(2)) SWIG_fail;
20980 }
20981 {
20982 PyThreadState* __tstate = wxPyBeginAllowThreads();
20983 (arg1)->Check(arg2);
20984
20985 wxPyEndAllowThreads(__tstate);
20986 if (PyErr_Occurred()) SWIG_fail;
20987 }
20988 Py_INCREF(Py_None); resultobj = Py_None;
20989 return resultobj;
20990 fail:
20991 return NULL;
20992 }
20993
20994
20995 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20996 PyObject *resultobj;
20997 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20998 bool arg2 ;
20999 PyObject * obj0 = 0 ;
21000 PyObject * obj1 = 0 ;
21001 char *kwnames[] = {
21002 (char *) "self",(char *) "enable", NULL
21003 };
21004
21005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21007 if (SWIG_arg_fail(1)) SWIG_fail;
21008 {
21009 arg2 = (bool)(SWIG_As_bool(obj1));
21010 if (SWIG_arg_fail(2)) SWIG_fail;
21011 }
21012 {
21013 PyThreadState* __tstate = wxPyBeginAllowThreads();
21014 (arg1)->Enable(arg2);
21015
21016 wxPyEndAllowThreads(__tstate);
21017 if (PyErr_Occurred()) SWIG_fail;
21018 }
21019 Py_INCREF(Py_None); resultobj = Py_None;
21020 return resultobj;
21021 fail:
21022 return NULL;
21023 }
21024
21025
21026 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21027 PyObject *resultobj;
21028 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21029 wxString *arg2 = 0 ;
21030 bool temp2 = false ;
21031 PyObject * obj0 = 0 ;
21032 PyObject * obj1 = 0 ;
21033 char *kwnames[] = {
21034 (char *) "self",(char *) "text", NULL
21035 };
21036
21037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21039 if (SWIG_arg_fail(1)) SWIG_fail;
21040 {
21041 arg2 = wxString_in_helper(obj1);
21042 if (arg2 == NULL) SWIG_fail;
21043 temp2 = true;
21044 }
21045 {
21046 PyThreadState* __tstate = wxPyBeginAllowThreads();
21047 (arg1)->SetText((wxString const &)*arg2);
21048
21049 wxPyEndAllowThreads(__tstate);
21050 if (PyErr_Occurred()) SWIG_fail;
21051 }
21052 Py_INCREF(Py_None); resultobj = Py_None;
21053 {
21054 if (temp2)
21055 delete arg2;
21056 }
21057 return resultobj;
21058 fail:
21059 {
21060 if (temp2)
21061 delete arg2;
21062 }
21063 return NULL;
21064 }
21065
21066
21067 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21068 PyObject *resultobj;
21069 long arg1 ;
21070 PyObject * obj0 = 0 ;
21071 char *kwnames[] = {
21072 (char *) "updateInterval", NULL
21073 };
21074
21075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21076 {
21077 arg1 = (long)(SWIG_As_long(obj0));
21078 if (SWIG_arg_fail(1)) SWIG_fail;
21079 }
21080 {
21081 PyThreadState* __tstate = wxPyBeginAllowThreads();
21082 wxUpdateUIEvent::SetUpdateInterval(arg1);
21083
21084 wxPyEndAllowThreads(__tstate);
21085 if (PyErr_Occurred()) SWIG_fail;
21086 }
21087 Py_INCREF(Py_None); resultobj = Py_None;
21088 return resultobj;
21089 fail:
21090 return NULL;
21091 }
21092
21093
21094 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21095 PyObject *resultobj;
21096 long result;
21097 char *kwnames[] = {
21098 NULL
21099 };
21100
21101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21102 {
21103 PyThreadState* __tstate = wxPyBeginAllowThreads();
21104 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21105
21106 wxPyEndAllowThreads(__tstate);
21107 if (PyErr_Occurred()) SWIG_fail;
21108 }
21109 {
21110 resultobj = SWIG_From_long((long)(result));
21111 }
21112 return resultobj;
21113 fail:
21114 return NULL;
21115 }
21116
21117
21118 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21119 PyObject *resultobj;
21120 wxWindow *arg1 = (wxWindow *) 0 ;
21121 bool result;
21122 PyObject * obj0 = 0 ;
21123 char *kwnames[] = {
21124 (char *) "win", NULL
21125 };
21126
21127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21129 if (SWIG_arg_fail(1)) SWIG_fail;
21130 {
21131 PyThreadState* __tstate = wxPyBeginAllowThreads();
21132 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21133
21134 wxPyEndAllowThreads(__tstate);
21135 if (PyErr_Occurred()) SWIG_fail;
21136 }
21137 {
21138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21139 }
21140 return resultobj;
21141 fail:
21142 return NULL;
21143 }
21144
21145
21146 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21147 PyObject *resultobj;
21148 char *kwnames[] = {
21149 NULL
21150 };
21151
21152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21153 {
21154 PyThreadState* __tstate = wxPyBeginAllowThreads();
21155 wxUpdateUIEvent::ResetUpdateTime();
21156
21157 wxPyEndAllowThreads(__tstate);
21158 if (PyErr_Occurred()) SWIG_fail;
21159 }
21160 Py_INCREF(Py_None); resultobj = Py_None;
21161 return resultobj;
21162 fail:
21163 return NULL;
21164 }
21165
21166
21167 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21168 PyObject *resultobj;
21169 wxUpdateUIMode arg1 ;
21170 PyObject * obj0 = 0 ;
21171 char *kwnames[] = {
21172 (char *) "mode", NULL
21173 };
21174
21175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21176 {
21177 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21178 if (SWIG_arg_fail(1)) SWIG_fail;
21179 }
21180 {
21181 PyThreadState* __tstate = wxPyBeginAllowThreads();
21182 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21183
21184 wxPyEndAllowThreads(__tstate);
21185 if (PyErr_Occurred()) SWIG_fail;
21186 }
21187 Py_INCREF(Py_None); resultobj = Py_None;
21188 return resultobj;
21189 fail:
21190 return NULL;
21191 }
21192
21193
21194 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21195 PyObject *resultobj;
21196 wxUpdateUIMode result;
21197 char *kwnames[] = {
21198 NULL
21199 };
21200
21201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21202 {
21203 PyThreadState* __tstate = wxPyBeginAllowThreads();
21204 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21205
21206 wxPyEndAllowThreads(__tstate);
21207 if (PyErr_Occurred()) SWIG_fail;
21208 }
21209 resultobj = SWIG_From_int((result));
21210 return resultobj;
21211 fail:
21212 return NULL;
21213 }
21214
21215
21216 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21217 PyObject *obj;
21218 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21219 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21220 Py_INCREF(obj);
21221 return Py_BuildValue((char *)"");
21222 }
21223 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21224 PyObject *resultobj;
21225 wxSysColourChangedEvent *result;
21226 char *kwnames[] = {
21227 NULL
21228 };
21229
21230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21231 {
21232 PyThreadState* __tstate = wxPyBeginAllowThreads();
21233 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21234
21235 wxPyEndAllowThreads(__tstate);
21236 if (PyErr_Occurred()) SWIG_fail;
21237 }
21238 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21239 return resultobj;
21240 fail:
21241 return NULL;
21242 }
21243
21244
21245 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21246 PyObject *obj;
21247 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21248 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21249 Py_INCREF(obj);
21250 return Py_BuildValue((char *)"");
21251 }
21252 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21253 PyObject *resultobj;
21254 int arg1 = (int) 0 ;
21255 wxWindow *arg2 = (wxWindow *) NULL ;
21256 wxMouseCaptureChangedEvent *result;
21257 PyObject * obj0 = 0 ;
21258 PyObject * obj1 = 0 ;
21259 char *kwnames[] = {
21260 (char *) "winid",(char *) "gainedCapture", NULL
21261 };
21262
21263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21264 if (obj0) {
21265 {
21266 arg1 = (int)(SWIG_As_int(obj0));
21267 if (SWIG_arg_fail(1)) SWIG_fail;
21268 }
21269 }
21270 if (obj1) {
21271 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21272 if (SWIG_arg_fail(2)) SWIG_fail;
21273 }
21274 {
21275 PyThreadState* __tstate = wxPyBeginAllowThreads();
21276 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21277
21278 wxPyEndAllowThreads(__tstate);
21279 if (PyErr_Occurred()) SWIG_fail;
21280 }
21281 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21282 return resultobj;
21283 fail:
21284 return NULL;
21285 }
21286
21287
21288 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21289 PyObject *resultobj;
21290 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21291 wxWindow *result;
21292 PyObject * obj0 = 0 ;
21293 char *kwnames[] = {
21294 (char *) "self", NULL
21295 };
21296
21297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21299 if (SWIG_arg_fail(1)) SWIG_fail;
21300 {
21301 PyThreadState* __tstate = wxPyBeginAllowThreads();
21302 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21303
21304 wxPyEndAllowThreads(__tstate);
21305 if (PyErr_Occurred()) SWIG_fail;
21306 }
21307 {
21308 resultobj = wxPyMake_wxObject(result, 0);
21309 }
21310 return resultobj;
21311 fail:
21312 return NULL;
21313 }
21314
21315
21316 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21317 PyObject *obj;
21318 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21319 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21320 Py_INCREF(obj);
21321 return Py_BuildValue((char *)"");
21322 }
21323 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21324 PyObject *resultobj;
21325 wxDisplayChangedEvent *result;
21326 char *kwnames[] = {
21327 NULL
21328 };
21329
21330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21331 {
21332 PyThreadState* __tstate = wxPyBeginAllowThreads();
21333 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21334
21335 wxPyEndAllowThreads(__tstate);
21336 if (PyErr_Occurred()) SWIG_fail;
21337 }
21338 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21339 return resultobj;
21340 fail:
21341 return NULL;
21342 }
21343
21344
21345 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21346 PyObject *obj;
21347 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21348 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21349 Py_INCREF(obj);
21350 return Py_BuildValue((char *)"");
21351 }
21352 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21353 PyObject *resultobj;
21354 int arg1 = (int) 0 ;
21355 wxPaletteChangedEvent *result;
21356 PyObject * obj0 = 0 ;
21357 char *kwnames[] = {
21358 (char *) "id", NULL
21359 };
21360
21361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21362 if (obj0) {
21363 {
21364 arg1 = (int)(SWIG_As_int(obj0));
21365 if (SWIG_arg_fail(1)) SWIG_fail;
21366 }
21367 }
21368 {
21369 PyThreadState* __tstate = wxPyBeginAllowThreads();
21370 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21371
21372 wxPyEndAllowThreads(__tstate);
21373 if (PyErr_Occurred()) SWIG_fail;
21374 }
21375 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21376 return resultobj;
21377 fail:
21378 return NULL;
21379 }
21380
21381
21382 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21383 PyObject *resultobj;
21384 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21385 wxWindow *arg2 = (wxWindow *) 0 ;
21386 PyObject * obj0 = 0 ;
21387 PyObject * obj1 = 0 ;
21388 char *kwnames[] = {
21389 (char *) "self",(char *) "win", NULL
21390 };
21391
21392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
21393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21394 if (SWIG_arg_fail(1)) SWIG_fail;
21395 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21396 if (SWIG_arg_fail(2)) SWIG_fail;
21397 {
21398 PyThreadState* __tstate = wxPyBeginAllowThreads();
21399 (arg1)->SetChangedWindow(arg2);
21400
21401 wxPyEndAllowThreads(__tstate);
21402 if (PyErr_Occurred()) SWIG_fail;
21403 }
21404 Py_INCREF(Py_None); resultobj = Py_None;
21405 return resultobj;
21406 fail:
21407 return NULL;
21408 }
21409
21410
21411 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21412 PyObject *resultobj;
21413 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21414 wxWindow *result;
21415 PyObject * obj0 = 0 ;
21416 char *kwnames[] = {
21417 (char *) "self", NULL
21418 };
21419
21420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21422 if (SWIG_arg_fail(1)) SWIG_fail;
21423 {
21424 PyThreadState* __tstate = wxPyBeginAllowThreads();
21425 result = (wxWindow *)(arg1)->GetChangedWindow();
21426
21427 wxPyEndAllowThreads(__tstate);
21428 if (PyErr_Occurred()) SWIG_fail;
21429 }
21430 {
21431 resultobj = wxPyMake_wxObject(result, 0);
21432 }
21433 return resultobj;
21434 fail:
21435 return NULL;
21436 }
21437
21438
21439 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21440 PyObject *obj;
21441 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21442 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21443 Py_INCREF(obj);
21444 return Py_BuildValue((char *)"");
21445 }
21446 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21447 PyObject *resultobj;
21448 int arg1 = (int) 0 ;
21449 wxQueryNewPaletteEvent *result;
21450 PyObject * obj0 = 0 ;
21451 char *kwnames[] = {
21452 (char *) "winid", NULL
21453 };
21454
21455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21456 if (obj0) {
21457 {
21458 arg1 = (int)(SWIG_As_int(obj0));
21459 if (SWIG_arg_fail(1)) SWIG_fail;
21460 }
21461 }
21462 {
21463 PyThreadState* __tstate = wxPyBeginAllowThreads();
21464 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21465
21466 wxPyEndAllowThreads(__tstate);
21467 if (PyErr_Occurred()) SWIG_fail;
21468 }
21469 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21470 return resultobj;
21471 fail:
21472 return NULL;
21473 }
21474
21475
21476 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21477 PyObject *resultobj;
21478 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21479 bool arg2 ;
21480 PyObject * obj0 = 0 ;
21481 PyObject * obj1 = 0 ;
21482 char *kwnames[] = {
21483 (char *) "self",(char *) "realized", NULL
21484 };
21485
21486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21488 if (SWIG_arg_fail(1)) SWIG_fail;
21489 {
21490 arg2 = (bool)(SWIG_As_bool(obj1));
21491 if (SWIG_arg_fail(2)) SWIG_fail;
21492 }
21493 {
21494 PyThreadState* __tstate = wxPyBeginAllowThreads();
21495 (arg1)->SetPaletteRealized(arg2);
21496
21497 wxPyEndAllowThreads(__tstate);
21498 if (PyErr_Occurred()) SWIG_fail;
21499 }
21500 Py_INCREF(Py_None); resultobj = Py_None;
21501 return resultobj;
21502 fail:
21503 return NULL;
21504 }
21505
21506
21507 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21508 PyObject *resultobj;
21509 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21510 bool result;
21511 PyObject * obj0 = 0 ;
21512 char *kwnames[] = {
21513 (char *) "self", NULL
21514 };
21515
21516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21518 if (SWIG_arg_fail(1)) SWIG_fail;
21519 {
21520 PyThreadState* __tstate = wxPyBeginAllowThreads();
21521 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21522
21523 wxPyEndAllowThreads(__tstate);
21524 if (PyErr_Occurred()) SWIG_fail;
21525 }
21526 {
21527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21528 }
21529 return resultobj;
21530 fail:
21531 return NULL;
21532 }
21533
21534
21535 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21536 PyObject *obj;
21537 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21538 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21539 Py_INCREF(obj);
21540 return Py_BuildValue((char *)"");
21541 }
21542 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21543 PyObject *resultobj;
21544 wxNavigationKeyEvent *result;
21545 char *kwnames[] = {
21546 NULL
21547 };
21548
21549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21550 {
21551 PyThreadState* __tstate = wxPyBeginAllowThreads();
21552 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21553
21554 wxPyEndAllowThreads(__tstate);
21555 if (PyErr_Occurred()) SWIG_fail;
21556 }
21557 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21558 return resultobj;
21559 fail:
21560 return NULL;
21561 }
21562
21563
21564 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21565 PyObject *resultobj;
21566 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21567 bool result;
21568 PyObject * obj0 = 0 ;
21569 char *kwnames[] = {
21570 (char *) "self", NULL
21571 };
21572
21573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21575 if (SWIG_arg_fail(1)) SWIG_fail;
21576 {
21577 PyThreadState* __tstate = wxPyBeginAllowThreads();
21578 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21579
21580 wxPyEndAllowThreads(__tstate);
21581 if (PyErr_Occurred()) SWIG_fail;
21582 }
21583 {
21584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21585 }
21586 return resultobj;
21587 fail:
21588 return NULL;
21589 }
21590
21591
21592 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21593 PyObject *resultobj;
21594 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21595 bool arg2 ;
21596 PyObject * obj0 = 0 ;
21597 PyObject * obj1 = 0 ;
21598 char *kwnames[] = {
21599 (char *) "self",(char *) "forward", NULL
21600 };
21601
21602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21604 if (SWIG_arg_fail(1)) SWIG_fail;
21605 {
21606 arg2 = (bool)(SWIG_As_bool(obj1));
21607 if (SWIG_arg_fail(2)) SWIG_fail;
21608 }
21609 {
21610 PyThreadState* __tstate = wxPyBeginAllowThreads();
21611 (arg1)->SetDirection(arg2);
21612
21613 wxPyEndAllowThreads(__tstate);
21614 if (PyErr_Occurred()) SWIG_fail;
21615 }
21616 Py_INCREF(Py_None); resultobj = Py_None;
21617 return resultobj;
21618 fail:
21619 return NULL;
21620 }
21621
21622
21623 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21624 PyObject *resultobj;
21625 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21626 bool result;
21627 PyObject * obj0 = 0 ;
21628 char *kwnames[] = {
21629 (char *) "self", NULL
21630 };
21631
21632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21634 if (SWIG_arg_fail(1)) SWIG_fail;
21635 {
21636 PyThreadState* __tstate = wxPyBeginAllowThreads();
21637 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21638
21639 wxPyEndAllowThreads(__tstate);
21640 if (PyErr_Occurred()) SWIG_fail;
21641 }
21642 {
21643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21644 }
21645 return resultobj;
21646 fail:
21647 return NULL;
21648 }
21649
21650
21651 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21652 PyObject *resultobj;
21653 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21654 bool arg2 ;
21655 PyObject * obj0 = 0 ;
21656 PyObject * obj1 = 0 ;
21657 char *kwnames[] = {
21658 (char *) "self",(char *) "ischange", NULL
21659 };
21660
21661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21663 if (SWIG_arg_fail(1)) SWIG_fail;
21664 {
21665 arg2 = (bool)(SWIG_As_bool(obj1));
21666 if (SWIG_arg_fail(2)) SWIG_fail;
21667 }
21668 {
21669 PyThreadState* __tstate = wxPyBeginAllowThreads();
21670 (arg1)->SetWindowChange(arg2);
21671
21672 wxPyEndAllowThreads(__tstate);
21673 if (PyErr_Occurred()) SWIG_fail;
21674 }
21675 Py_INCREF(Py_None); resultobj = Py_None;
21676 return resultobj;
21677 fail:
21678 return NULL;
21679 }
21680
21681
21682 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21683 PyObject *resultobj;
21684 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21685 bool result;
21686 PyObject * obj0 = 0 ;
21687 char *kwnames[] = {
21688 (char *) "self", NULL
21689 };
21690
21691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21693 if (SWIG_arg_fail(1)) SWIG_fail;
21694 {
21695 PyThreadState* __tstate = wxPyBeginAllowThreads();
21696 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21697
21698 wxPyEndAllowThreads(__tstate);
21699 if (PyErr_Occurred()) SWIG_fail;
21700 }
21701 {
21702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21703 }
21704 return resultobj;
21705 fail:
21706 return NULL;
21707 }
21708
21709
21710 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21711 PyObject *resultobj;
21712 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21713 bool arg2 ;
21714 PyObject * obj0 = 0 ;
21715 PyObject * obj1 = 0 ;
21716 char *kwnames[] = {
21717 (char *) "self",(char *) "bIs", NULL
21718 };
21719
21720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21722 if (SWIG_arg_fail(1)) SWIG_fail;
21723 {
21724 arg2 = (bool)(SWIG_As_bool(obj1));
21725 if (SWIG_arg_fail(2)) SWIG_fail;
21726 }
21727 {
21728 PyThreadState* __tstate = wxPyBeginAllowThreads();
21729 (arg1)->SetFromTab(arg2);
21730
21731 wxPyEndAllowThreads(__tstate);
21732 if (PyErr_Occurred()) SWIG_fail;
21733 }
21734 Py_INCREF(Py_None); resultobj = Py_None;
21735 return resultobj;
21736 fail:
21737 return NULL;
21738 }
21739
21740
21741 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21742 PyObject *resultobj;
21743 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21744 long arg2 ;
21745 PyObject * obj0 = 0 ;
21746 PyObject * obj1 = 0 ;
21747 char *kwnames[] = {
21748 (char *) "self",(char *) "flags", NULL
21749 };
21750
21751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21753 if (SWIG_arg_fail(1)) SWIG_fail;
21754 {
21755 arg2 = (long)(SWIG_As_long(obj1));
21756 if (SWIG_arg_fail(2)) SWIG_fail;
21757 }
21758 {
21759 PyThreadState* __tstate = wxPyBeginAllowThreads();
21760 (arg1)->SetFlags(arg2);
21761
21762 wxPyEndAllowThreads(__tstate);
21763 if (PyErr_Occurred()) SWIG_fail;
21764 }
21765 Py_INCREF(Py_None); resultobj = Py_None;
21766 return resultobj;
21767 fail:
21768 return NULL;
21769 }
21770
21771
21772 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21773 PyObject *resultobj;
21774 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21775 wxWindow *result;
21776 PyObject * obj0 = 0 ;
21777 char *kwnames[] = {
21778 (char *) "self", NULL
21779 };
21780
21781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21783 if (SWIG_arg_fail(1)) SWIG_fail;
21784 {
21785 PyThreadState* __tstate = wxPyBeginAllowThreads();
21786 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21787
21788 wxPyEndAllowThreads(__tstate);
21789 if (PyErr_Occurred()) SWIG_fail;
21790 }
21791 {
21792 resultobj = wxPyMake_wxObject(result, 0);
21793 }
21794 return resultobj;
21795 fail:
21796 return NULL;
21797 }
21798
21799
21800 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21801 PyObject *resultobj;
21802 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21803 wxWindow *arg2 = (wxWindow *) 0 ;
21804 PyObject * obj0 = 0 ;
21805 PyObject * obj1 = 0 ;
21806 char *kwnames[] = {
21807 (char *) "self",(char *) "win", NULL
21808 };
21809
21810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21812 if (SWIG_arg_fail(1)) SWIG_fail;
21813 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21814 if (SWIG_arg_fail(2)) SWIG_fail;
21815 {
21816 PyThreadState* __tstate = wxPyBeginAllowThreads();
21817 (arg1)->SetCurrentFocus(arg2);
21818
21819 wxPyEndAllowThreads(__tstate);
21820 if (PyErr_Occurred()) SWIG_fail;
21821 }
21822 Py_INCREF(Py_None); resultobj = Py_None;
21823 return resultobj;
21824 fail:
21825 return NULL;
21826 }
21827
21828
21829 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21830 PyObject *obj;
21831 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21832 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21833 Py_INCREF(obj);
21834 return Py_BuildValue((char *)"");
21835 }
21836 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21837 PyObject *resultobj;
21838 wxWindow *arg1 = (wxWindow *) NULL ;
21839 wxWindowCreateEvent *result;
21840 PyObject * obj0 = 0 ;
21841 char *kwnames[] = {
21842 (char *) "win", NULL
21843 };
21844
21845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21846 if (obj0) {
21847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21848 if (SWIG_arg_fail(1)) SWIG_fail;
21849 }
21850 {
21851 PyThreadState* __tstate = wxPyBeginAllowThreads();
21852 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21853
21854 wxPyEndAllowThreads(__tstate);
21855 if (PyErr_Occurred()) SWIG_fail;
21856 }
21857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21858 return resultobj;
21859 fail:
21860 return NULL;
21861 }
21862
21863
21864 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21865 PyObject *resultobj;
21866 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21867 wxWindow *result;
21868 PyObject * obj0 = 0 ;
21869 char *kwnames[] = {
21870 (char *) "self", NULL
21871 };
21872
21873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21875 if (SWIG_arg_fail(1)) SWIG_fail;
21876 {
21877 PyThreadState* __tstate = wxPyBeginAllowThreads();
21878 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21879
21880 wxPyEndAllowThreads(__tstate);
21881 if (PyErr_Occurred()) SWIG_fail;
21882 }
21883 {
21884 resultobj = wxPyMake_wxObject(result, 0);
21885 }
21886 return resultobj;
21887 fail:
21888 return NULL;
21889 }
21890
21891
21892 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21893 PyObject *obj;
21894 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21895 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21896 Py_INCREF(obj);
21897 return Py_BuildValue((char *)"");
21898 }
21899 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21900 PyObject *resultobj;
21901 wxWindow *arg1 = (wxWindow *) NULL ;
21902 wxWindowDestroyEvent *result;
21903 PyObject * obj0 = 0 ;
21904 char *kwnames[] = {
21905 (char *) "win", NULL
21906 };
21907
21908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21909 if (obj0) {
21910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21911 if (SWIG_arg_fail(1)) SWIG_fail;
21912 }
21913 {
21914 PyThreadState* __tstate = wxPyBeginAllowThreads();
21915 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21916
21917 wxPyEndAllowThreads(__tstate);
21918 if (PyErr_Occurred()) SWIG_fail;
21919 }
21920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21921 return resultobj;
21922 fail:
21923 return NULL;
21924 }
21925
21926
21927 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21928 PyObject *resultobj;
21929 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21930 wxWindow *result;
21931 PyObject * obj0 = 0 ;
21932 char *kwnames[] = {
21933 (char *) "self", NULL
21934 };
21935
21936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21938 if (SWIG_arg_fail(1)) SWIG_fail;
21939 {
21940 PyThreadState* __tstate = wxPyBeginAllowThreads();
21941 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21942
21943 wxPyEndAllowThreads(__tstate);
21944 if (PyErr_Occurred()) SWIG_fail;
21945 }
21946 {
21947 resultobj = wxPyMake_wxObject(result, 0);
21948 }
21949 return resultobj;
21950 fail:
21951 return NULL;
21952 }
21953
21954
21955 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21956 PyObject *obj;
21957 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21958 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21959 Py_INCREF(obj);
21960 return Py_BuildValue((char *)"");
21961 }
21962 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21963 PyObject *resultobj;
21964 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21965 int arg2 = (int) 0 ;
21966 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21967 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21968 wxContextMenuEvent *result;
21969 wxPoint temp3 ;
21970 PyObject * obj0 = 0 ;
21971 PyObject * obj1 = 0 ;
21972 PyObject * obj2 = 0 ;
21973 char *kwnames[] = {
21974 (char *) "type",(char *) "winid",(char *) "pt", NULL
21975 };
21976
21977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21978 if (obj0) {
21979 {
21980 arg1 = (wxEventType)(SWIG_As_int(obj0));
21981 if (SWIG_arg_fail(1)) SWIG_fail;
21982 }
21983 }
21984 if (obj1) {
21985 {
21986 arg2 = (int)(SWIG_As_int(obj1));
21987 if (SWIG_arg_fail(2)) SWIG_fail;
21988 }
21989 }
21990 if (obj2) {
21991 {
21992 arg3 = &temp3;
21993 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21994 }
21995 }
21996 {
21997 PyThreadState* __tstate = wxPyBeginAllowThreads();
21998 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21999
22000 wxPyEndAllowThreads(__tstate);
22001 if (PyErr_Occurred()) SWIG_fail;
22002 }
22003 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22004 return resultobj;
22005 fail:
22006 return NULL;
22007 }
22008
22009
22010 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22011 PyObject *resultobj;
22012 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22013 wxPoint *result;
22014 PyObject * obj0 = 0 ;
22015 char *kwnames[] = {
22016 (char *) "self", NULL
22017 };
22018
22019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22021 if (SWIG_arg_fail(1)) SWIG_fail;
22022 {
22023 PyThreadState* __tstate = wxPyBeginAllowThreads();
22024 {
22025 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22026 result = (wxPoint *) &_result_ref;
22027 }
22028
22029 wxPyEndAllowThreads(__tstate);
22030 if (PyErr_Occurred()) SWIG_fail;
22031 }
22032 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22033 return resultobj;
22034 fail:
22035 return NULL;
22036 }
22037
22038
22039 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22040 PyObject *resultobj;
22041 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22042 wxPoint *arg2 = 0 ;
22043 wxPoint temp2 ;
22044 PyObject * obj0 = 0 ;
22045 PyObject * obj1 = 0 ;
22046 char *kwnames[] = {
22047 (char *) "self",(char *) "pos", NULL
22048 };
22049
22050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22052 if (SWIG_arg_fail(1)) SWIG_fail;
22053 {
22054 arg2 = &temp2;
22055 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22056 }
22057 {
22058 PyThreadState* __tstate = wxPyBeginAllowThreads();
22059 (arg1)->SetPosition((wxPoint const &)*arg2);
22060
22061 wxPyEndAllowThreads(__tstate);
22062 if (PyErr_Occurred()) SWIG_fail;
22063 }
22064 Py_INCREF(Py_None); resultobj = Py_None;
22065 return resultobj;
22066 fail:
22067 return NULL;
22068 }
22069
22070
22071 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22072 PyObject *obj;
22073 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22074 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22075 Py_INCREF(obj);
22076 return Py_BuildValue((char *)"");
22077 }
22078 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22079 PyObject *resultobj;
22080 wxIdleEvent *result;
22081 char *kwnames[] = {
22082 NULL
22083 };
22084
22085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22086 {
22087 PyThreadState* __tstate = wxPyBeginAllowThreads();
22088 result = (wxIdleEvent *)new wxIdleEvent();
22089
22090 wxPyEndAllowThreads(__tstate);
22091 if (PyErr_Occurred()) SWIG_fail;
22092 }
22093 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22094 return resultobj;
22095 fail:
22096 return NULL;
22097 }
22098
22099
22100 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22101 PyObject *resultobj;
22102 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22103 bool arg2 = (bool) true ;
22104 PyObject * obj0 = 0 ;
22105 PyObject * obj1 = 0 ;
22106 char *kwnames[] = {
22107 (char *) "self",(char *) "needMore", NULL
22108 };
22109
22110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22112 if (SWIG_arg_fail(1)) SWIG_fail;
22113 if (obj1) {
22114 {
22115 arg2 = (bool)(SWIG_As_bool(obj1));
22116 if (SWIG_arg_fail(2)) SWIG_fail;
22117 }
22118 }
22119 {
22120 PyThreadState* __tstate = wxPyBeginAllowThreads();
22121 (arg1)->RequestMore(arg2);
22122
22123 wxPyEndAllowThreads(__tstate);
22124 if (PyErr_Occurred()) SWIG_fail;
22125 }
22126 Py_INCREF(Py_None); resultobj = Py_None;
22127 return resultobj;
22128 fail:
22129 return NULL;
22130 }
22131
22132
22133 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22134 PyObject *resultobj;
22135 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22136 bool result;
22137 PyObject * obj0 = 0 ;
22138 char *kwnames[] = {
22139 (char *) "self", NULL
22140 };
22141
22142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22144 if (SWIG_arg_fail(1)) SWIG_fail;
22145 {
22146 PyThreadState* __tstate = wxPyBeginAllowThreads();
22147 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22148
22149 wxPyEndAllowThreads(__tstate);
22150 if (PyErr_Occurred()) SWIG_fail;
22151 }
22152 {
22153 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22154 }
22155 return resultobj;
22156 fail:
22157 return NULL;
22158 }
22159
22160
22161 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22162 PyObject *resultobj;
22163 wxIdleMode arg1 ;
22164 PyObject * obj0 = 0 ;
22165 char *kwnames[] = {
22166 (char *) "mode", NULL
22167 };
22168
22169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22170 {
22171 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22172 if (SWIG_arg_fail(1)) SWIG_fail;
22173 }
22174 {
22175 PyThreadState* __tstate = wxPyBeginAllowThreads();
22176 wxIdleEvent::SetMode((wxIdleMode )arg1);
22177
22178 wxPyEndAllowThreads(__tstate);
22179 if (PyErr_Occurred()) SWIG_fail;
22180 }
22181 Py_INCREF(Py_None); resultobj = Py_None;
22182 return resultobj;
22183 fail:
22184 return NULL;
22185 }
22186
22187
22188 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22189 PyObject *resultobj;
22190 wxIdleMode result;
22191 char *kwnames[] = {
22192 NULL
22193 };
22194
22195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22196 {
22197 PyThreadState* __tstate = wxPyBeginAllowThreads();
22198 result = (wxIdleMode)wxIdleEvent::GetMode();
22199
22200 wxPyEndAllowThreads(__tstate);
22201 if (PyErr_Occurred()) SWIG_fail;
22202 }
22203 resultobj = SWIG_From_int((result));
22204 return resultobj;
22205 fail:
22206 return NULL;
22207 }
22208
22209
22210 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22211 PyObject *resultobj;
22212 wxWindow *arg1 = (wxWindow *) 0 ;
22213 bool result;
22214 PyObject * obj0 = 0 ;
22215 char *kwnames[] = {
22216 (char *) "win", NULL
22217 };
22218
22219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22221 if (SWIG_arg_fail(1)) SWIG_fail;
22222 {
22223 PyThreadState* __tstate = wxPyBeginAllowThreads();
22224 result = (bool)wxIdleEvent::CanSend(arg1);
22225
22226 wxPyEndAllowThreads(__tstate);
22227 if (PyErr_Occurred()) SWIG_fail;
22228 }
22229 {
22230 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22231 }
22232 return resultobj;
22233 fail:
22234 return NULL;
22235 }
22236
22237
22238 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22239 PyObject *obj;
22240 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22241 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22242 Py_INCREF(obj);
22243 return Py_BuildValue((char *)"");
22244 }
22245 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22246 PyObject *resultobj;
22247 int arg1 = (int) 0 ;
22248 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22249 wxPyEvent *result;
22250 PyObject * obj0 = 0 ;
22251 PyObject * obj1 = 0 ;
22252 char *kwnames[] = {
22253 (char *) "winid",(char *) "commandType", NULL
22254 };
22255
22256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22257 if (obj0) {
22258 {
22259 arg1 = (int)(SWIG_As_int(obj0));
22260 if (SWIG_arg_fail(1)) SWIG_fail;
22261 }
22262 }
22263 if (obj1) {
22264 {
22265 arg2 = (wxEventType)(SWIG_As_int(obj1));
22266 if (SWIG_arg_fail(2)) SWIG_fail;
22267 }
22268 }
22269 {
22270 PyThreadState* __tstate = wxPyBeginAllowThreads();
22271 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22272
22273 wxPyEndAllowThreads(__tstate);
22274 if (PyErr_Occurred()) SWIG_fail;
22275 }
22276 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22277 return resultobj;
22278 fail:
22279 return NULL;
22280 }
22281
22282
22283 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22284 PyObject *resultobj;
22285 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22286 PyObject * obj0 = 0 ;
22287 char *kwnames[] = {
22288 (char *) "self", NULL
22289 };
22290
22291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22293 if (SWIG_arg_fail(1)) SWIG_fail;
22294 {
22295 PyThreadState* __tstate = wxPyBeginAllowThreads();
22296 delete arg1;
22297
22298 wxPyEndAllowThreads(__tstate);
22299 if (PyErr_Occurred()) SWIG_fail;
22300 }
22301 Py_INCREF(Py_None); resultobj = Py_None;
22302 return resultobj;
22303 fail:
22304 return NULL;
22305 }
22306
22307
22308 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22309 PyObject *resultobj;
22310 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22311 PyObject *arg2 = (PyObject *) 0 ;
22312 PyObject * obj0 = 0 ;
22313 PyObject * obj1 = 0 ;
22314 char *kwnames[] = {
22315 (char *) "self",(char *) "self", NULL
22316 };
22317
22318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22320 if (SWIG_arg_fail(1)) SWIG_fail;
22321 arg2 = obj1;
22322 {
22323 PyThreadState* __tstate = wxPyBeginAllowThreads();
22324 (arg1)->SetSelf(arg2);
22325
22326 wxPyEndAllowThreads(__tstate);
22327 if (PyErr_Occurred()) SWIG_fail;
22328 }
22329 Py_INCREF(Py_None); resultobj = Py_None;
22330 return resultobj;
22331 fail:
22332 return NULL;
22333 }
22334
22335
22336 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22337 PyObject *resultobj;
22338 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22339 PyObject *result;
22340 PyObject * obj0 = 0 ;
22341 char *kwnames[] = {
22342 (char *) "self", NULL
22343 };
22344
22345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
22346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22347 if (SWIG_arg_fail(1)) SWIG_fail;
22348 {
22349 PyThreadState* __tstate = wxPyBeginAllowThreads();
22350 result = (PyObject *)(arg1)->GetSelf();
22351
22352 wxPyEndAllowThreads(__tstate);
22353 if (PyErr_Occurred()) SWIG_fail;
22354 }
22355 resultobj = result;
22356 return resultobj;
22357 fail:
22358 return NULL;
22359 }
22360
22361
22362 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22363 PyObject *obj;
22364 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22365 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22366 Py_INCREF(obj);
22367 return Py_BuildValue((char *)"");
22368 }
22369 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22370 PyObject *resultobj;
22371 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22372 int arg2 = (int) 0 ;
22373 wxPyCommandEvent *result;
22374 PyObject * obj0 = 0 ;
22375 PyObject * obj1 = 0 ;
22376 char *kwnames[] = {
22377 (char *) "commandType",(char *) "id", NULL
22378 };
22379
22380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22381 if (obj0) {
22382 {
22383 arg1 = (wxEventType)(SWIG_As_int(obj0));
22384 if (SWIG_arg_fail(1)) SWIG_fail;
22385 }
22386 }
22387 if (obj1) {
22388 {
22389 arg2 = (int)(SWIG_As_int(obj1));
22390 if (SWIG_arg_fail(2)) SWIG_fail;
22391 }
22392 }
22393 {
22394 PyThreadState* __tstate = wxPyBeginAllowThreads();
22395 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
22396
22397 wxPyEndAllowThreads(__tstate);
22398 if (PyErr_Occurred()) SWIG_fail;
22399 }
22400 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
22401 return resultobj;
22402 fail:
22403 return NULL;
22404 }
22405
22406
22407 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22408 PyObject *resultobj;
22409 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22410 PyObject * obj0 = 0 ;
22411 char *kwnames[] = {
22412 (char *) "self", NULL
22413 };
22414
22415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
22416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22417 if (SWIG_arg_fail(1)) SWIG_fail;
22418 {
22419 PyThreadState* __tstate = wxPyBeginAllowThreads();
22420 delete arg1;
22421
22422 wxPyEndAllowThreads(__tstate);
22423 if (PyErr_Occurred()) SWIG_fail;
22424 }
22425 Py_INCREF(Py_None); resultobj = Py_None;
22426 return resultobj;
22427 fail:
22428 return NULL;
22429 }
22430
22431
22432 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22433 PyObject *resultobj;
22434 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22435 PyObject *arg2 = (PyObject *) 0 ;
22436 PyObject * obj0 = 0 ;
22437 PyObject * obj1 = 0 ;
22438 char *kwnames[] = {
22439 (char *) "self",(char *) "self", NULL
22440 };
22441
22442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22444 if (SWIG_arg_fail(1)) SWIG_fail;
22445 arg2 = obj1;
22446 {
22447 PyThreadState* __tstate = wxPyBeginAllowThreads();
22448 (arg1)->SetSelf(arg2);
22449
22450 wxPyEndAllowThreads(__tstate);
22451 if (PyErr_Occurred()) SWIG_fail;
22452 }
22453 Py_INCREF(Py_None); resultobj = Py_None;
22454 return resultobj;
22455 fail:
22456 return NULL;
22457 }
22458
22459
22460 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22461 PyObject *resultobj;
22462 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22463 PyObject *result;
22464 PyObject * obj0 = 0 ;
22465 char *kwnames[] = {
22466 (char *) "self", NULL
22467 };
22468
22469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
22470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22471 if (SWIG_arg_fail(1)) SWIG_fail;
22472 {
22473 PyThreadState* __tstate = wxPyBeginAllowThreads();
22474 result = (PyObject *)(arg1)->GetSelf();
22475
22476 wxPyEndAllowThreads(__tstate);
22477 if (PyErr_Occurred()) SWIG_fail;
22478 }
22479 resultobj = result;
22480 return resultobj;
22481 fail:
22482 return NULL;
22483 }
22484
22485
22486 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22487 PyObject *obj;
22488 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22489 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22490 Py_INCREF(obj);
22491 return Py_BuildValue((char *)"");
22492 }
22493 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22494 PyObject *resultobj;
22495 wxWindow *arg1 = (wxWindow *) 0 ;
22496 wxDateTime *arg2 = 0 ;
22497 wxEventType arg3 ;
22498 wxDateEvent *result;
22499 PyObject * obj0 = 0 ;
22500 PyObject * obj1 = 0 ;
22501 PyObject * obj2 = 0 ;
22502 char *kwnames[] = {
22503 (char *) "win",(char *) "dt",(char *) "type", NULL
22504 };
22505
22506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22508 if (SWIG_arg_fail(1)) SWIG_fail;
22509 {
22510 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22511 if (SWIG_arg_fail(2)) SWIG_fail;
22512 if (arg2 == NULL) {
22513 SWIG_null_ref("wxDateTime");
22514 }
22515 if (SWIG_arg_fail(2)) SWIG_fail;
22516 }
22517 {
22518 arg3 = (wxEventType)(SWIG_As_int(obj2));
22519 if (SWIG_arg_fail(3)) SWIG_fail;
22520 }
22521 {
22522 PyThreadState* __tstate = wxPyBeginAllowThreads();
22523 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22524
22525 wxPyEndAllowThreads(__tstate);
22526 if (PyErr_Occurred()) SWIG_fail;
22527 }
22528 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22529 return resultobj;
22530 fail:
22531 return NULL;
22532 }
22533
22534
22535 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22536 PyObject *resultobj;
22537 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22538 wxDateTime *result;
22539 PyObject * obj0 = 0 ;
22540 char *kwnames[] = {
22541 (char *) "self", NULL
22542 };
22543
22544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22546 if (SWIG_arg_fail(1)) SWIG_fail;
22547 {
22548 PyThreadState* __tstate = wxPyBeginAllowThreads();
22549 {
22550 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22551 result = (wxDateTime *) &_result_ref;
22552 }
22553
22554 wxPyEndAllowThreads(__tstate);
22555 if (PyErr_Occurred()) SWIG_fail;
22556 }
22557 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22558 return resultobj;
22559 fail:
22560 return NULL;
22561 }
22562
22563
22564 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22565 PyObject *resultobj;
22566 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22567 wxDateTime *arg2 = 0 ;
22568 PyObject * obj0 = 0 ;
22569 PyObject * obj1 = 0 ;
22570 char *kwnames[] = {
22571 (char *) "self",(char *) "date", NULL
22572 };
22573
22574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22576 if (SWIG_arg_fail(1)) SWIG_fail;
22577 {
22578 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22579 if (SWIG_arg_fail(2)) SWIG_fail;
22580 if (arg2 == NULL) {
22581 SWIG_null_ref("wxDateTime");
22582 }
22583 if (SWIG_arg_fail(2)) SWIG_fail;
22584 }
22585 {
22586 PyThreadState* __tstate = wxPyBeginAllowThreads();
22587 (arg1)->SetDate((wxDateTime const &)*arg2);
22588
22589 wxPyEndAllowThreads(__tstate);
22590 if (PyErr_Occurred()) SWIG_fail;
22591 }
22592 Py_INCREF(Py_None); resultobj = Py_None;
22593 return resultobj;
22594 fail:
22595 return NULL;
22596 }
22597
22598
22599 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22600 PyObject *obj;
22601 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22602 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22603 Py_INCREF(obj);
22604 return Py_BuildValue((char *)"");
22605 }
22606 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22607 PyObject *resultobj;
22608 wxPyApp *result;
22609 char *kwnames[] = {
22610 NULL
22611 };
22612
22613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22614 {
22615 PyThreadState* __tstate = wxPyBeginAllowThreads();
22616 result = (wxPyApp *)new_wxPyApp();
22617
22618 wxPyEndAllowThreads(__tstate);
22619 if (PyErr_Occurred()) SWIG_fail;
22620 }
22621 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22622 return resultobj;
22623 fail:
22624 return NULL;
22625 }
22626
22627
22628 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22629 PyObject *resultobj;
22630 wxPyApp *arg1 = (wxPyApp *) 0 ;
22631 PyObject * obj0 = 0 ;
22632 char *kwnames[] = {
22633 (char *) "self", NULL
22634 };
22635
22636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22638 if (SWIG_arg_fail(1)) SWIG_fail;
22639 {
22640 PyThreadState* __tstate = wxPyBeginAllowThreads();
22641 delete arg1;
22642
22643 wxPyEndAllowThreads(__tstate);
22644 if (PyErr_Occurred()) SWIG_fail;
22645 }
22646 Py_INCREF(Py_None); resultobj = Py_None;
22647 return resultobj;
22648 fail:
22649 return NULL;
22650 }
22651
22652
22653 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22654 PyObject *resultobj;
22655 wxPyApp *arg1 = (wxPyApp *) 0 ;
22656 PyObject *arg2 = (PyObject *) 0 ;
22657 PyObject *arg3 = (PyObject *) 0 ;
22658 PyObject * obj0 = 0 ;
22659 PyObject * obj1 = 0 ;
22660 PyObject * obj2 = 0 ;
22661 char *kwnames[] = {
22662 (char *) "self",(char *) "self",(char *) "_class", NULL
22663 };
22664
22665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22667 if (SWIG_arg_fail(1)) SWIG_fail;
22668 arg2 = obj1;
22669 arg3 = obj2;
22670 {
22671 PyThreadState* __tstate = wxPyBeginAllowThreads();
22672 (arg1)->_setCallbackInfo(arg2,arg3);
22673
22674 wxPyEndAllowThreads(__tstate);
22675 if (PyErr_Occurred()) SWIG_fail;
22676 }
22677 Py_INCREF(Py_None); resultobj = Py_None;
22678 return resultobj;
22679 fail:
22680 return NULL;
22681 }
22682
22683
22684 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22685 PyObject *resultobj;
22686 wxPyApp *arg1 = (wxPyApp *) 0 ;
22687 wxString result;
22688 PyObject * obj0 = 0 ;
22689 char *kwnames[] = {
22690 (char *) "self", NULL
22691 };
22692
22693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22695 if (SWIG_arg_fail(1)) SWIG_fail;
22696 {
22697 PyThreadState* __tstate = wxPyBeginAllowThreads();
22698 result = ((wxPyApp const *)arg1)->GetAppName();
22699
22700 wxPyEndAllowThreads(__tstate);
22701 if (PyErr_Occurred()) SWIG_fail;
22702 }
22703 {
22704 #if wxUSE_UNICODE
22705 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22706 #else
22707 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22708 #endif
22709 }
22710 return resultobj;
22711 fail:
22712 return NULL;
22713 }
22714
22715
22716 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22717 PyObject *resultobj;
22718 wxPyApp *arg1 = (wxPyApp *) 0 ;
22719 wxString *arg2 = 0 ;
22720 bool temp2 = false ;
22721 PyObject * obj0 = 0 ;
22722 PyObject * obj1 = 0 ;
22723 char *kwnames[] = {
22724 (char *) "self",(char *) "name", NULL
22725 };
22726
22727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22729 if (SWIG_arg_fail(1)) SWIG_fail;
22730 {
22731 arg2 = wxString_in_helper(obj1);
22732 if (arg2 == NULL) SWIG_fail;
22733 temp2 = true;
22734 }
22735 {
22736 PyThreadState* __tstate = wxPyBeginAllowThreads();
22737 (arg1)->SetAppName((wxString const &)*arg2);
22738
22739 wxPyEndAllowThreads(__tstate);
22740 if (PyErr_Occurred()) SWIG_fail;
22741 }
22742 Py_INCREF(Py_None); resultobj = Py_None;
22743 {
22744 if (temp2)
22745 delete arg2;
22746 }
22747 return resultobj;
22748 fail:
22749 {
22750 if (temp2)
22751 delete arg2;
22752 }
22753 return NULL;
22754 }
22755
22756
22757 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22758 PyObject *resultobj;
22759 wxPyApp *arg1 = (wxPyApp *) 0 ;
22760 wxString result;
22761 PyObject * obj0 = 0 ;
22762 char *kwnames[] = {
22763 (char *) "self", NULL
22764 };
22765
22766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22768 if (SWIG_arg_fail(1)) SWIG_fail;
22769 {
22770 PyThreadState* __tstate = wxPyBeginAllowThreads();
22771 result = ((wxPyApp const *)arg1)->GetClassName();
22772
22773 wxPyEndAllowThreads(__tstate);
22774 if (PyErr_Occurred()) SWIG_fail;
22775 }
22776 {
22777 #if wxUSE_UNICODE
22778 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22779 #else
22780 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22781 #endif
22782 }
22783 return resultobj;
22784 fail:
22785 return NULL;
22786 }
22787
22788
22789 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22790 PyObject *resultobj;
22791 wxPyApp *arg1 = (wxPyApp *) 0 ;
22792 wxString *arg2 = 0 ;
22793 bool temp2 = false ;
22794 PyObject * obj0 = 0 ;
22795 PyObject * obj1 = 0 ;
22796 char *kwnames[] = {
22797 (char *) "self",(char *) "name", NULL
22798 };
22799
22800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22802 if (SWIG_arg_fail(1)) SWIG_fail;
22803 {
22804 arg2 = wxString_in_helper(obj1);
22805 if (arg2 == NULL) SWIG_fail;
22806 temp2 = true;
22807 }
22808 {
22809 PyThreadState* __tstate = wxPyBeginAllowThreads();
22810 (arg1)->SetClassName((wxString const &)*arg2);
22811
22812 wxPyEndAllowThreads(__tstate);
22813 if (PyErr_Occurred()) SWIG_fail;
22814 }
22815 Py_INCREF(Py_None); resultobj = Py_None;
22816 {
22817 if (temp2)
22818 delete arg2;
22819 }
22820 return resultobj;
22821 fail:
22822 {
22823 if (temp2)
22824 delete arg2;
22825 }
22826 return NULL;
22827 }
22828
22829
22830 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22831 PyObject *resultobj;
22832 wxPyApp *arg1 = (wxPyApp *) 0 ;
22833 wxString *result;
22834 PyObject * obj0 = 0 ;
22835 char *kwnames[] = {
22836 (char *) "self", NULL
22837 };
22838
22839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22841 if (SWIG_arg_fail(1)) SWIG_fail;
22842 {
22843 PyThreadState* __tstate = wxPyBeginAllowThreads();
22844 {
22845 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22846 result = (wxString *) &_result_ref;
22847 }
22848
22849 wxPyEndAllowThreads(__tstate);
22850 if (PyErr_Occurred()) SWIG_fail;
22851 }
22852 {
22853 #if wxUSE_UNICODE
22854 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22855 #else
22856 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22857 #endif
22858 }
22859 return resultobj;
22860 fail:
22861 return NULL;
22862 }
22863
22864
22865 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22866 PyObject *resultobj;
22867 wxPyApp *arg1 = (wxPyApp *) 0 ;
22868 wxString *arg2 = 0 ;
22869 bool temp2 = false ;
22870 PyObject * obj0 = 0 ;
22871 PyObject * obj1 = 0 ;
22872 char *kwnames[] = {
22873 (char *) "self",(char *) "name", NULL
22874 };
22875
22876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22878 if (SWIG_arg_fail(1)) SWIG_fail;
22879 {
22880 arg2 = wxString_in_helper(obj1);
22881 if (arg2 == NULL) SWIG_fail;
22882 temp2 = true;
22883 }
22884 {
22885 PyThreadState* __tstate = wxPyBeginAllowThreads();
22886 (arg1)->SetVendorName((wxString const &)*arg2);
22887
22888 wxPyEndAllowThreads(__tstate);
22889 if (PyErr_Occurred()) SWIG_fail;
22890 }
22891 Py_INCREF(Py_None); resultobj = Py_None;
22892 {
22893 if (temp2)
22894 delete arg2;
22895 }
22896 return resultobj;
22897 fail:
22898 {
22899 if (temp2)
22900 delete arg2;
22901 }
22902 return NULL;
22903 }
22904
22905
22906 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22907 PyObject *resultobj;
22908 wxPyApp *arg1 = (wxPyApp *) 0 ;
22909 wxAppTraits *result;
22910 PyObject * obj0 = 0 ;
22911 char *kwnames[] = {
22912 (char *) "self", NULL
22913 };
22914
22915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22917 if (SWIG_arg_fail(1)) SWIG_fail;
22918 {
22919 PyThreadState* __tstate = wxPyBeginAllowThreads();
22920 result = (wxAppTraits *)(arg1)->GetTraits();
22921
22922 wxPyEndAllowThreads(__tstate);
22923 if (PyErr_Occurred()) SWIG_fail;
22924 }
22925 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22926 return resultobj;
22927 fail:
22928 return NULL;
22929 }
22930
22931
22932 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22933 PyObject *resultobj;
22934 wxPyApp *arg1 = (wxPyApp *) 0 ;
22935 PyObject * obj0 = 0 ;
22936 char *kwnames[] = {
22937 (char *) "self", NULL
22938 };
22939
22940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22942 if (SWIG_arg_fail(1)) SWIG_fail;
22943 {
22944 PyThreadState* __tstate = wxPyBeginAllowThreads();
22945 (arg1)->ProcessPendingEvents();
22946
22947 wxPyEndAllowThreads(__tstate);
22948 if (PyErr_Occurred()) SWIG_fail;
22949 }
22950 Py_INCREF(Py_None); resultobj = Py_None;
22951 return resultobj;
22952 fail:
22953 return NULL;
22954 }
22955
22956
22957 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22958 PyObject *resultobj;
22959 wxPyApp *arg1 = (wxPyApp *) 0 ;
22960 bool arg2 = (bool) false ;
22961 bool result;
22962 PyObject * obj0 = 0 ;
22963 PyObject * obj1 = 0 ;
22964 char *kwnames[] = {
22965 (char *) "self",(char *) "onlyIfNeeded", NULL
22966 };
22967
22968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22970 if (SWIG_arg_fail(1)) SWIG_fail;
22971 if (obj1) {
22972 {
22973 arg2 = (bool)(SWIG_As_bool(obj1));
22974 if (SWIG_arg_fail(2)) SWIG_fail;
22975 }
22976 }
22977 {
22978 PyThreadState* __tstate = wxPyBeginAllowThreads();
22979 result = (bool)(arg1)->Yield(arg2);
22980
22981 wxPyEndAllowThreads(__tstate);
22982 if (PyErr_Occurred()) SWIG_fail;
22983 }
22984 {
22985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22986 }
22987 return resultobj;
22988 fail:
22989 return NULL;
22990 }
22991
22992
22993 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22994 PyObject *resultobj;
22995 wxPyApp *arg1 = (wxPyApp *) 0 ;
22996 PyObject * obj0 = 0 ;
22997 char *kwnames[] = {
22998 (char *) "self", NULL
22999 };
23000
23001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23003 if (SWIG_arg_fail(1)) SWIG_fail;
23004 {
23005 PyThreadState* __tstate = wxPyBeginAllowThreads();
23006 (arg1)->WakeUpIdle();
23007
23008 wxPyEndAllowThreads(__tstate);
23009 if (PyErr_Occurred()) SWIG_fail;
23010 }
23011 Py_INCREF(Py_None); resultobj = Py_None;
23012 return resultobj;
23013 fail:
23014 return NULL;
23015 }
23016
23017
23018 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23019 PyObject *resultobj;
23020 bool result;
23021 char *kwnames[] = {
23022 NULL
23023 };
23024
23025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23026 {
23027 PyThreadState* __tstate = wxPyBeginAllowThreads();
23028 result = (bool)wxPyApp::IsMainLoopRunning();
23029
23030 wxPyEndAllowThreads(__tstate);
23031 if (PyErr_Occurred()) SWIG_fail;
23032 }
23033 {
23034 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23035 }
23036 return resultobj;
23037 fail:
23038 return NULL;
23039 }
23040
23041
23042 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23043 PyObject *resultobj;
23044 wxPyApp *arg1 = (wxPyApp *) 0 ;
23045 int result;
23046 PyObject * obj0 = 0 ;
23047 char *kwnames[] = {
23048 (char *) "self", NULL
23049 };
23050
23051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23053 if (SWIG_arg_fail(1)) SWIG_fail;
23054 {
23055 PyThreadState* __tstate = wxPyBeginAllowThreads();
23056 result = (int)(arg1)->MainLoop();
23057
23058 wxPyEndAllowThreads(__tstate);
23059 if (PyErr_Occurred()) SWIG_fail;
23060 }
23061 {
23062 resultobj = SWIG_From_int((int)(result));
23063 }
23064 return resultobj;
23065 fail:
23066 return NULL;
23067 }
23068
23069
23070 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23071 PyObject *resultobj;
23072 wxPyApp *arg1 = (wxPyApp *) 0 ;
23073 PyObject * obj0 = 0 ;
23074 char *kwnames[] = {
23075 (char *) "self", NULL
23076 };
23077
23078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23080 if (SWIG_arg_fail(1)) SWIG_fail;
23081 {
23082 PyThreadState* __tstate = wxPyBeginAllowThreads();
23083 (arg1)->Exit();
23084
23085 wxPyEndAllowThreads(__tstate);
23086 if (PyErr_Occurred()) SWIG_fail;
23087 }
23088 Py_INCREF(Py_None); resultobj = Py_None;
23089 return resultobj;
23090 fail:
23091 return NULL;
23092 }
23093
23094
23095 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23096 PyObject *resultobj;
23097 wxPyApp *arg1 = (wxPyApp *) 0 ;
23098 PyObject * obj0 = 0 ;
23099 char *kwnames[] = {
23100 (char *) "self", NULL
23101 };
23102
23103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23105 if (SWIG_arg_fail(1)) SWIG_fail;
23106 {
23107 PyThreadState* __tstate = wxPyBeginAllowThreads();
23108 (arg1)->ExitMainLoop();
23109
23110 wxPyEndAllowThreads(__tstate);
23111 if (PyErr_Occurred()) SWIG_fail;
23112 }
23113 Py_INCREF(Py_None); resultobj = Py_None;
23114 return resultobj;
23115 fail:
23116 return NULL;
23117 }
23118
23119
23120 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23121 PyObject *resultobj;
23122 wxPyApp *arg1 = (wxPyApp *) 0 ;
23123 bool result;
23124 PyObject * obj0 = 0 ;
23125 char *kwnames[] = {
23126 (char *) "self", NULL
23127 };
23128
23129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23131 if (SWIG_arg_fail(1)) SWIG_fail;
23132 {
23133 PyThreadState* __tstate = wxPyBeginAllowThreads();
23134 result = (bool)(arg1)->Pending();
23135
23136 wxPyEndAllowThreads(__tstate);
23137 if (PyErr_Occurred()) SWIG_fail;
23138 }
23139 {
23140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23141 }
23142 return resultobj;
23143 fail:
23144 return NULL;
23145 }
23146
23147
23148 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23149 PyObject *resultobj;
23150 wxPyApp *arg1 = (wxPyApp *) 0 ;
23151 bool result;
23152 PyObject * obj0 = 0 ;
23153 char *kwnames[] = {
23154 (char *) "self", NULL
23155 };
23156
23157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23159 if (SWIG_arg_fail(1)) SWIG_fail;
23160 {
23161 PyThreadState* __tstate = wxPyBeginAllowThreads();
23162 result = (bool)(arg1)->Dispatch();
23163
23164 wxPyEndAllowThreads(__tstate);
23165 if (PyErr_Occurred()) SWIG_fail;
23166 }
23167 {
23168 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23169 }
23170 return resultobj;
23171 fail:
23172 return NULL;
23173 }
23174
23175
23176 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23177 PyObject *resultobj;
23178 wxPyApp *arg1 = (wxPyApp *) 0 ;
23179 bool result;
23180 PyObject * obj0 = 0 ;
23181 char *kwnames[] = {
23182 (char *) "self", NULL
23183 };
23184
23185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23187 if (SWIG_arg_fail(1)) SWIG_fail;
23188 {
23189 PyThreadState* __tstate = wxPyBeginAllowThreads();
23190 result = (bool)(arg1)->ProcessIdle();
23191
23192 wxPyEndAllowThreads(__tstate);
23193 if (PyErr_Occurred()) SWIG_fail;
23194 }
23195 {
23196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23197 }
23198 return resultobj;
23199 fail:
23200 return NULL;
23201 }
23202
23203
23204 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23205 PyObject *resultobj;
23206 wxPyApp *arg1 = (wxPyApp *) 0 ;
23207 wxWindow *arg2 = (wxWindow *) 0 ;
23208 wxIdleEvent *arg3 = 0 ;
23209 bool result;
23210 PyObject * obj0 = 0 ;
23211 PyObject * obj1 = 0 ;
23212 PyObject * obj2 = 0 ;
23213 char *kwnames[] = {
23214 (char *) "self",(char *) "win",(char *) "event", NULL
23215 };
23216
23217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23219 if (SWIG_arg_fail(1)) SWIG_fail;
23220 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23221 if (SWIG_arg_fail(2)) SWIG_fail;
23222 {
23223 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23224 if (SWIG_arg_fail(3)) SWIG_fail;
23225 if (arg3 == NULL) {
23226 SWIG_null_ref("wxIdleEvent");
23227 }
23228 if (SWIG_arg_fail(3)) SWIG_fail;
23229 }
23230 {
23231 PyThreadState* __tstate = wxPyBeginAllowThreads();
23232 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23233
23234 wxPyEndAllowThreads(__tstate);
23235 if (PyErr_Occurred()) SWIG_fail;
23236 }
23237 {
23238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23239 }
23240 return resultobj;
23241 fail:
23242 return NULL;
23243 }
23244
23245
23246 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23247 PyObject *resultobj;
23248 wxPyApp *arg1 = (wxPyApp *) 0 ;
23249 bool result;
23250 PyObject * obj0 = 0 ;
23251 char *kwnames[] = {
23252 (char *) "self", NULL
23253 };
23254
23255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23257 if (SWIG_arg_fail(1)) SWIG_fail;
23258 {
23259 PyThreadState* __tstate = wxPyBeginAllowThreads();
23260 result = (bool)((wxPyApp const *)arg1)->IsActive();
23261
23262 wxPyEndAllowThreads(__tstate);
23263 if (PyErr_Occurred()) SWIG_fail;
23264 }
23265 {
23266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23267 }
23268 return resultobj;
23269 fail:
23270 return NULL;
23271 }
23272
23273
23274 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23275 PyObject *resultobj;
23276 wxPyApp *arg1 = (wxPyApp *) 0 ;
23277 wxWindow *arg2 = (wxWindow *) 0 ;
23278 PyObject * obj0 = 0 ;
23279 PyObject * obj1 = 0 ;
23280 char *kwnames[] = {
23281 (char *) "self",(char *) "win", NULL
23282 };
23283
23284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23286 if (SWIG_arg_fail(1)) SWIG_fail;
23287 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23288 if (SWIG_arg_fail(2)) SWIG_fail;
23289 {
23290 PyThreadState* __tstate = wxPyBeginAllowThreads();
23291 (arg1)->SetTopWindow(arg2);
23292
23293 wxPyEndAllowThreads(__tstate);
23294 if (PyErr_Occurred()) SWIG_fail;
23295 }
23296 Py_INCREF(Py_None); resultobj = Py_None;
23297 return resultobj;
23298 fail:
23299 return NULL;
23300 }
23301
23302
23303 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23304 PyObject *resultobj;
23305 wxPyApp *arg1 = (wxPyApp *) 0 ;
23306 wxWindow *result;
23307 PyObject * obj0 = 0 ;
23308 char *kwnames[] = {
23309 (char *) "self", NULL
23310 };
23311
23312 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23313 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23314 if (SWIG_arg_fail(1)) SWIG_fail;
23315 {
23316 PyThreadState* __tstate = wxPyBeginAllowThreads();
23317 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23318
23319 wxPyEndAllowThreads(__tstate);
23320 if (PyErr_Occurred()) SWIG_fail;
23321 }
23322 {
23323 resultobj = wxPyMake_wxObject(result, 0);
23324 }
23325 return resultobj;
23326 fail:
23327 return NULL;
23328 }
23329
23330
23331 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23332 PyObject *resultobj;
23333 wxPyApp *arg1 = (wxPyApp *) 0 ;
23334 bool arg2 ;
23335 PyObject * obj0 = 0 ;
23336 PyObject * obj1 = 0 ;
23337 char *kwnames[] = {
23338 (char *) "self",(char *) "flag", NULL
23339 };
23340
23341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23343 if (SWIG_arg_fail(1)) SWIG_fail;
23344 {
23345 arg2 = (bool)(SWIG_As_bool(obj1));
23346 if (SWIG_arg_fail(2)) SWIG_fail;
23347 }
23348 {
23349 PyThreadState* __tstate = wxPyBeginAllowThreads();
23350 (arg1)->SetExitOnFrameDelete(arg2);
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_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23363 PyObject *resultobj;
23364 wxPyApp *arg1 = (wxPyApp *) 0 ;
23365 bool result;
23366 PyObject * obj0 = 0 ;
23367 char *kwnames[] = {
23368 (char *) "self", NULL
23369 };
23370
23371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
23372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23373 if (SWIG_arg_fail(1)) SWIG_fail;
23374 {
23375 PyThreadState* __tstate = wxPyBeginAllowThreads();
23376 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23377
23378 wxPyEndAllowThreads(__tstate);
23379 if (PyErr_Occurred()) SWIG_fail;
23380 }
23381 {
23382 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23383 }
23384 return resultobj;
23385 fail:
23386 return NULL;
23387 }
23388
23389
23390 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23391 PyObject *resultobj;
23392 wxPyApp *arg1 = (wxPyApp *) 0 ;
23393 bool arg2 ;
23394 PyObject * obj0 = 0 ;
23395 PyObject * obj1 = 0 ;
23396 char *kwnames[] = {
23397 (char *) "self",(char *) "flag", NULL
23398 };
23399
23400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
23401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23402 if (SWIG_arg_fail(1)) SWIG_fail;
23403 {
23404 arg2 = (bool)(SWIG_As_bool(obj1));
23405 if (SWIG_arg_fail(2)) SWIG_fail;
23406 }
23407 {
23408 PyThreadState* __tstate = wxPyBeginAllowThreads();
23409 (arg1)->SetUseBestVisual(arg2);
23410
23411 wxPyEndAllowThreads(__tstate);
23412 if (PyErr_Occurred()) SWIG_fail;
23413 }
23414 Py_INCREF(Py_None); resultobj = Py_None;
23415 return resultobj;
23416 fail:
23417 return NULL;
23418 }
23419
23420
23421 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23422 PyObject *resultobj;
23423 wxPyApp *arg1 = (wxPyApp *) 0 ;
23424 bool result;
23425 PyObject * obj0 = 0 ;
23426 char *kwnames[] = {
23427 (char *) "self", NULL
23428 };
23429
23430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23431 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23432 if (SWIG_arg_fail(1)) SWIG_fail;
23433 {
23434 PyThreadState* __tstate = wxPyBeginAllowThreads();
23435 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23436
23437 wxPyEndAllowThreads(__tstate);
23438 if (PyErr_Occurred()) SWIG_fail;
23439 }
23440 {
23441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23442 }
23443 return resultobj;
23444 fail:
23445 return NULL;
23446 }
23447
23448
23449 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23450 PyObject *resultobj;
23451 wxPyApp *arg1 = (wxPyApp *) 0 ;
23452 int arg2 ;
23453 PyObject * obj0 = 0 ;
23454 PyObject * obj1 = 0 ;
23455 char *kwnames[] = {
23456 (char *) "self",(char *) "mode", NULL
23457 };
23458
23459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23461 if (SWIG_arg_fail(1)) SWIG_fail;
23462 {
23463 arg2 = (int)(SWIG_As_int(obj1));
23464 if (SWIG_arg_fail(2)) SWIG_fail;
23465 }
23466 {
23467 PyThreadState* __tstate = wxPyBeginAllowThreads();
23468 (arg1)->SetPrintMode(arg2);
23469
23470 wxPyEndAllowThreads(__tstate);
23471 if (PyErr_Occurred()) SWIG_fail;
23472 }
23473 Py_INCREF(Py_None); resultobj = Py_None;
23474 return resultobj;
23475 fail:
23476 return NULL;
23477 }
23478
23479
23480 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23481 PyObject *resultobj;
23482 wxPyApp *arg1 = (wxPyApp *) 0 ;
23483 int result;
23484 PyObject * obj0 = 0 ;
23485 char *kwnames[] = {
23486 (char *) "self", NULL
23487 };
23488
23489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23491 if (SWIG_arg_fail(1)) SWIG_fail;
23492 {
23493 PyThreadState* __tstate = wxPyBeginAllowThreads();
23494 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23495
23496 wxPyEndAllowThreads(__tstate);
23497 if (PyErr_Occurred()) SWIG_fail;
23498 }
23499 {
23500 resultobj = SWIG_From_int((int)(result));
23501 }
23502 return resultobj;
23503 fail:
23504 return NULL;
23505 }
23506
23507
23508 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23509 PyObject *resultobj;
23510 wxPyApp *arg1 = (wxPyApp *) 0 ;
23511 int arg2 ;
23512 PyObject * obj0 = 0 ;
23513 PyObject * obj1 = 0 ;
23514 char *kwnames[] = {
23515 (char *) "self",(char *) "mode", NULL
23516 };
23517
23518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23520 if (SWIG_arg_fail(1)) SWIG_fail;
23521 {
23522 arg2 = (int)(SWIG_As_int(obj1));
23523 if (SWIG_arg_fail(2)) SWIG_fail;
23524 }
23525 {
23526 PyThreadState* __tstate = wxPyBeginAllowThreads();
23527 (arg1)->SetAssertMode(arg2);
23528
23529 wxPyEndAllowThreads(__tstate);
23530 if (PyErr_Occurred()) SWIG_fail;
23531 }
23532 Py_INCREF(Py_None); resultobj = Py_None;
23533 return resultobj;
23534 fail:
23535 return NULL;
23536 }
23537
23538
23539 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23540 PyObject *resultobj;
23541 wxPyApp *arg1 = (wxPyApp *) 0 ;
23542 int result;
23543 PyObject * obj0 = 0 ;
23544 char *kwnames[] = {
23545 (char *) "self", NULL
23546 };
23547
23548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23550 if (SWIG_arg_fail(1)) SWIG_fail;
23551 {
23552 PyThreadState* __tstate = wxPyBeginAllowThreads();
23553 result = (int)(arg1)->GetAssertMode();
23554
23555 wxPyEndAllowThreads(__tstate);
23556 if (PyErr_Occurred()) SWIG_fail;
23557 }
23558 {
23559 resultobj = SWIG_From_int((int)(result));
23560 }
23561 return resultobj;
23562 fail:
23563 return NULL;
23564 }
23565
23566
23567 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23568 PyObject *resultobj;
23569 bool result;
23570 char *kwnames[] = {
23571 NULL
23572 };
23573
23574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23575 {
23576 PyThreadState* __tstate = wxPyBeginAllowThreads();
23577 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23578
23579 wxPyEndAllowThreads(__tstate);
23580 if (PyErr_Occurred()) SWIG_fail;
23581 }
23582 {
23583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23584 }
23585 return resultobj;
23586 fail:
23587 return NULL;
23588 }
23589
23590
23591 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23592 PyObject *resultobj;
23593 long result;
23594 char *kwnames[] = {
23595 NULL
23596 };
23597
23598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23599 {
23600 PyThreadState* __tstate = wxPyBeginAllowThreads();
23601 result = (long)wxPyApp::GetMacAboutMenuItemId();
23602
23603 wxPyEndAllowThreads(__tstate);
23604 if (PyErr_Occurred()) SWIG_fail;
23605 }
23606 {
23607 resultobj = SWIG_From_long((long)(result));
23608 }
23609 return resultobj;
23610 fail:
23611 return NULL;
23612 }
23613
23614
23615 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23616 PyObject *resultobj;
23617 long result;
23618 char *kwnames[] = {
23619 NULL
23620 };
23621
23622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23623 {
23624 PyThreadState* __tstate = wxPyBeginAllowThreads();
23625 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23626
23627 wxPyEndAllowThreads(__tstate);
23628 if (PyErr_Occurred()) SWIG_fail;
23629 }
23630 {
23631 resultobj = SWIG_From_long((long)(result));
23632 }
23633 return resultobj;
23634 fail:
23635 return NULL;
23636 }
23637
23638
23639 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23640 PyObject *resultobj;
23641 long result;
23642 char *kwnames[] = {
23643 NULL
23644 };
23645
23646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23647 {
23648 PyThreadState* __tstate = wxPyBeginAllowThreads();
23649 result = (long)wxPyApp::GetMacExitMenuItemId();
23650
23651 wxPyEndAllowThreads(__tstate);
23652 if (PyErr_Occurred()) SWIG_fail;
23653 }
23654 {
23655 resultobj = SWIG_From_long((long)(result));
23656 }
23657 return resultobj;
23658 fail:
23659 return NULL;
23660 }
23661
23662
23663 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23664 PyObject *resultobj;
23665 wxString result;
23666 char *kwnames[] = {
23667 NULL
23668 };
23669
23670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23671 {
23672 PyThreadState* __tstate = wxPyBeginAllowThreads();
23673 result = wxPyApp::GetMacHelpMenuTitleName();
23674
23675 wxPyEndAllowThreads(__tstate);
23676 if (PyErr_Occurred()) SWIG_fail;
23677 }
23678 {
23679 #if wxUSE_UNICODE
23680 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23681 #else
23682 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23683 #endif
23684 }
23685 return resultobj;
23686 fail:
23687 return NULL;
23688 }
23689
23690
23691 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23692 PyObject *resultobj;
23693 bool arg1 ;
23694 PyObject * obj0 = 0 ;
23695 char *kwnames[] = {
23696 (char *) "val", NULL
23697 };
23698
23699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23700 {
23701 arg1 = (bool)(SWIG_As_bool(obj0));
23702 if (SWIG_arg_fail(1)) SWIG_fail;
23703 }
23704 {
23705 PyThreadState* __tstate = wxPyBeginAllowThreads();
23706 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23707
23708 wxPyEndAllowThreads(__tstate);
23709 if (PyErr_Occurred()) SWIG_fail;
23710 }
23711 Py_INCREF(Py_None); resultobj = Py_None;
23712 return resultobj;
23713 fail:
23714 return NULL;
23715 }
23716
23717
23718 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23719 PyObject *resultobj;
23720 long arg1 ;
23721 PyObject * obj0 = 0 ;
23722 char *kwnames[] = {
23723 (char *) "val", NULL
23724 };
23725
23726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23727 {
23728 arg1 = (long)(SWIG_As_long(obj0));
23729 if (SWIG_arg_fail(1)) SWIG_fail;
23730 }
23731 {
23732 PyThreadState* __tstate = wxPyBeginAllowThreads();
23733 wxPyApp::SetMacAboutMenuItemId(arg1);
23734
23735 wxPyEndAllowThreads(__tstate);
23736 if (PyErr_Occurred()) SWIG_fail;
23737 }
23738 Py_INCREF(Py_None); resultobj = Py_None;
23739 return resultobj;
23740 fail:
23741 return NULL;
23742 }
23743
23744
23745 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23746 PyObject *resultobj;
23747 long arg1 ;
23748 PyObject * obj0 = 0 ;
23749 char *kwnames[] = {
23750 (char *) "val", NULL
23751 };
23752
23753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23754 {
23755 arg1 = (long)(SWIG_As_long(obj0));
23756 if (SWIG_arg_fail(1)) SWIG_fail;
23757 }
23758 {
23759 PyThreadState* __tstate = wxPyBeginAllowThreads();
23760 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23761
23762 wxPyEndAllowThreads(__tstate);
23763 if (PyErr_Occurred()) SWIG_fail;
23764 }
23765 Py_INCREF(Py_None); resultobj = Py_None;
23766 return resultobj;
23767 fail:
23768 return NULL;
23769 }
23770
23771
23772 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23773 PyObject *resultobj;
23774 long arg1 ;
23775 PyObject * obj0 = 0 ;
23776 char *kwnames[] = {
23777 (char *) "val", NULL
23778 };
23779
23780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23781 {
23782 arg1 = (long)(SWIG_As_long(obj0));
23783 if (SWIG_arg_fail(1)) SWIG_fail;
23784 }
23785 {
23786 PyThreadState* __tstate = wxPyBeginAllowThreads();
23787 wxPyApp::SetMacExitMenuItemId(arg1);
23788
23789 wxPyEndAllowThreads(__tstate);
23790 if (PyErr_Occurred()) SWIG_fail;
23791 }
23792 Py_INCREF(Py_None); resultobj = Py_None;
23793 return resultobj;
23794 fail:
23795 return NULL;
23796 }
23797
23798
23799 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23800 PyObject *resultobj;
23801 wxString *arg1 = 0 ;
23802 bool temp1 = false ;
23803 PyObject * obj0 = 0 ;
23804 char *kwnames[] = {
23805 (char *) "val", NULL
23806 };
23807
23808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23809 {
23810 arg1 = wxString_in_helper(obj0);
23811 if (arg1 == NULL) SWIG_fail;
23812 temp1 = true;
23813 }
23814 {
23815 PyThreadState* __tstate = wxPyBeginAllowThreads();
23816 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23817
23818 wxPyEndAllowThreads(__tstate);
23819 if (PyErr_Occurred()) SWIG_fail;
23820 }
23821 Py_INCREF(Py_None); resultobj = Py_None;
23822 {
23823 if (temp1)
23824 delete arg1;
23825 }
23826 return resultobj;
23827 fail:
23828 {
23829 if (temp1)
23830 delete arg1;
23831 }
23832 return NULL;
23833 }
23834
23835
23836 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23837 PyObject *resultobj;
23838 wxPyApp *arg1 = (wxPyApp *) 0 ;
23839 PyObject * obj0 = 0 ;
23840 char *kwnames[] = {
23841 (char *) "self", NULL
23842 };
23843
23844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23846 if (SWIG_arg_fail(1)) SWIG_fail;
23847 {
23848 PyThreadState* __tstate = wxPyBeginAllowThreads();
23849 (arg1)->_BootstrapApp();
23850
23851 wxPyEndAllowThreads(__tstate);
23852 if (PyErr_Occurred()) SWIG_fail;
23853 }
23854 Py_INCREF(Py_None); resultobj = Py_None;
23855 return resultobj;
23856 fail:
23857 return NULL;
23858 }
23859
23860
23861 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23862 PyObject *resultobj;
23863 int result;
23864 char *kwnames[] = {
23865 NULL
23866 };
23867
23868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23869 {
23870 PyThreadState* __tstate = wxPyBeginAllowThreads();
23871 result = (int)wxPyApp::GetComCtl32Version();
23872
23873 wxPyEndAllowThreads(__tstate);
23874 if (PyErr_Occurred()) SWIG_fail;
23875 }
23876 {
23877 resultobj = SWIG_From_int((int)(result));
23878 }
23879 return resultobj;
23880 fail:
23881 return NULL;
23882 }
23883
23884
23885 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23886 PyObject *obj;
23887 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23888 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23889 Py_INCREF(obj);
23890 return Py_BuildValue((char *)"");
23891 }
23892 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23893 PyObject *resultobj;
23894 char *kwnames[] = {
23895 NULL
23896 };
23897
23898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23899 {
23900 PyThreadState* __tstate = wxPyBeginAllowThreads();
23901 wxExit();
23902
23903 wxPyEndAllowThreads(__tstate);
23904 if (PyErr_Occurred()) SWIG_fail;
23905 }
23906 Py_INCREF(Py_None); resultobj = Py_None;
23907 return resultobj;
23908 fail:
23909 return NULL;
23910 }
23911
23912
23913 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23914 PyObject *resultobj;
23915 bool result;
23916 char *kwnames[] = {
23917 NULL
23918 };
23919
23920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23921 {
23922 PyThreadState* __tstate = wxPyBeginAllowThreads();
23923 result = (bool)wxYield();
23924
23925 wxPyEndAllowThreads(__tstate);
23926 if (PyErr_Occurred()) SWIG_fail;
23927 }
23928 {
23929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23930 }
23931 return resultobj;
23932 fail:
23933 return NULL;
23934 }
23935
23936
23937 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23938 PyObject *resultobj;
23939 bool result;
23940 char *kwnames[] = {
23941 NULL
23942 };
23943
23944 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23945 {
23946 PyThreadState* __tstate = wxPyBeginAllowThreads();
23947 result = (bool)wxYieldIfNeeded();
23948
23949 wxPyEndAllowThreads(__tstate);
23950 if (PyErr_Occurred()) SWIG_fail;
23951 }
23952 {
23953 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23954 }
23955 return resultobj;
23956 fail:
23957 return NULL;
23958 }
23959
23960
23961 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23962 PyObject *resultobj;
23963 wxWindow *arg1 = (wxWindow *) NULL ;
23964 bool arg2 = (bool) false ;
23965 bool result;
23966 PyObject * obj0 = 0 ;
23967 PyObject * obj1 = 0 ;
23968 char *kwnames[] = {
23969 (char *) "win",(char *) "onlyIfNeeded", NULL
23970 };
23971
23972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23973 if (obj0) {
23974 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23975 if (SWIG_arg_fail(1)) SWIG_fail;
23976 }
23977 if (obj1) {
23978 {
23979 arg2 = (bool)(SWIG_As_bool(obj1));
23980 if (SWIG_arg_fail(2)) SWIG_fail;
23981 }
23982 }
23983 {
23984 PyThreadState* __tstate = wxPyBeginAllowThreads();
23985 result = (bool)wxSafeYield(arg1,arg2);
23986
23987 wxPyEndAllowThreads(__tstate);
23988 if (PyErr_Occurred()) SWIG_fail;
23989 }
23990 {
23991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23992 }
23993 return resultobj;
23994 fail:
23995 return NULL;
23996 }
23997
23998
23999 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24000 PyObject *resultobj;
24001 char *kwnames[] = {
24002 NULL
24003 };
24004
24005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24006 {
24007 PyThreadState* __tstate = wxPyBeginAllowThreads();
24008 wxWakeUpIdle();
24009
24010 wxPyEndAllowThreads(__tstate);
24011 if (PyErr_Occurred()) SWIG_fail;
24012 }
24013 Py_INCREF(Py_None); resultobj = Py_None;
24014 return resultobj;
24015 fail:
24016 return NULL;
24017 }
24018
24019
24020 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24021 PyObject *resultobj;
24022 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24023 wxEvent *arg2 = 0 ;
24024 PyObject * obj0 = 0 ;
24025 PyObject * obj1 = 0 ;
24026 char *kwnames[] = {
24027 (char *) "dest",(char *) "event", NULL
24028 };
24029
24030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24032 if (SWIG_arg_fail(1)) SWIG_fail;
24033 {
24034 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24035 if (SWIG_arg_fail(2)) SWIG_fail;
24036 if (arg2 == NULL) {
24037 SWIG_null_ref("wxEvent");
24038 }
24039 if (SWIG_arg_fail(2)) SWIG_fail;
24040 }
24041 {
24042 PyThreadState* __tstate = wxPyBeginAllowThreads();
24043 wxPostEvent(arg1,*arg2);
24044
24045 wxPyEndAllowThreads(__tstate);
24046 if (PyErr_Occurred()) SWIG_fail;
24047 }
24048 Py_INCREF(Py_None); resultobj = Py_None;
24049 return resultobj;
24050 fail:
24051 return NULL;
24052 }
24053
24054
24055 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24056 PyObject *resultobj;
24057 char *kwnames[] = {
24058 NULL
24059 };
24060
24061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24062 {
24063 PyThreadState* __tstate = wxPyBeginAllowThreads();
24064 wxApp_CleanUp();
24065
24066 wxPyEndAllowThreads(__tstate);
24067 if (PyErr_Occurred()) SWIG_fail;
24068 }
24069 Py_INCREF(Py_None); resultobj = Py_None;
24070 return resultobj;
24071 fail:
24072 return NULL;
24073 }
24074
24075
24076 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24077 PyObject *resultobj;
24078 wxPyApp *result;
24079 char *kwnames[] = {
24080 NULL
24081 };
24082
24083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24084 {
24085 PyThreadState* __tstate = wxPyBeginAllowThreads();
24086 result = (wxPyApp *)wxPyGetApp();
24087
24088 wxPyEndAllowThreads(__tstate);
24089 if (PyErr_Occurred()) SWIG_fail;
24090 }
24091 {
24092 resultobj = wxPyMake_wxObject(result, 0);
24093 }
24094 return resultobj;
24095 fail:
24096 return NULL;
24097 }
24098
24099
24100 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24101 PyObject *resultobj;
24102 char *arg1 = (char *) 0 ;
24103 PyObject * obj0 = 0 ;
24104 char *kwnames[] = {
24105 (char *) "encoding", NULL
24106 };
24107
24108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24109 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24110 SWIG_arg_fail(1);SWIG_fail;
24111 }
24112 {
24113 PyThreadState* __tstate = wxPyBeginAllowThreads();
24114 wxSetDefaultPyEncoding((char const *)arg1);
24115
24116 wxPyEndAllowThreads(__tstate);
24117 if (PyErr_Occurred()) SWIG_fail;
24118 }
24119 Py_INCREF(Py_None); resultobj = Py_None;
24120 return resultobj;
24121 fail:
24122 return NULL;
24123 }
24124
24125
24126 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24127 PyObject *resultobj;
24128 char *result;
24129 char *kwnames[] = {
24130 NULL
24131 };
24132
24133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24134 {
24135 PyThreadState* __tstate = wxPyBeginAllowThreads();
24136 result = (char *)wxGetDefaultPyEncoding();
24137
24138 wxPyEndAllowThreads(__tstate);
24139 if (PyErr_Occurred()) SWIG_fail;
24140 }
24141 resultobj = SWIG_FromCharPtr(result);
24142 return resultobj;
24143 fail:
24144 return NULL;
24145 }
24146
24147
24148 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24149 PyObject *resultobj;
24150 wxEventLoop *result;
24151 char *kwnames[] = {
24152 NULL
24153 };
24154
24155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24156 {
24157 PyThreadState* __tstate = wxPyBeginAllowThreads();
24158 result = (wxEventLoop *)new wxEventLoop();
24159
24160 wxPyEndAllowThreads(__tstate);
24161 if (PyErr_Occurred()) SWIG_fail;
24162 }
24163 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24164 return resultobj;
24165 fail:
24166 return NULL;
24167 }
24168
24169
24170 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24171 PyObject *resultobj;
24172 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24173 PyObject * obj0 = 0 ;
24174 char *kwnames[] = {
24175 (char *) "self", NULL
24176 };
24177
24178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24180 if (SWIG_arg_fail(1)) SWIG_fail;
24181 {
24182 PyThreadState* __tstate = wxPyBeginAllowThreads();
24183 delete arg1;
24184
24185 wxPyEndAllowThreads(__tstate);
24186 if (PyErr_Occurred()) SWIG_fail;
24187 }
24188 Py_INCREF(Py_None); resultobj = Py_None;
24189 return resultobj;
24190 fail:
24191 return NULL;
24192 }
24193
24194
24195 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24196 PyObject *resultobj;
24197 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24198 int result;
24199 PyObject * obj0 = 0 ;
24200 char *kwnames[] = {
24201 (char *) "self", NULL
24202 };
24203
24204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24206 if (SWIG_arg_fail(1)) SWIG_fail;
24207 {
24208 PyThreadState* __tstate = wxPyBeginAllowThreads();
24209 result = (int)(arg1)->Run();
24210
24211 wxPyEndAllowThreads(__tstate);
24212 if (PyErr_Occurred()) SWIG_fail;
24213 }
24214 {
24215 resultobj = SWIG_From_int((int)(result));
24216 }
24217 return resultobj;
24218 fail:
24219 return NULL;
24220 }
24221
24222
24223 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24224 PyObject *resultobj;
24225 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24226 int arg2 = (int) 0 ;
24227 PyObject * obj0 = 0 ;
24228 PyObject * obj1 = 0 ;
24229 char *kwnames[] = {
24230 (char *) "self",(char *) "rc", NULL
24231 };
24232
24233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24235 if (SWIG_arg_fail(1)) SWIG_fail;
24236 if (obj1) {
24237 {
24238 arg2 = (int)(SWIG_As_int(obj1));
24239 if (SWIG_arg_fail(2)) SWIG_fail;
24240 }
24241 }
24242 {
24243 PyThreadState* __tstate = wxPyBeginAllowThreads();
24244 (arg1)->Exit(arg2);
24245
24246 wxPyEndAllowThreads(__tstate);
24247 if (PyErr_Occurred()) SWIG_fail;
24248 }
24249 Py_INCREF(Py_None); resultobj = Py_None;
24250 return resultobj;
24251 fail:
24252 return NULL;
24253 }
24254
24255
24256 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24257 PyObject *resultobj;
24258 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24259 bool result;
24260 PyObject * obj0 = 0 ;
24261 char *kwnames[] = {
24262 (char *) "self", NULL
24263 };
24264
24265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24267 if (SWIG_arg_fail(1)) SWIG_fail;
24268 {
24269 PyThreadState* __tstate = wxPyBeginAllowThreads();
24270 result = (bool)((wxEventLoop const *)arg1)->Pending();
24271
24272 wxPyEndAllowThreads(__tstate);
24273 if (PyErr_Occurred()) SWIG_fail;
24274 }
24275 {
24276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24277 }
24278 return resultobj;
24279 fail:
24280 return NULL;
24281 }
24282
24283
24284 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24285 PyObject *resultobj;
24286 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24287 bool result;
24288 PyObject * obj0 = 0 ;
24289 char *kwnames[] = {
24290 (char *) "self", NULL
24291 };
24292
24293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24295 if (SWIG_arg_fail(1)) SWIG_fail;
24296 {
24297 PyThreadState* __tstate = wxPyBeginAllowThreads();
24298 result = (bool)(arg1)->Dispatch();
24299
24300 wxPyEndAllowThreads(__tstate);
24301 if (PyErr_Occurred()) SWIG_fail;
24302 }
24303 {
24304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24305 }
24306 return resultobj;
24307 fail:
24308 return NULL;
24309 }
24310
24311
24312 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24313 PyObject *resultobj;
24314 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24315 bool result;
24316 PyObject * obj0 = 0 ;
24317 char *kwnames[] = {
24318 (char *) "self", NULL
24319 };
24320
24321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24323 if (SWIG_arg_fail(1)) SWIG_fail;
24324 {
24325 PyThreadState* __tstate = wxPyBeginAllowThreads();
24326 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24327
24328 wxPyEndAllowThreads(__tstate);
24329 if (PyErr_Occurred()) SWIG_fail;
24330 }
24331 {
24332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24333 }
24334 return resultobj;
24335 fail:
24336 return NULL;
24337 }
24338
24339
24340 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24341 PyObject *resultobj;
24342 wxEventLoop *result;
24343 char *kwnames[] = {
24344 NULL
24345 };
24346
24347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24348 {
24349 PyThreadState* __tstate = wxPyBeginAllowThreads();
24350 result = (wxEventLoop *)wxEventLoop::GetActive();
24351
24352 wxPyEndAllowThreads(__tstate);
24353 if (PyErr_Occurred()) SWIG_fail;
24354 }
24355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24356 return resultobj;
24357 fail:
24358 return NULL;
24359 }
24360
24361
24362 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24363 PyObject *resultobj;
24364 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24365 PyObject * obj0 = 0 ;
24366 char *kwnames[] = {
24367 (char *) "loop", NULL
24368 };
24369
24370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
24371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24372 if (SWIG_arg_fail(1)) SWIG_fail;
24373 {
24374 PyThreadState* __tstate = wxPyBeginAllowThreads();
24375 wxEventLoop::SetActive(arg1);
24376
24377 wxPyEndAllowThreads(__tstate);
24378 if (PyErr_Occurred()) SWIG_fail;
24379 }
24380 Py_INCREF(Py_None); resultobj = Py_None;
24381 return resultobj;
24382 fail:
24383 return NULL;
24384 }
24385
24386
24387 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
24388 PyObject *obj;
24389 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24390 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
24391 Py_INCREF(obj);
24392 return Py_BuildValue((char *)"");
24393 }
24394 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24395 PyObject *resultobj;
24396 int arg1 = (int) 0 ;
24397 int arg2 = (int) 0 ;
24398 int arg3 = (int) 0 ;
24399 wxAcceleratorEntry *result;
24400 PyObject * obj0 = 0 ;
24401 PyObject * obj1 = 0 ;
24402 PyObject * obj2 = 0 ;
24403 char *kwnames[] = {
24404 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
24405 };
24406
24407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
24408 if (obj0) {
24409 {
24410 arg1 = (int)(SWIG_As_int(obj0));
24411 if (SWIG_arg_fail(1)) SWIG_fail;
24412 }
24413 }
24414 if (obj1) {
24415 {
24416 arg2 = (int)(SWIG_As_int(obj1));
24417 if (SWIG_arg_fail(2)) SWIG_fail;
24418 }
24419 }
24420 if (obj2) {
24421 {
24422 arg3 = (int)(SWIG_As_int(obj2));
24423 if (SWIG_arg_fail(3)) SWIG_fail;
24424 }
24425 }
24426 {
24427 PyThreadState* __tstate = wxPyBeginAllowThreads();
24428 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24429
24430 wxPyEndAllowThreads(__tstate);
24431 if (PyErr_Occurred()) SWIG_fail;
24432 }
24433 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24434 return resultobj;
24435 fail:
24436 return NULL;
24437 }
24438
24439
24440 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24441 PyObject *resultobj;
24442 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24443 PyObject * obj0 = 0 ;
24444 char *kwnames[] = {
24445 (char *) "self", NULL
24446 };
24447
24448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24450 if (SWIG_arg_fail(1)) SWIG_fail;
24451 {
24452 PyThreadState* __tstate = wxPyBeginAllowThreads();
24453 delete arg1;
24454
24455 wxPyEndAllowThreads(__tstate);
24456 if (PyErr_Occurred()) SWIG_fail;
24457 }
24458 Py_INCREF(Py_None); resultobj = Py_None;
24459 return resultobj;
24460 fail:
24461 return NULL;
24462 }
24463
24464
24465 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24466 PyObject *resultobj;
24467 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24468 int arg2 ;
24469 int arg3 ;
24470 int arg4 ;
24471 PyObject * obj0 = 0 ;
24472 PyObject * obj1 = 0 ;
24473 PyObject * obj2 = 0 ;
24474 PyObject * obj3 = 0 ;
24475 char *kwnames[] = {
24476 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24477 };
24478
24479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24481 if (SWIG_arg_fail(1)) SWIG_fail;
24482 {
24483 arg2 = (int)(SWIG_As_int(obj1));
24484 if (SWIG_arg_fail(2)) SWIG_fail;
24485 }
24486 {
24487 arg3 = (int)(SWIG_As_int(obj2));
24488 if (SWIG_arg_fail(3)) SWIG_fail;
24489 }
24490 {
24491 arg4 = (int)(SWIG_As_int(obj3));
24492 if (SWIG_arg_fail(4)) SWIG_fail;
24493 }
24494 {
24495 PyThreadState* __tstate = wxPyBeginAllowThreads();
24496 (arg1)->Set(arg2,arg3,arg4);
24497
24498 wxPyEndAllowThreads(__tstate);
24499 if (PyErr_Occurred()) SWIG_fail;
24500 }
24501 Py_INCREF(Py_None); resultobj = Py_None;
24502 return resultobj;
24503 fail:
24504 return NULL;
24505 }
24506
24507
24508 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24509 PyObject *resultobj;
24510 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24511 int result;
24512 PyObject * obj0 = 0 ;
24513 char *kwnames[] = {
24514 (char *) "self", NULL
24515 };
24516
24517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24519 if (SWIG_arg_fail(1)) SWIG_fail;
24520 {
24521 PyThreadState* __tstate = wxPyBeginAllowThreads();
24522 result = (int)(arg1)->GetFlags();
24523
24524 wxPyEndAllowThreads(__tstate);
24525 if (PyErr_Occurred()) SWIG_fail;
24526 }
24527 {
24528 resultobj = SWIG_From_int((int)(result));
24529 }
24530 return resultobj;
24531 fail:
24532 return NULL;
24533 }
24534
24535
24536 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24537 PyObject *resultobj;
24538 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24539 int result;
24540 PyObject * obj0 = 0 ;
24541 char *kwnames[] = {
24542 (char *) "self", NULL
24543 };
24544
24545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24547 if (SWIG_arg_fail(1)) SWIG_fail;
24548 {
24549 PyThreadState* __tstate = wxPyBeginAllowThreads();
24550 result = (int)(arg1)->GetKeyCode();
24551
24552 wxPyEndAllowThreads(__tstate);
24553 if (PyErr_Occurred()) SWIG_fail;
24554 }
24555 {
24556 resultobj = SWIG_From_int((int)(result));
24557 }
24558 return resultobj;
24559 fail:
24560 return NULL;
24561 }
24562
24563
24564 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24565 PyObject *resultobj;
24566 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24567 int result;
24568 PyObject * obj0 = 0 ;
24569 char *kwnames[] = {
24570 (char *) "self", NULL
24571 };
24572
24573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24575 if (SWIG_arg_fail(1)) SWIG_fail;
24576 {
24577 PyThreadState* __tstate = wxPyBeginAllowThreads();
24578 result = (int)(arg1)->GetCommand();
24579
24580 wxPyEndAllowThreads(__tstate);
24581 if (PyErr_Occurred()) SWIG_fail;
24582 }
24583 {
24584 resultobj = SWIG_From_int((int)(result));
24585 }
24586 return resultobj;
24587 fail:
24588 return NULL;
24589 }
24590
24591
24592 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24593 PyObject *obj;
24594 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24595 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24596 Py_INCREF(obj);
24597 return Py_BuildValue((char *)"");
24598 }
24599 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24600 PyObject *resultobj;
24601 int arg1 ;
24602 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24603 wxAcceleratorTable *result;
24604 PyObject * obj0 = 0 ;
24605 char *kwnames[] = {
24606 (char *) "n", NULL
24607 };
24608
24609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24610 {
24611 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24612 if (arg2) arg1 = PyList_Size(obj0);
24613 else arg1 = 0;
24614 }
24615 {
24616 PyThreadState* __tstate = wxPyBeginAllowThreads();
24617 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24618
24619 wxPyEndAllowThreads(__tstate);
24620 if (PyErr_Occurred()) SWIG_fail;
24621 }
24622 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24623 {
24624 delete [] arg2;
24625 }
24626 return resultobj;
24627 fail:
24628 {
24629 delete [] arg2;
24630 }
24631 return NULL;
24632 }
24633
24634
24635 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24636 PyObject *resultobj;
24637 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24638 PyObject * obj0 = 0 ;
24639 char *kwnames[] = {
24640 (char *) "self", NULL
24641 };
24642
24643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24645 if (SWIG_arg_fail(1)) SWIG_fail;
24646 {
24647 PyThreadState* __tstate = wxPyBeginAllowThreads();
24648 delete arg1;
24649
24650 wxPyEndAllowThreads(__tstate);
24651 if (PyErr_Occurred()) SWIG_fail;
24652 }
24653 Py_INCREF(Py_None); resultobj = Py_None;
24654 return resultobj;
24655 fail:
24656 return NULL;
24657 }
24658
24659
24660 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24661 PyObject *resultobj;
24662 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24663 bool result;
24664 PyObject * obj0 = 0 ;
24665 char *kwnames[] = {
24666 (char *) "self", NULL
24667 };
24668
24669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24671 if (SWIG_arg_fail(1)) SWIG_fail;
24672 {
24673 PyThreadState* __tstate = wxPyBeginAllowThreads();
24674 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24675
24676 wxPyEndAllowThreads(__tstate);
24677 if (PyErr_Occurred()) SWIG_fail;
24678 }
24679 {
24680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24681 }
24682 return resultobj;
24683 fail:
24684 return NULL;
24685 }
24686
24687
24688 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24689 PyObject *obj;
24690 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24691 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24692 Py_INCREF(obj);
24693 return Py_BuildValue((char *)"");
24694 }
24695 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24696 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24697 return 1;
24698 }
24699
24700
24701 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24702 PyObject *pyobj;
24703
24704 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24705 return pyobj;
24706 }
24707
24708
24709 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24710 PyObject *resultobj;
24711 wxString *arg1 = 0 ;
24712 wxAcceleratorEntry *result;
24713 bool temp1 = false ;
24714 PyObject * obj0 = 0 ;
24715 char *kwnames[] = {
24716 (char *) "label", NULL
24717 };
24718
24719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24720 {
24721 arg1 = wxString_in_helper(obj0);
24722 if (arg1 == NULL) SWIG_fail;
24723 temp1 = true;
24724 }
24725 {
24726 PyThreadState* __tstate = wxPyBeginAllowThreads();
24727 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24728
24729 wxPyEndAllowThreads(__tstate);
24730 if (PyErr_Occurred()) SWIG_fail;
24731 }
24732 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24733 {
24734 if (temp1)
24735 delete arg1;
24736 }
24737 return resultobj;
24738 fail:
24739 {
24740 if (temp1)
24741 delete arg1;
24742 }
24743 return NULL;
24744 }
24745
24746
24747 static int _wrap_PanelNameStr_set(PyObject *) {
24748 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24749 return 1;
24750 }
24751
24752
24753 static PyObject *_wrap_PanelNameStr_get(void) {
24754 PyObject *pyobj;
24755
24756 {
24757 #if wxUSE_UNICODE
24758 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24759 #else
24760 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24761 #endif
24762 }
24763 return pyobj;
24764 }
24765
24766
24767 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24768 PyObject *resultobj;
24769 wxVisualAttributes *result;
24770 char *kwnames[] = {
24771 NULL
24772 };
24773
24774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24775 {
24776 PyThreadState* __tstate = wxPyBeginAllowThreads();
24777 result = (wxVisualAttributes *)new_wxVisualAttributes();
24778
24779 wxPyEndAllowThreads(__tstate);
24780 if (PyErr_Occurred()) SWIG_fail;
24781 }
24782 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24783 return resultobj;
24784 fail:
24785 return NULL;
24786 }
24787
24788
24789 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24790 PyObject *resultobj;
24791 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24792 PyObject * obj0 = 0 ;
24793 char *kwnames[] = {
24794 (char *) "self", NULL
24795 };
24796
24797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24799 if (SWIG_arg_fail(1)) SWIG_fail;
24800 {
24801 PyThreadState* __tstate = wxPyBeginAllowThreads();
24802 delete_wxVisualAttributes(arg1);
24803
24804 wxPyEndAllowThreads(__tstate);
24805 if (PyErr_Occurred()) SWIG_fail;
24806 }
24807 Py_INCREF(Py_None); resultobj = Py_None;
24808 return resultobj;
24809 fail:
24810 return NULL;
24811 }
24812
24813
24814 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24815 PyObject *resultobj;
24816 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24817 wxFont *arg2 = (wxFont *) 0 ;
24818 PyObject * obj0 = 0 ;
24819 PyObject * obj1 = 0 ;
24820 char *kwnames[] = {
24821 (char *) "self",(char *) "font", NULL
24822 };
24823
24824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24826 if (SWIG_arg_fail(1)) SWIG_fail;
24827 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24828 if (SWIG_arg_fail(2)) SWIG_fail;
24829 if (arg1) (arg1)->font = *arg2;
24830
24831 Py_INCREF(Py_None); resultobj = Py_None;
24832 return resultobj;
24833 fail:
24834 return NULL;
24835 }
24836
24837
24838 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24839 PyObject *resultobj;
24840 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24841 wxFont *result;
24842 PyObject * obj0 = 0 ;
24843 char *kwnames[] = {
24844 (char *) "self", NULL
24845 };
24846
24847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24849 if (SWIG_arg_fail(1)) SWIG_fail;
24850 result = (wxFont *)& ((arg1)->font);
24851
24852 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24853 return resultobj;
24854 fail:
24855 return NULL;
24856 }
24857
24858
24859 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24860 PyObject *resultobj;
24861 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24862 wxColour *arg2 = (wxColour *) 0 ;
24863 PyObject * obj0 = 0 ;
24864 PyObject * obj1 = 0 ;
24865 char *kwnames[] = {
24866 (char *) "self",(char *) "colFg", NULL
24867 };
24868
24869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24871 if (SWIG_arg_fail(1)) SWIG_fail;
24872 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24873 if (SWIG_arg_fail(2)) SWIG_fail;
24874 if (arg1) (arg1)->colFg = *arg2;
24875
24876 Py_INCREF(Py_None); resultobj = Py_None;
24877 return resultobj;
24878 fail:
24879 return NULL;
24880 }
24881
24882
24883 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24884 PyObject *resultobj;
24885 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24886 wxColour *result;
24887 PyObject * obj0 = 0 ;
24888 char *kwnames[] = {
24889 (char *) "self", NULL
24890 };
24891
24892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24894 if (SWIG_arg_fail(1)) SWIG_fail;
24895 result = (wxColour *)& ((arg1)->colFg);
24896
24897 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24898 return resultobj;
24899 fail:
24900 return NULL;
24901 }
24902
24903
24904 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24905 PyObject *resultobj;
24906 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24907 wxColour *arg2 = (wxColour *) 0 ;
24908 PyObject * obj0 = 0 ;
24909 PyObject * obj1 = 0 ;
24910 char *kwnames[] = {
24911 (char *) "self",(char *) "colBg", NULL
24912 };
24913
24914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24916 if (SWIG_arg_fail(1)) SWIG_fail;
24917 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24918 if (SWIG_arg_fail(2)) SWIG_fail;
24919 if (arg1) (arg1)->colBg = *arg2;
24920
24921 Py_INCREF(Py_None); resultobj = Py_None;
24922 return resultobj;
24923 fail:
24924 return NULL;
24925 }
24926
24927
24928 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24929 PyObject *resultobj;
24930 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24931 wxColour *result;
24932 PyObject * obj0 = 0 ;
24933 char *kwnames[] = {
24934 (char *) "self", NULL
24935 };
24936
24937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24939 if (SWIG_arg_fail(1)) SWIG_fail;
24940 result = (wxColour *)& ((arg1)->colBg);
24941
24942 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24943 return resultobj;
24944 fail:
24945 return NULL;
24946 }
24947
24948
24949 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24950 PyObject *obj;
24951 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24952 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24953 Py_INCREF(obj);
24954 return Py_BuildValue((char *)"");
24955 }
24956 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24957 PyObject *resultobj;
24958 wxWindow *arg1 = (wxWindow *) 0 ;
24959 int arg2 = (int) (int)-1 ;
24960 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24961 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24962 wxSize const &arg4_defvalue = wxDefaultSize ;
24963 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24964 long arg5 = (long) 0 ;
24965 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24966 wxString *arg6 = (wxString *) &arg6_defvalue ;
24967 wxWindow *result;
24968 wxPoint temp3 ;
24969 wxSize temp4 ;
24970 bool temp6 = false ;
24971 PyObject * obj0 = 0 ;
24972 PyObject * obj1 = 0 ;
24973 PyObject * obj2 = 0 ;
24974 PyObject * obj3 = 0 ;
24975 PyObject * obj4 = 0 ;
24976 PyObject * obj5 = 0 ;
24977 char *kwnames[] = {
24978 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24979 };
24980
24981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24983 if (SWIG_arg_fail(1)) SWIG_fail;
24984 if (obj1) {
24985 {
24986 arg2 = (int const)(SWIG_As_int(obj1));
24987 if (SWIG_arg_fail(2)) SWIG_fail;
24988 }
24989 }
24990 if (obj2) {
24991 {
24992 arg3 = &temp3;
24993 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24994 }
24995 }
24996 if (obj3) {
24997 {
24998 arg4 = &temp4;
24999 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25000 }
25001 }
25002 if (obj4) {
25003 {
25004 arg5 = (long)(SWIG_As_long(obj4));
25005 if (SWIG_arg_fail(5)) SWIG_fail;
25006 }
25007 }
25008 if (obj5) {
25009 {
25010 arg6 = wxString_in_helper(obj5);
25011 if (arg6 == NULL) SWIG_fail;
25012 temp6 = true;
25013 }
25014 }
25015 {
25016 if (!wxPyCheckForApp()) SWIG_fail;
25017 PyThreadState* __tstate = wxPyBeginAllowThreads();
25018 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25019
25020 wxPyEndAllowThreads(__tstate);
25021 if (PyErr_Occurred()) SWIG_fail;
25022 }
25023 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25024 {
25025 if (temp6)
25026 delete arg6;
25027 }
25028 return resultobj;
25029 fail:
25030 {
25031 if (temp6)
25032 delete arg6;
25033 }
25034 return NULL;
25035 }
25036
25037
25038 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25039 PyObject *resultobj;
25040 wxWindow *result;
25041 char *kwnames[] = {
25042 NULL
25043 };
25044
25045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25046 {
25047 if (!wxPyCheckForApp()) SWIG_fail;
25048 PyThreadState* __tstate = wxPyBeginAllowThreads();
25049 result = (wxWindow *)new wxWindow();
25050
25051 wxPyEndAllowThreads(__tstate);
25052 if (PyErr_Occurred()) SWIG_fail;
25053 }
25054 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25055 return resultobj;
25056 fail:
25057 return NULL;
25058 }
25059
25060
25061 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25062 PyObject *resultobj;
25063 wxWindow *arg1 = (wxWindow *) 0 ;
25064 wxWindow *arg2 = (wxWindow *) 0 ;
25065 int arg3 = (int) (int)-1 ;
25066 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25067 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25068 wxSize const &arg5_defvalue = wxDefaultSize ;
25069 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25070 long arg6 = (long) 0 ;
25071 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25072 wxString *arg7 = (wxString *) &arg7_defvalue ;
25073 bool result;
25074 wxPoint temp4 ;
25075 wxSize temp5 ;
25076 bool temp7 = false ;
25077 PyObject * obj0 = 0 ;
25078 PyObject * obj1 = 0 ;
25079 PyObject * obj2 = 0 ;
25080 PyObject * obj3 = 0 ;
25081 PyObject * obj4 = 0 ;
25082 PyObject * obj5 = 0 ;
25083 PyObject * obj6 = 0 ;
25084 char *kwnames[] = {
25085 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25086 };
25087
25088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25090 if (SWIG_arg_fail(1)) SWIG_fail;
25091 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25092 if (SWIG_arg_fail(2)) SWIG_fail;
25093 if (obj2) {
25094 {
25095 arg3 = (int const)(SWIG_As_int(obj2));
25096 if (SWIG_arg_fail(3)) SWIG_fail;
25097 }
25098 }
25099 if (obj3) {
25100 {
25101 arg4 = &temp4;
25102 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25103 }
25104 }
25105 if (obj4) {
25106 {
25107 arg5 = &temp5;
25108 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25109 }
25110 }
25111 if (obj5) {
25112 {
25113 arg6 = (long)(SWIG_As_long(obj5));
25114 if (SWIG_arg_fail(6)) SWIG_fail;
25115 }
25116 }
25117 if (obj6) {
25118 {
25119 arg7 = wxString_in_helper(obj6);
25120 if (arg7 == NULL) SWIG_fail;
25121 temp7 = true;
25122 }
25123 }
25124 {
25125 PyThreadState* __tstate = wxPyBeginAllowThreads();
25126 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25127
25128 wxPyEndAllowThreads(__tstate);
25129 if (PyErr_Occurred()) SWIG_fail;
25130 }
25131 {
25132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25133 }
25134 {
25135 if (temp7)
25136 delete arg7;
25137 }
25138 return resultobj;
25139 fail:
25140 {
25141 if (temp7)
25142 delete arg7;
25143 }
25144 return NULL;
25145 }
25146
25147
25148 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25149 PyObject *resultobj;
25150 wxWindow *arg1 = (wxWindow *) 0 ;
25151 bool arg2 = (bool) false ;
25152 bool result;
25153 PyObject * obj0 = 0 ;
25154 PyObject * obj1 = 0 ;
25155 char *kwnames[] = {
25156 (char *) "self",(char *) "force", NULL
25157 };
25158
25159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
25160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25161 if (SWIG_arg_fail(1)) SWIG_fail;
25162 if (obj1) {
25163 {
25164 arg2 = (bool)(SWIG_As_bool(obj1));
25165 if (SWIG_arg_fail(2)) SWIG_fail;
25166 }
25167 }
25168 {
25169 PyThreadState* __tstate = wxPyBeginAllowThreads();
25170 result = (bool)(arg1)->Close(arg2);
25171
25172 wxPyEndAllowThreads(__tstate);
25173 if (PyErr_Occurred()) SWIG_fail;
25174 }
25175 {
25176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25177 }
25178 return resultobj;
25179 fail:
25180 return NULL;
25181 }
25182
25183
25184 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25185 PyObject *resultobj;
25186 wxWindow *arg1 = (wxWindow *) 0 ;
25187 bool result;
25188 PyObject * obj0 = 0 ;
25189 char *kwnames[] = {
25190 (char *) "self", NULL
25191 };
25192
25193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25195 if (SWIG_arg_fail(1)) SWIG_fail;
25196 {
25197 PyThreadState* __tstate = wxPyBeginAllowThreads();
25198 result = (bool)(arg1)->Destroy();
25199
25200 wxPyEndAllowThreads(__tstate);
25201 if (PyErr_Occurred()) SWIG_fail;
25202 }
25203 {
25204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25205 }
25206 return resultobj;
25207 fail:
25208 return NULL;
25209 }
25210
25211
25212 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25213 PyObject *resultobj;
25214 wxWindow *arg1 = (wxWindow *) 0 ;
25215 bool result;
25216 PyObject * obj0 = 0 ;
25217 char *kwnames[] = {
25218 (char *) "self", NULL
25219 };
25220
25221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25223 if (SWIG_arg_fail(1)) SWIG_fail;
25224 {
25225 PyThreadState* __tstate = wxPyBeginAllowThreads();
25226 result = (bool)(arg1)->DestroyChildren();
25227
25228 wxPyEndAllowThreads(__tstate);
25229 if (PyErr_Occurred()) SWIG_fail;
25230 }
25231 {
25232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25233 }
25234 return resultobj;
25235 fail:
25236 return NULL;
25237 }
25238
25239
25240 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25241 PyObject *resultobj;
25242 wxWindow *arg1 = (wxWindow *) 0 ;
25243 bool result;
25244 PyObject * obj0 = 0 ;
25245 char *kwnames[] = {
25246 (char *) "self", NULL
25247 };
25248
25249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25251 if (SWIG_arg_fail(1)) SWIG_fail;
25252 {
25253 PyThreadState* __tstate = wxPyBeginAllowThreads();
25254 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25255
25256 wxPyEndAllowThreads(__tstate);
25257 if (PyErr_Occurred()) SWIG_fail;
25258 }
25259 {
25260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25261 }
25262 return resultobj;
25263 fail:
25264 return NULL;
25265 }
25266
25267
25268 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25269 PyObject *resultobj;
25270 wxWindow *arg1 = (wxWindow *) 0 ;
25271 wxString *arg2 = 0 ;
25272 bool temp2 = false ;
25273 PyObject * obj0 = 0 ;
25274 PyObject * obj1 = 0 ;
25275 char *kwnames[] = {
25276 (char *) "self",(char *) "title", NULL
25277 };
25278
25279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
25280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25281 if (SWIG_arg_fail(1)) SWIG_fail;
25282 {
25283 arg2 = wxString_in_helper(obj1);
25284 if (arg2 == NULL) SWIG_fail;
25285 temp2 = true;
25286 }
25287 {
25288 PyThreadState* __tstate = wxPyBeginAllowThreads();
25289 (arg1)->SetTitle((wxString const &)*arg2);
25290
25291 wxPyEndAllowThreads(__tstate);
25292 if (PyErr_Occurred()) SWIG_fail;
25293 }
25294 Py_INCREF(Py_None); resultobj = Py_None;
25295 {
25296 if (temp2)
25297 delete arg2;
25298 }
25299 return resultobj;
25300 fail:
25301 {
25302 if (temp2)
25303 delete arg2;
25304 }
25305 return NULL;
25306 }
25307
25308
25309 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25310 PyObject *resultobj;
25311 wxWindow *arg1 = (wxWindow *) 0 ;
25312 wxString result;
25313 PyObject * obj0 = 0 ;
25314 char *kwnames[] = {
25315 (char *) "self", NULL
25316 };
25317
25318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
25319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25320 if (SWIG_arg_fail(1)) SWIG_fail;
25321 {
25322 PyThreadState* __tstate = wxPyBeginAllowThreads();
25323 result = ((wxWindow const *)arg1)->GetTitle();
25324
25325 wxPyEndAllowThreads(__tstate);
25326 if (PyErr_Occurred()) SWIG_fail;
25327 }
25328 {
25329 #if wxUSE_UNICODE
25330 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25331 #else
25332 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25333 #endif
25334 }
25335 return resultobj;
25336 fail:
25337 return NULL;
25338 }
25339
25340
25341 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25342 PyObject *resultobj;
25343 wxWindow *arg1 = (wxWindow *) 0 ;
25344 wxString *arg2 = 0 ;
25345 bool temp2 = false ;
25346 PyObject * obj0 = 0 ;
25347 PyObject * obj1 = 0 ;
25348 char *kwnames[] = {
25349 (char *) "self",(char *) "label", NULL
25350 };
25351
25352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) 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 = wxString_in_helper(obj1);
25357 if (arg2 == NULL) SWIG_fail;
25358 temp2 = true;
25359 }
25360 {
25361 PyThreadState* __tstate = wxPyBeginAllowThreads();
25362 (arg1)->SetLabel((wxString const &)*arg2);
25363
25364 wxPyEndAllowThreads(__tstate);
25365 if (PyErr_Occurred()) SWIG_fail;
25366 }
25367 Py_INCREF(Py_None); resultobj = Py_None;
25368 {
25369 if (temp2)
25370 delete arg2;
25371 }
25372 return resultobj;
25373 fail:
25374 {
25375 if (temp2)
25376 delete arg2;
25377 }
25378 return NULL;
25379 }
25380
25381
25382 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25383 PyObject *resultobj;
25384 wxWindow *arg1 = (wxWindow *) 0 ;
25385 wxString result;
25386 PyObject * obj0 = 0 ;
25387 char *kwnames[] = {
25388 (char *) "self", NULL
25389 };
25390
25391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
25396 result = ((wxWindow const *)arg1)->GetLabel();
25397
25398 wxPyEndAllowThreads(__tstate);
25399 if (PyErr_Occurred()) SWIG_fail;
25400 }
25401 {
25402 #if wxUSE_UNICODE
25403 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25404 #else
25405 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25406 #endif
25407 }
25408 return resultobj;
25409 fail:
25410 return NULL;
25411 }
25412
25413
25414 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25415 PyObject *resultobj;
25416 wxWindow *arg1 = (wxWindow *) 0 ;
25417 wxString *arg2 = 0 ;
25418 bool temp2 = false ;
25419 PyObject * obj0 = 0 ;
25420 PyObject * obj1 = 0 ;
25421 char *kwnames[] = {
25422 (char *) "self",(char *) "name", NULL
25423 };
25424
25425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25427 if (SWIG_arg_fail(1)) SWIG_fail;
25428 {
25429 arg2 = wxString_in_helper(obj1);
25430 if (arg2 == NULL) SWIG_fail;
25431 temp2 = true;
25432 }
25433 {
25434 PyThreadState* __tstate = wxPyBeginAllowThreads();
25435 (arg1)->SetName((wxString const &)*arg2);
25436
25437 wxPyEndAllowThreads(__tstate);
25438 if (PyErr_Occurred()) SWIG_fail;
25439 }
25440 Py_INCREF(Py_None); resultobj = Py_None;
25441 {
25442 if (temp2)
25443 delete arg2;
25444 }
25445 return resultobj;
25446 fail:
25447 {
25448 if (temp2)
25449 delete arg2;
25450 }
25451 return NULL;
25452 }
25453
25454
25455 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25456 PyObject *resultobj;
25457 wxWindow *arg1 = (wxWindow *) 0 ;
25458 wxString result;
25459 PyObject * obj0 = 0 ;
25460 char *kwnames[] = {
25461 (char *) "self", NULL
25462 };
25463
25464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25466 if (SWIG_arg_fail(1)) SWIG_fail;
25467 {
25468 PyThreadState* __tstate = wxPyBeginAllowThreads();
25469 result = ((wxWindow const *)arg1)->GetName();
25470
25471 wxPyEndAllowThreads(__tstate);
25472 if (PyErr_Occurred()) SWIG_fail;
25473 }
25474 {
25475 #if wxUSE_UNICODE
25476 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25477 #else
25478 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25479 #endif
25480 }
25481 return resultobj;
25482 fail:
25483 return NULL;
25484 }
25485
25486
25487 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25488 PyObject *resultobj;
25489 wxWindow *arg1 = (wxWindow *) 0 ;
25490 wxWindowVariant arg2 ;
25491 PyObject * obj0 = 0 ;
25492 PyObject * obj1 = 0 ;
25493 char *kwnames[] = {
25494 (char *) "self",(char *) "variant", NULL
25495 };
25496
25497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25499 if (SWIG_arg_fail(1)) SWIG_fail;
25500 {
25501 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25502 if (SWIG_arg_fail(2)) SWIG_fail;
25503 }
25504 {
25505 PyThreadState* __tstate = wxPyBeginAllowThreads();
25506 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25507
25508 wxPyEndAllowThreads(__tstate);
25509 if (PyErr_Occurred()) SWIG_fail;
25510 }
25511 Py_INCREF(Py_None); resultobj = Py_None;
25512 return resultobj;
25513 fail:
25514 return NULL;
25515 }
25516
25517
25518 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25519 PyObject *resultobj;
25520 wxWindow *arg1 = (wxWindow *) 0 ;
25521 wxWindowVariant result;
25522 PyObject * obj0 = 0 ;
25523 char *kwnames[] = {
25524 (char *) "self", NULL
25525 };
25526
25527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25529 if (SWIG_arg_fail(1)) SWIG_fail;
25530 {
25531 PyThreadState* __tstate = wxPyBeginAllowThreads();
25532 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25533
25534 wxPyEndAllowThreads(__tstate);
25535 if (PyErr_Occurred()) SWIG_fail;
25536 }
25537 resultobj = SWIG_From_int((result));
25538 return resultobj;
25539 fail:
25540 return NULL;
25541 }
25542
25543
25544 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25545 PyObject *resultobj;
25546 wxWindow *arg1 = (wxWindow *) 0 ;
25547 int arg2 ;
25548 PyObject * obj0 = 0 ;
25549 PyObject * obj1 = 0 ;
25550 char *kwnames[] = {
25551 (char *) "self",(char *) "winid", NULL
25552 };
25553
25554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25556 if (SWIG_arg_fail(1)) SWIG_fail;
25557 {
25558 arg2 = (int)(SWIG_As_int(obj1));
25559 if (SWIG_arg_fail(2)) SWIG_fail;
25560 }
25561 {
25562 PyThreadState* __tstate = wxPyBeginAllowThreads();
25563 (arg1)->SetId(arg2);
25564
25565 wxPyEndAllowThreads(__tstate);
25566 if (PyErr_Occurred()) SWIG_fail;
25567 }
25568 Py_INCREF(Py_None); resultobj = Py_None;
25569 return resultobj;
25570 fail:
25571 return NULL;
25572 }
25573
25574
25575 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25576 PyObject *resultobj;
25577 wxWindow *arg1 = (wxWindow *) 0 ;
25578 int result;
25579 PyObject * obj0 = 0 ;
25580 char *kwnames[] = {
25581 (char *) "self", NULL
25582 };
25583
25584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25586 if (SWIG_arg_fail(1)) SWIG_fail;
25587 {
25588 PyThreadState* __tstate = wxPyBeginAllowThreads();
25589 result = (int)((wxWindow const *)arg1)->GetId();
25590
25591 wxPyEndAllowThreads(__tstate);
25592 if (PyErr_Occurred()) SWIG_fail;
25593 }
25594 {
25595 resultobj = SWIG_From_int((int)(result));
25596 }
25597 return resultobj;
25598 fail:
25599 return NULL;
25600 }
25601
25602
25603 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25604 PyObject *resultobj;
25605 int result;
25606 char *kwnames[] = {
25607 NULL
25608 };
25609
25610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25611 {
25612 PyThreadState* __tstate = wxPyBeginAllowThreads();
25613 result = (int)wxWindow::NewControlId();
25614
25615 wxPyEndAllowThreads(__tstate);
25616 if (PyErr_Occurred()) SWIG_fail;
25617 }
25618 {
25619 resultobj = SWIG_From_int((int)(result));
25620 }
25621 return resultobj;
25622 fail:
25623 return NULL;
25624 }
25625
25626
25627 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25628 PyObject *resultobj;
25629 int arg1 ;
25630 int result;
25631 PyObject * obj0 = 0 ;
25632 char *kwnames[] = {
25633 (char *) "winid", NULL
25634 };
25635
25636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25637 {
25638 arg1 = (int)(SWIG_As_int(obj0));
25639 if (SWIG_arg_fail(1)) SWIG_fail;
25640 }
25641 {
25642 PyThreadState* __tstate = wxPyBeginAllowThreads();
25643 result = (int)wxWindow::NextControlId(arg1);
25644
25645 wxPyEndAllowThreads(__tstate);
25646 if (PyErr_Occurred()) SWIG_fail;
25647 }
25648 {
25649 resultobj = SWIG_From_int((int)(result));
25650 }
25651 return resultobj;
25652 fail:
25653 return NULL;
25654 }
25655
25656
25657 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25658 PyObject *resultobj;
25659 int arg1 ;
25660 int result;
25661 PyObject * obj0 = 0 ;
25662 char *kwnames[] = {
25663 (char *) "winid", NULL
25664 };
25665
25666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25667 {
25668 arg1 = (int)(SWIG_As_int(obj0));
25669 if (SWIG_arg_fail(1)) SWIG_fail;
25670 }
25671 {
25672 PyThreadState* __tstate = wxPyBeginAllowThreads();
25673 result = (int)wxWindow::PrevControlId(arg1);
25674
25675 wxPyEndAllowThreads(__tstate);
25676 if (PyErr_Occurred()) SWIG_fail;
25677 }
25678 {
25679 resultobj = SWIG_From_int((int)(result));
25680 }
25681 return resultobj;
25682 fail:
25683 return NULL;
25684 }
25685
25686
25687 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25688 PyObject *resultobj;
25689 wxWindow *arg1 = (wxWindow *) 0 ;
25690 wxSize *arg2 = 0 ;
25691 wxSize temp2 ;
25692 PyObject * obj0 = 0 ;
25693 PyObject * obj1 = 0 ;
25694 char *kwnames[] = {
25695 (char *) "self",(char *) "size", NULL
25696 };
25697
25698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25700 if (SWIG_arg_fail(1)) SWIG_fail;
25701 {
25702 arg2 = &temp2;
25703 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25704 }
25705 {
25706 PyThreadState* __tstate = wxPyBeginAllowThreads();
25707 (arg1)->SetSize((wxSize const &)*arg2);
25708
25709 wxPyEndAllowThreads(__tstate);
25710 if (PyErr_Occurred()) SWIG_fail;
25711 }
25712 Py_INCREF(Py_None); resultobj = Py_None;
25713 return resultobj;
25714 fail:
25715 return NULL;
25716 }
25717
25718
25719 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25720 PyObject *resultobj;
25721 wxWindow *arg1 = (wxWindow *) 0 ;
25722 int arg2 ;
25723 int arg3 ;
25724 int arg4 ;
25725 int arg5 ;
25726 int arg6 = (int) wxSIZE_AUTO ;
25727 PyObject * obj0 = 0 ;
25728 PyObject * obj1 = 0 ;
25729 PyObject * obj2 = 0 ;
25730 PyObject * obj3 = 0 ;
25731 PyObject * obj4 = 0 ;
25732 PyObject * obj5 = 0 ;
25733 char *kwnames[] = {
25734 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25735 };
25736
25737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25739 if (SWIG_arg_fail(1)) SWIG_fail;
25740 {
25741 arg2 = (int)(SWIG_As_int(obj1));
25742 if (SWIG_arg_fail(2)) SWIG_fail;
25743 }
25744 {
25745 arg3 = (int)(SWIG_As_int(obj2));
25746 if (SWIG_arg_fail(3)) SWIG_fail;
25747 }
25748 {
25749 arg4 = (int)(SWIG_As_int(obj3));
25750 if (SWIG_arg_fail(4)) SWIG_fail;
25751 }
25752 {
25753 arg5 = (int)(SWIG_As_int(obj4));
25754 if (SWIG_arg_fail(5)) SWIG_fail;
25755 }
25756 if (obj5) {
25757 {
25758 arg6 = (int)(SWIG_As_int(obj5));
25759 if (SWIG_arg_fail(6)) SWIG_fail;
25760 }
25761 }
25762 {
25763 PyThreadState* __tstate = wxPyBeginAllowThreads();
25764 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25765
25766 wxPyEndAllowThreads(__tstate);
25767 if (PyErr_Occurred()) SWIG_fail;
25768 }
25769 Py_INCREF(Py_None); resultobj = Py_None;
25770 return resultobj;
25771 fail:
25772 return NULL;
25773 }
25774
25775
25776 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25777 PyObject *resultobj;
25778 wxWindow *arg1 = (wxWindow *) 0 ;
25779 wxRect *arg2 = 0 ;
25780 int arg3 = (int) wxSIZE_AUTO ;
25781 wxRect temp2 ;
25782 PyObject * obj0 = 0 ;
25783 PyObject * obj1 = 0 ;
25784 PyObject * obj2 = 0 ;
25785 char *kwnames[] = {
25786 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25787 };
25788
25789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25791 if (SWIG_arg_fail(1)) SWIG_fail;
25792 {
25793 arg2 = &temp2;
25794 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25795 }
25796 if (obj2) {
25797 {
25798 arg3 = (int)(SWIG_As_int(obj2));
25799 if (SWIG_arg_fail(3)) SWIG_fail;
25800 }
25801 }
25802 {
25803 PyThreadState* __tstate = wxPyBeginAllowThreads();
25804 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25805
25806 wxPyEndAllowThreads(__tstate);
25807 if (PyErr_Occurred()) SWIG_fail;
25808 }
25809 Py_INCREF(Py_None); resultobj = Py_None;
25810 return resultobj;
25811 fail:
25812 return NULL;
25813 }
25814
25815
25816 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25817 PyObject *resultobj;
25818 wxWindow *arg1 = (wxWindow *) 0 ;
25819 int arg2 ;
25820 int arg3 ;
25821 PyObject * obj0 = 0 ;
25822 PyObject * obj1 = 0 ;
25823 PyObject * obj2 = 0 ;
25824 char *kwnames[] = {
25825 (char *) "self",(char *) "width",(char *) "height", NULL
25826 };
25827
25828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25830 if (SWIG_arg_fail(1)) SWIG_fail;
25831 {
25832 arg2 = (int)(SWIG_As_int(obj1));
25833 if (SWIG_arg_fail(2)) SWIG_fail;
25834 }
25835 {
25836 arg3 = (int)(SWIG_As_int(obj2));
25837 if (SWIG_arg_fail(3)) SWIG_fail;
25838 }
25839 {
25840 PyThreadState* __tstate = wxPyBeginAllowThreads();
25841 (arg1)->SetSize(arg2,arg3);
25842
25843 wxPyEndAllowThreads(__tstate);
25844 if (PyErr_Occurred()) SWIG_fail;
25845 }
25846 Py_INCREF(Py_None); resultobj = Py_None;
25847 return resultobj;
25848 fail:
25849 return NULL;
25850 }
25851
25852
25853 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25854 PyObject *resultobj;
25855 wxWindow *arg1 = (wxWindow *) 0 ;
25856 wxPoint *arg2 = 0 ;
25857 int arg3 = (int) wxSIZE_USE_EXISTING ;
25858 wxPoint temp2 ;
25859 PyObject * obj0 = 0 ;
25860 PyObject * obj1 = 0 ;
25861 PyObject * obj2 = 0 ;
25862 char *kwnames[] = {
25863 (char *) "self",(char *) "pt",(char *) "flags", NULL
25864 };
25865
25866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25868 if (SWIG_arg_fail(1)) SWIG_fail;
25869 {
25870 arg2 = &temp2;
25871 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25872 }
25873 if (obj2) {
25874 {
25875 arg3 = (int)(SWIG_As_int(obj2));
25876 if (SWIG_arg_fail(3)) SWIG_fail;
25877 }
25878 }
25879 {
25880 PyThreadState* __tstate = wxPyBeginAllowThreads();
25881 (arg1)->Move((wxPoint const &)*arg2,arg3);
25882
25883 wxPyEndAllowThreads(__tstate);
25884 if (PyErr_Occurred()) SWIG_fail;
25885 }
25886 Py_INCREF(Py_None); resultobj = Py_None;
25887 return resultobj;
25888 fail:
25889 return NULL;
25890 }
25891
25892
25893 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25894 PyObject *resultobj;
25895 wxWindow *arg1 = (wxWindow *) 0 ;
25896 int arg2 ;
25897 int arg3 ;
25898 int arg4 = (int) wxSIZE_USE_EXISTING ;
25899 PyObject * obj0 = 0 ;
25900 PyObject * obj1 = 0 ;
25901 PyObject * obj2 = 0 ;
25902 PyObject * obj3 = 0 ;
25903 char *kwnames[] = {
25904 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25905 };
25906
25907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25909 if (SWIG_arg_fail(1)) SWIG_fail;
25910 {
25911 arg2 = (int)(SWIG_As_int(obj1));
25912 if (SWIG_arg_fail(2)) SWIG_fail;
25913 }
25914 {
25915 arg3 = (int)(SWIG_As_int(obj2));
25916 if (SWIG_arg_fail(3)) SWIG_fail;
25917 }
25918 if (obj3) {
25919 {
25920 arg4 = (int)(SWIG_As_int(obj3));
25921 if (SWIG_arg_fail(4)) SWIG_fail;
25922 }
25923 }
25924 {
25925 PyThreadState* __tstate = wxPyBeginAllowThreads();
25926 (arg1)->Move(arg2,arg3,arg4);
25927
25928 wxPyEndAllowThreads(__tstate);
25929 if (PyErr_Occurred()) SWIG_fail;
25930 }
25931 Py_INCREF(Py_None); resultobj = Py_None;
25932 return resultobj;
25933 fail:
25934 return NULL;
25935 }
25936
25937
25938 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25939 PyObject *resultobj;
25940 wxWindow *arg1 = (wxWindow *) 0 ;
25941 wxSize const &arg2_defvalue = wxDefaultSize ;
25942 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25943 wxSize temp2 ;
25944 PyObject * obj0 = 0 ;
25945 PyObject * obj1 = 0 ;
25946 char *kwnames[] = {
25947 (char *) "self",(char *) "size", NULL
25948 };
25949
25950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25952 if (SWIG_arg_fail(1)) SWIG_fail;
25953 if (obj1) {
25954 {
25955 arg2 = &temp2;
25956 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25957 }
25958 }
25959 {
25960 PyThreadState* __tstate = wxPyBeginAllowThreads();
25961 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25962
25963 wxPyEndAllowThreads(__tstate);
25964 if (PyErr_Occurred()) SWIG_fail;
25965 }
25966 Py_INCREF(Py_None); resultobj = Py_None;
25967 return resultobj;
25968 fail:
25969 return NULL;
25970 }
25971
25972
25973 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25974 PyObject *resultobj;
25975 wxWindow *arg1 = (wxWindow *) 0 ;
25976 PyObject * obj0 = 0 ;
25977 char *kwnames[] = {
25978 (char *) "self", NULL
25979 };
25980
25981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25983 if (SWIG_arg_fail(1)) SWIG_fail;
25984 {
25985 PyThreadState* __tstate = wxPyBeginAllowThreads();
25986 (arg1)->Raise();
25987
25988 wxPyEndAllowThreads(__tstate);
25989 if (PyErr_Occurred()) SWIG_fail;
25990 }
25991 Py_INCREF(Py_None); resultobj = Py_None;
25992 return resultobj;
25993 fail:
25994 return NULL;
25995 }
25996
25997
25998 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25999 PyObject *resultobj;
26000 wxWindow *arg1 = (wxWindow *) 0 ;
26001 PyObject * obj0 = 0 ;
26002 char *kwnames[] = {
26003 (char *) "self", NULL
26004 };
26005
26006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26008 if (SWIG_arg_fail(1)) SWIG_fail;
26009 {
26010 PyThreadState* __tstate = wxPyBeginAllowThreads();
26011 (arg1)->Lower();
26012
26013 wxPyEndAllowThreads(__tstate);
26014 if (PyErr_Occurred()) SWIG_fail;
26015 }
26016 Py_INCREF(Py_None); resultobj = Py_None;
26017 return resultobj;
26018 fail:
26019 return NULL;
26020 }
26021
26022
26023 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26024 PyObject *resultobj;
26025 wxWindow *arg1 = (wxWindow *) 0 ;
26026 wxSize *arg2 = 0 ;
26027 wxSize temp2 ;
26028 PyObject * obj0 = 0 ;
26029 PyObject * obj1 = 0 ;
26030 char *kwnames[] = {
26031 (char *) "self",(char *) "size", NULL
26032 };
26033
26034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26036 if (SWIG_arg_fail(1)) SWIG_fail;
26037 {
26038 arg2 = &temp2;
26039 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26040 }
26041 {
26042 PyThreadState* __tstate = wxPyBeginAllowThreads();
26043 (arg1)->SetClientSize((wxSize const &)*arg2);
26044
26045 wxPyEndAllowThreads(__tstate);
26046 if (PyErr_Occurred()) SWIG_fail;
26047 }
26048 Py_INCREF(Py_None); resultobj = Py_None;
26049 return resultobj;
26050 fail:
26051 return NULL;
26052 }
26053
26054
26055 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26056 PyObject *resultobj;
26057 wxWindow *arg1 = (wxWindow *) 0 ;
26058 int arg2 ;
26059 int arg3 ;
26060 PyObject * obj0 = 0 ;
26061 PyObject * obj1 = 0 ;
26062 PyObject * obj2 = 0 ;
26063 char *kwnames[] = {
26064 (char *) "self",(char *) "width",(char *) "height", NULL
26065 };
26066
26067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26069 if (SWIG_arg_fail(1)) SWIG_fail;
26070 {
26071 arg2 = (int)(SWIG_As_int(obj1));
26072 if (SWIG_arg_fail(2)) SWIG_fail;
26073 }
26074 {
26075 arg3 = (int)(SWIG_As_int(obj2));
26076 if (SWIG_arg_fail(3)) SWIG_fail;
26077 }
26078 {
26079 PyThreadState* __tstate = wxPyBeginAllowThreads();
26080 (arg1)->SetClientSize(arg2,arg3);
26081
26082 wxPyEndAllowThreads(__tstate);
26083 if (PyErr_Occurred()) SWIG_fail;
26084 }
26085 Py_INCREF(Py_None); resultobj = Py_None;
26086 return resultobj;
26087 fail:
26088 return NULL;
26089 }
26090
26091
26092 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26093 PyObject *resultobj;
26094 wxWindow *arg1 = (wxWindow *) 0 ;
26095 wxRect *arg2 = 0 ;
26096 wxRect temp2 ;
26097 PyObject * obj0 = 0 ;
26098 PyObject * obj1 = 0 ;
26099 char *kwnames[] = {
26100 (char *) "self",(char *) "rect", NULL
26101 };
26102
26103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26105 if (SWIG_arg_fail(1)) SWIG_fail;
26106 {
26107 arg2 = &temp2;
26108 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26109 }
26110 {
26111 PyThreadState* __tstate = wxPyBeginAllowThreads();
26112 (arg1)->SetClientSize((wxRect const &)*arg2);
26113
26114 wxPyEndAllowThreads(__tstate);
26115 if (PyErr_Occurred()) SWIG_fail;
26116 }
26117 Py_INCREF(Py_None); resultobj = Py_None;
26118 return resultobj;
26119 fail:
26120 return NULL;
26121 }
26122
26123
26124 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26125 PyObject *resultobj;
26126 wxWindow *arg1 = (wxWindow *) 0 ;
26127 wxPoint result;
26128 PyObject * obj0 = 0 ;
26129 char *kwnames[] = {
26130 (char *) "self", NULL
26131 };
26132
26133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26135 if (SWIG_arg_fail(1)) SWIG_fail;
26136 {
26137 PyThreadState* __tstate = wxPyBeginAllowThreads();
26138 result = (arg1)->GetPosition();
26139
26140 wxPyEndAllowThreads(__tstate);
26141 if (PyErr_Occurred()) SWIG_fail;
26142 }
26143 {
26144 wxPoint * resultptr;
26145 resultptr = new wxPoint((wxPoint &)(result));
26146 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26147 }
26148 return resultobj;
26149 fail:
26150 return NULL;
26151 }
26152
26153
26154 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26155 PyObject *resultobj;
26156 wxWindow *arg1 = (wxWindow *) 0 ;
26157 int *arg2 = (int *) 0 ;
26158 int *arg3 = (int *) 0 ;
26159 int temp2 ;
26160 int res2 = 0 ;
26161 int temp3 ;
26162 int res3 = 0 ;
26163 PyObject * obj0 = 0 ;
26164 char *kwnames[] = {
26165 (char *) "self", NULL
26166 };
26167
26168 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26169 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26172 if (SWIG_arg_fail(1)) SWIG_fail;
26173 {
26174 PyThreadState* __tstate = wxPyBeginAllowThreads();
26175 (arg1)->GetPosition(arg2,arg3);
26176
26177 wxPyEndAllowThreads(__tstate);
26178 if (PyErr_Occurred()) SWIG_fail;
26179 }
26180 Py_INCREF(Py_None); resultobj = Py_None;
26181 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26182 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26183 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26184 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26185 return resultobj;
26186 fail:
26187 return NULL;
26188 }
26189
26190
26191 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26192 PyObject *resultobj;
26193 wxWindow *arg1 = (wxWindow *) 0 ;
26194 wxSize result;
26195 PyObject * obj0 = 0 ;
26196 char *kwnames[] = {
26197 (char *) "self", NULL
26198 };
26199
26200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26202 if (SWIG_arg_fail(1)) SWIG_fail;
26203 {
26204 PyThreadState* __tstate = wxPyBeginAllowThreads();
26205 result = ((wxWindow const *)arg1)->GetSize();
26206
26207 wxPyEndAllowThreads(__tstate);
26208 if (PyErr_Occurred()) SWIG_fail;
26209 }
26210 {
26211 wxSize * resultptr;
26212 resultptr = new wxSize((wxSize &)(result));
26213 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26214 }
26215 return resultobj;
26216 fail:
26217 return NULL;
26218 }
26219
26220
26221 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26222 PyObject *resultobj;
26223 wxWindow *arg1 = (wxWindow *) 0 ;
26224 int *arg2 = (int *) 0 ;
26225 int *arg3 = (int *) 0 ;
26226 int temp2 ;
26227 int res2 = 0 ;
26228 int temp3 ;
26229 int res3 = 0 ;
26230 PyObject * obj0 = 0 ;
26231 char *kwnames[] = {
26232 (char *) "self", NULL
26233 };
26234
26235 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26236 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",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 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26243
26244 wxPyEndAllowThreads(__tstate);
26245 if (PyErr_Occurred()) SWIG_fail;
26246 }
26247 Py_INCREF(Py_None); resultobj = Py_None;
26248 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26249 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26250 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26251 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26252 return resultobj;
26253 fail:
26254 return NULL;
26255 }
26256
26257
26258 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26259 PyObject *resultobj;
26260 wxWindow *arg1 = (wxWindow *) 0 ;
26261 wxRect result;
26262 PyObject * obj0 = 0 ;
26263 char *kwnames[] = {
26264 (char *) "self", NULL
26265 };
26266
26267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26269 if (SWIG_arg_fail(1)) SWIG_fail;
26270 {
26271 PyThreadState* __tstate = wxPyBeginAllowThreads();
26272 result = ((wxWindow const *)arg1)->GetRect();
26273
26274 wxPyEndAllowThreads(__tstate);
26275 if (PyErr_Occurred()) SWIG_fail;
26276 }
26277 {
26278 wxRect * resultptr;
26279 resultptr = new wxRect((wxRect &)(result));
26280 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26281 }
26282 return resultobj;
26283 fail:
26284 return NULL;
26285 }
26286
26287
26288 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26289 PyObject *resultobj;
26290 wxWindow *arg1 = (wxWindow *) 0 ;
26291 wxSize result;
26292 PyObject * obj0 = 0 ;
26293 char *kwnames[] = {
26294 (char *) "self", NULL
26295 };
26296
26297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26299 if (SWIG_arg_fail(1)) SWIG_fail;
26300 {
26301 PyThreadState* __tstate = wxPyBeginAllowThreads();
26302 result = ((wxWindow const *)arg1)->GetClientSize();
26303
26304 wxPyEndAllowThreads(__tstate);
26305 if (PyErr_Occurred()) SWIG_fail;
26306 }
26307 {
26308 wxSize * resultptr;
26309 resultptr = new wxSize((wxSize &)(result));
26310 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26311 }
26312 return resultobj;
26313 fail:
26314 return NULL;
26315 }
26316
26317
26318 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26319 PyObject *resultobj;
26320 wxWindow *arg1 = (wxWindow *) 0 ;
26321 int *arg2 = (int *) 0 ;
26322 int *arg3 = (int *) 0 ;
26323 int temp2 ;
26324 int res2 = 0 ;
26325 int temp3 ;
26326 int res3 = 0 ;
26327 PyObject * obj0 = 0 ;
26328 char *kwnames[] = {
26329 (char *) "self", NULL
26330 };
26331
26332 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26333 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26336 if (SWIG_arg_fail(1)) SWIG_fail;
26337 {
26338 PyThreadState* __tstate = wxPyBeginAllowThreads();
26339 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26340
26341 wxPyEndAllowThreads(__tstate);
26342 if (PyErr_Occurred()) SWIG_fail;
26343 }
26344 Py_INCREF(Py_None); resultobj = Py_None;
26345 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26346 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26347 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26348 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26349 return resultobj;
26350 fail:
26351 return NULL;
26352 }
26353
26354
26355 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26356 PyObject *resultobj;
26357 wxWindow *arg1 = (wxWindow *) 0 ;
26358 wxPoint result;
26359 PyObject * obj0 = 0 ;
26360 char *kwnames[] = {
26361 (char *) "self", NULL
26362 };
26363
26364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26366 if (SWIG_arg_fail(1)) SWIG_fail;
26367 {
26368 PyThreadState* __tstate = wxPyBeginAllowThreads();
26369 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26370
26371 wxPyEndAllowThreads(__tstate);
26372 if (PyErr_Occurred()) SWIG_fail;
26373 }
26374 {
26375 wxPoint * resultptr;
26376 resultptr = new wxPoint((wxPoint &)(result));
26377 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26378 }
26379 return resultobj;
26380 fail:
26381 return NULL;
26382 }
26383
26384
26385 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26386 PyObject *resultobj;
26387 wxWindow *arg1 = (wxWindow *) 0 ;
26388 wxRect result;
26389 PyObject * obj0 = 0 ;
26390 char *kwnames[] = {
26391 (char *) "self", NULL
26392 };
26393
26394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26396 if (SWIG_arg_fail(1)) SWIG_fail;
26397 {
26398 PyThreadState* __tstate = wxPyBeginAllowThreads();
26399 result = ((wxWindow const *)arg1)->GetClientRect();
26400
26401 wxPyEndAllowThreads(__tstate);
26402 if (PyErr_Occurred()) SWIG_fail;
26403 }
26404 {
26405 wxRect * resultptr;
26406 resultptr = new wxRect((wxRect &)(result));
26407 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26408 }
26409 return resultobj;
26410 fail:
26411 return NULL;
26412 }
26413
26414
26415 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26416 PyObject *resultobj;
26417 wxWindow *arg1 = (wxWindow *) 0 ;
26418 wxSize result;
26419 PyObject * obj0 = 0 ;
26420 char *kwnames[] = {
26421 (char *) "self", NULL
26422 };
26423
26424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26426 if (SWIG_arg_fail(1)) SWIG_fail;
26427 {
26428 PyThreadState* __tstate = wxPyBeginAllowThreads();
26429 result = ((wxWindow const *)arg1)->GetBestSize();
26430
26431 wxPyEndAllowThreads(__tstate);
26432 if (PyErr_Occurred()) SWIG_fail;
26433 }
26434 {
26435 wxSize * resultptr;
26436 resultptr = new wxSize((wxSize &)(result));
26437 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26438 }
26439 return resultobj;
26440 fail:
26441 return NULL;
26442 }
26443
26444
26445 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26446 PyObject *resultobj;
26447 wxWindow *arg1 = (wxWindow *) 0 ;
26448 int *arg2 = (int *) 0 ;
26449 int *arg3 = (int *) 0 ;
26450 int temp2 ;
26451 int res2 = 0 ;
26452 int temp3 ;
26453 int res3 = 0 ;
26454 PyObject * obj0 = 0 ;
26455 char *kwnames[] = {
26456 (char *) "self", NULL
26457 };
26458
26459 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26460 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26463 if (SWIG_arg_fail(1)) SWIG_fail;
26464 {
26465 PyThreadState* __tstate = wxPyBeginAllowThreads();
26466 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26467
26468 wxPyEndAllowThreads(__tstate);
26469 if (PyErr_Occurred()) SWIG_fail;
26470 }
26471 Py_INCREF(Py_None); resultobj = Py_None;
26472 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26473 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26474 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26475 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26476 return resultobj;
26477 fail:
26478 return NULL;
26479 }
26480
26481
26482 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26483 PyObject *resultobj;
26484 wxWindow *arg1 = (wxWindow *) 0 ;
26485 PyObject * obj0 = 0 ;
26486 char *kwnames[] = {
26487 (char *) "self", NULL
26488 };
26489
26490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26492 if (SWIG_arg_fail(1)) SWIG_fail;
26493 {
26494 PyThreadState* __tstate = wxPyBeginAllowThreads();
26495 (arg1)->InvalidateBestSize();
26496
26497 wxPyEndAllowThreads(__tstate);
26498 if (PyErr_Occurred()) SWIG_fail;
26499 }
26500 Py_INCREF(Py_None); resultobj = Py_None;
26501 return resultobj;
26502 fail:
26503 return NULL;
26504 }
26505
26506
26507 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26508 PyObject *resultobj;
26509 wxWindow *arg1 = (wxWindow *) 0 ;
26510 wxSize result;
26511 PyObject * obj0 = 0 ;
26512 char *kwnames[] = {
26513 (char *) "self", NULL
26514 };
26515
26516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26518 if (SWIG_arg_fail(1)) SWIG_fail;
26519 {
26520 PyThreadState* __tstate = wxPyBeginAllowThreads();
26521 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26522
26523 wxPyEndAllowThreads(__tstate);
26524 if (PyErr_Occurred()) SWIG_fail;
26525 }
26526 {
26527 wxSize * resultptr;
26528 resultptr = new wxSize((wxSize &)(result));
26529 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26530 }
26531 return resultobj;
26532 fail:
26533 return NULL;
26534 }
26535
26536
26537 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26538 PyObject *resultobj;
26539 wxWindow *arg1 = (wxWindow *) 0 ;
26540 wxSize result;
26541 PyObject * obj0 = 0 ;
26542 char *kwnames[] = {
26543 (char *) "self", NULL
26544 };
26545
26546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26548 if (SWIG_arg_fail(1)) SWIG_fail;
26549 {
26550 PyThreadState* __tstate = wxPyBeginAllowThreads();
26551 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26552
26553 wxPyEndAllowThreads(__tstate);
26554 if (PyErr_Occurred()) SWIG_fail;
26555 }
26556 {
26557 wxSize * resultptr;
26558 resultptr = new wxSize((wxSize &)(result));
26559 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26560 }
26561 return resultobj;
26562 fail:
26563 return NULL;
26564 }
26565
26566
26567 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26568 PyObject *resultobj;
26569 wxWindow *arg1 = (wxWindow *) 0 ;
26570 int arg2 = (int) wxBOTH ;
26571 PyObject * obj0 = 0 ;
26572 PyObject * obj1 = 0 ;
26573 char *kwnames[] = {
26574 (char *) "self",(char *) "direction", NULL
26575 };
26576
26577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26579 if (SWIG_arg_fail(1)) SWIG_fail;
26580 if (obj1) {
26581 {
26582 arg2 = (int)(SWIG_As_int(obj1));
26583 if (SWIG_arg_fail(2)) SWIG_fail;
26584 }
26585 }
26586 {
26587 PyThreadState* __tstate = wxPyBeginAllowThreads();
26588 (arg1)->Center(arg2);
26589
26590 wxPyEndAllowThreads(__tstate);
26591 if (PyErr_Occurred()) SWIG_fail;
26592 }
26593 Py_INCREF(Py_None); resultobj = Py_None;
26594 return resultobj;
26595 fail:
26596 return NULL;
26597 }
26598
26599
26600 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26601 PyObject *resultobj;
26602 wxWindow *arg1 = (wxWindow *) 0 ;
26603 int arg2 = (int) wxBOTH ;
26604 PyObject * obj0 = 0 ;
26605 PyObject * obj1 = 0 ;
26606 char *kwnames[] = {
26607 (char *) "self",(char *) "dir", NULL
26608 };
26609
26610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26612 if (SWIG_arg_fail(1)) SWIG_fail;
26613 if (obj1) {
26614 {
26615 arg2 = (int)(SWIG_As_int(obj1));
26616 if (SWIG_arg_fail(2)) SWIG_fail;
26617 }
26618 }
26619 {
26620 PyThreadState* __tstate = wxPyBeginAllowThreads();
26621 (arg1)->CenterOnScreen(arg2);
26622
26623 wxPyEndAllowThreads(__tstate);
26624 if (PyErr_Occurred()) SWIG_fail;
26625 }
26626 Py_INCREF(Py_None); resultobj = Py_None;
26627 return resultobj;
26628 fail:
26629 return NULL;
26630 }
26631
26632
26633 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26634 PyObject *resultobj;
26635 wxWindow *arg1 = (wxWindow *) 0 ;
26636 int arg2 = (int) wxBOTH ;
26637 PyObject * obj0 = 0 ;
26638 PyObject * obj1 = 0 ;
26639 char *kwnames[] = {
26640 (char *) "self",(char *) "dir", NULL
26641 };
26642
26643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26645 if (SWIG_arg_fail(1)) SWIG_fail;
26646 if (obj1) {
26647 {
26648 arg2 = (int)(SWIG_As_int(obj1));
26649 if (SWIG_arg_fail(2)) SWIG_fail;
26650 }
26651 }
26652 {
26653 PyThreadState* __tstate = wxPyBeginAllowThreads();
26654 (arg1)->CenterOnParent(arg2);
26655
26656 wxPyEndAllowThreads(__tstate);
26657 if (PyErr_Occurred()) SWIG_fail;
26658 }
26659 Py_INCREF(Py_None); resultobj = Py_None;
26660 return resultobj;
26661 fail:
26662 return NULL;
26663 }
26664
26665
26666 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26667 PyObject *resultobj;
26668 wxWindow *arg1 = (wxWindow *) 0 ;
26669 PyObject * obj0 = 0 ;
26670 char *kwnames[] = {
26671 (char *) "self", NULL
26672 };
26673
26674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26676 if (SWIG_arg_fail(1)) SWIG_fail;
26677 {
26678 PyThreadState* __tstate = wxPyBeginAllowThreads();
26679 (arg1)->Fit();
26680
26681 wxPyEndAllowThreads(__tstate);
26682 if (PyErr_Occurred()) SWIG_fail;
26683 }
26684 Py_INCREF(Py_None); resultobj = Py_None;
26685 return resultobj;
26686 fail:
26687 return NULL;
26688 }
26689
26690
26691 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26692 PyObject *resultobj;
26693 wxWindow *arg1 = (wxWindow *) 0 ;
26694 PyObject * obj0 = 0 ;
26695 char *kwnames[] = {
26696 (char *) "self", NULL
26697 };
26698
26699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26701 if (SWIG_arg_fail(1)) SWIG_fail;
26702 {
26703 PyThreadState* __tstate = wxPyBeginAllowThreads();
26704 (arg1)->FitInside();
26705
26706 wxPyEndAllowThreads(__tstate);
26707 if (PyErr_Occurred()) SWIG_fail;
26708 }
26709 Py_INCREF(Py_None); resultobj = Py_None;
26710 return resultobj;
26711 fail:
26712 return NULL;
26713 }
26714
26715
26716 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26717 PyObject *resultobj;
26718 wxWindow *arg1 = (wxWindow *) 0 ;
26719 int arg2 ;
26720 int arg3 ;
26721 int arg4 = (int) -1 ;
26722 int arg5 = (int) -1 ;
26723 int arg6 = (int) -1 ;
26724 int arg7 = (int) -1 ;
26725 PyObject * obj0 = 0 ;
26726 PyObject * obj1 = 0 ;
26727 PyObject * obj2 = 0 ;
26728 PyObject * obj3 = 0 ;
26729 PyObject * obj4 = 0 ;
26730 PyObject * obj5 = 0 ;
26731 PyObject * obj6 = 0 ;
26732 char *kwnames[] = {
26733 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26734 };
26735
26736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26738 if (SWIG_arg_fail(1)) SWIG_fail;
26739 {
26740 arg2 = (int)(SWIG_As_int(obj1));
26741 if (SWIG_arg_fail(2)) SWIG_fail;
26742 }
26743 {
26744 arg3 = (int)(SWIG_As_int(obj2));
26745 if (SWIG_arg_fail(3)) SWIG_fail;
26746 }
26747 if (obj3) {
26748 {
26749 arg4 = (int)(SWIG_As_int(obj3));
26750 if (SWIG_arg_fail(4)) SWIG_fail;
26751 }
26752 }
26753 if (obj4) {
26754 {
26755 arg5 = (int)(SWIG_As_int(obj4));
26756 if (SWIG_arg_fail(5)) SWIG_fail;
26757 }
26758 }
26759 if (obj5) {
26760 {
26761 arg6 = (int)(SWIG_As_int(obj5));
26762 if (SWIG_arg_fail(6)) SWIG_fail;
26763 }
26764 }
26765 if (obj6) {
26766 {
26767 arg7 = (int)(SWIG_As_int(obj6));
26768 if (SWIG_arg_fail(7)) SWIG_fail;
26769 }
26770 }
26771 {
26772 PyThreadState* __tstate = wxPyBeginAllowThreads();
26773 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26774
26775 wxPyEndAllowThreads(__tstate);
26776 if (PyErr_Occurred()) SWIG_fail;
26777 }
26778 Py_INCREF(Py_None); resultobj = Py_None;
26779 return resultobj;
26780 fail:
26781 return NULL;
26782 }
26783
26784
26785 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26786 PyObject *resultobj;
26787 wxWindow *arg1 = (wxWindow *) 0 ;
26788 wxSize *arg2 = 0 ;
26789 wxSize const &arg3_defvalue = wxDefaultSize ;
26790 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26791 wxSize const &arg4_defvalue = wxDefaultSize ;
26792 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26793 wxSize temp2 ;
26794 wxSize temp3 ;
26795 wxSize temp4 ;
26796 PyObject * obj0 = 0 ;
26797 PyObject * obj1 = 0 ;
26798 PyObject * obj2 = 0 ;
26799 PyObject * obj3 = 0 ;
26800 char *kwnames[] = {
26801 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26802 };
26803
26804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26806 if (SWIG_arg_fail(1)) SWIG_fail;
26807 {
26808 arg2 = &temp2;
26809 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26810 }
26811 if (obj2) {
26812 {
26813 arg3 = &temp3;
26814 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26815 }
26816 }
26817 if (obj3) {
26818 {
26819 arg4 = &temp4;
26820 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26821 }
26822 }
26823 {
26824 PyThreadState* __tstate = wxPyBeginAllowThreads();
26825 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26826
26827 wxPyEndAllowThreads(__tstate);
26828 if (PyErr_Occurred()) SWIG_fail;
26829 }
26830 Py_INCREF(Py_None); resultobj = Py_None;
26831 return resultobj;
26832 fail:
26833 return NULL;
26834 }
26835
26836
26837 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26838 PyObject *resultobj;
26839 wxWindow *arg1 = (wxWindow *) 0 ;
26840 int arg2 ;
26841 int arg3 ;
26842 int arg4 = (int) -1 ;
26843 int arg5 = (int) -1 ;
26844 PyObject * obj0 = 0 ;
26845 PyObject * obj1 = 0 ;
26846 PyObject * obj2 = 0 ;
26847 PyObject * obj3 = 0 ;
26848 PyObject * obj4 = 0 ;
26849 char *kwnames[] = {
26850 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26851 };
26852
26853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26855 if (SWIG_arg_fail(1)) SWIG_fail;
26856 {
26857 arg2 = (int)(SWIG_As_int(obj1));
26858 if (SWIG_arg_fail(2)) SWIG_fail;
26859 }
26860 {
26861 arg3 = (int)(SWIG_As_int(obj2));
26862 if (SWIG_arg_fail(3)) SWIG_fail;
26863 }
26864 if (obj3) {
26865 {
26866 arg4 = (int)(SWIG_As_int(obj3));
26867 if (SWIG_arg_fail(4)) SWIG_fail;
26868 }
26869 }
26870 if (obj4) {
26871 {
26872 arg5 = (int)(SWIG_As_int(obj4));
26873 if (SWIG_arg_fail(5)) SWIG_fail;
26874 }
26875 }
26876 {
26877 PyThreadState* __tstate = wxPyBeginAllowThreads();
26878 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26879
26880 wxPyEndAllowThreads(__tstate);
26881 if (PyErr_Occurred()) SWIG_fail;
26882 }
26883 Py_INCREF(Py_None); resultobj = Py_None;
26884 return resultobj;
26885 fail:
26886 return NULL;
26887 }
26888
26889
26890 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26891 PyObject *resultobj;
26892 wxWindow *arg1 = (wxWindow *) 0 ;
26893 wxSize *arg2 = 0 ;
26894 wxSize const &arg3_defvalue = wxDefaultSize ;
26895 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26896 wxSize temp2 ;
26897 wxSize temp3 ;
26898 PyObject * obj0 = 0 ;
26899 PyObject * obj1 = 0 ;
26900 PyObject * obj2 = 0 ;
26901 char *kwnames[] = {
26902 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26903 };
26904
26905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26907 if (SWIG_arg_fail(1)) SWIG_fail;
26908 {
26909 arg2 = &temp2;
26910 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26911 }
26912 if (obj2) {
26913 {
26914 arg3 = &temp3;
26915 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26916 }
26917 }
26918 {
26919 PyThreadState* __tstate = wxPyBeginAllowThreads();
26920 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26921
26922 wxPyEndAllowThreads(__tstate);
26923 if (PyErr_Occurred()) SWIG_fail;
26924 }
26925 Py_INCREF(Py_None); resultobj = Py_None;
26926 return resultobj;
26927 fail:
26928 return NULL;
26929 }
26930
26931
26932 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26933 PyObject *resultobj;
26934 wxWindow *arg1 = (wxWindow *) 0 ;
26935 wxSize result;
26936 PyObject * obj0 = 0 ;
26937 char *kwnames[] = {
26938 (char *) "self", NULL
26939 };
26940
26941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26943 if (SWIG_arg_fail(1)) SWIG_fail;
26944 {
26945 PyThreadState* __tstate = wxPyBeginAllowThreads();
26946 result = ((wxWindow const *)arg1)->GetMaxSize();
26947
26948 wxPyEndAllowThreads(__tstate);
26949 if (PyErr_Occurred()) SWIG_fail;
26950 }
26951 {
26952 wxSize * resultptr;
26953 resultptr = new wxSize((wxSize &)(result));
26954 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26955 }
26956 return resultobj;
26957 fail:
26958 return NULL;
26959 }
26960
26961
26962 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26963 PyObject *resultobj;
26964 wxWindow *arg1 = (wxWindow *) 0 ;
26965 wxSize result;
26966 PyObject * obj0 = 0 ;
26967 char *kwnames[] = {
26968 (char *) "self", NULL
26969 };
26970
26971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26973 if (SWIG_arg_fail(1)) SWIG_fail;
26974 {
26975 PyThreadState* __tstate = wxPyBeginAllowThreads();
26976 result = ((wxWindow const *)arg1)->GetMinSize();
26977
26978 wxPyEndAllowThreads(__tstate);
26979 if (PyErr_Occurred()) SWIG_fail;
26980 }
26981 {
26982 wxSize * resultptr;
26983 resultptr = new wxSize((wxSize &)(result));
26984 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26985 }
26986 return resultobj;
26987 fail:
26988 return NULL;
26989 }
26990
26991
26992 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26993 PyObject *resultobj;
26994 wxWindow *arg1 = (wxWindow *) 0 ;
26995 wxSize *arg2 = 0 ;
26996 wxSize temp2 ;
26997 PyObject * obj0 = 0 ;
26998 PyObject * obj1 = 0 ;
26999 char *kwnames[] = {
27000 (char *) "self",(char *) "minSize", NULL
27001 };
27002
27003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27005 if (SWIG_arg_fail(1)) SWIG_fail;
27006 {
27007 arg2 = &temp2;
27008 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27009 }
27010 {
27011 PyThreadState* __tstate = wxPyBeginAllowThreads();
27012 (arg1)->SetMinSize((wxSize const &)*arg2);
27013
27014 wxPyEndAllowThreads(__tstate);
27015 if (PyErr_Occurred()) SWIG_fail;
27016 }
27017 Py_INCREF(Py_None); resultobj = Py_None;
27018 return resultobj;
27019 fail:
27020 return NULL;
27021 }
27022
27023
27024 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27025 PyObject *resultobj;
27026 wxWindow *arg1 = (wxWindow *) 0 ;
27027 wxSize *arg2 = 0 ;
27028 wxSize temp2 ;
27029 PyObject * obj0 = 0 ;
27030 PyObject * obj1 = 0 ;
27031 char *kwnames[] = {
27032 (char *) "self",(char *) "maxSize", NULL
27033 };
27034
27035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27037 if (SWIG_arg_fail(1)) SWIG_fail;
27038 {
27039 arg2 = &temp2;
27040 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27041 }
27042 {
27043 PyThreadState* __tstate = wxPyBeginAllowThreads();
27044 (arg1)->SetMaxSize((wxSize const &)*arg2);
27045
27046 wxPyEndAllowThreads(__tstate);
27047 if (PyErr_Occurred()) SWIG_fail;
27048 }
27049 Py_INCREF(Py_None); resultobj = Py_None;
27050 return resultobj;
27051 fail:
27052 return NULL;
27053 }
27054
27055
27056 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27057 PyObject *resultobj;
27058 wxWindow *arg1 = (wxWindow *) 0 ;
27059 int result;
27060 PyObject * obj0 = 0 ;
27061 char *kwnames[] = {
27062 (char *) "self", NULL
27063 };
27064
27065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27067 if (SWIG_arg_fail(1)) SWIG_fail;
27068 {
27069 PyThreadState* __tstate = wxPyBeginAllowThreads();
27070 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27071
27072 wxPyEndAllowThreads(__tstate);
27073 if (PyErr_Occurred()) SWIG_fail;
27074 }
27075 {
27076 resultobj = SWIG_From_int((int)(result));
27077 }
27078 return resultobj;
27079 fail:
27080 return NULL;
27081 }
27082
27083
27084 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27085 PyObject *resultobj;
27086 wxWindow *arg1 = (wxWindow *) 0 ;
27087 int result;
27088 PyObject * obj0 = 0 ;
27089 char *kwnames[] = {
27090 (char *) "self", NULL
27091 };
27092
27093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27095 if (SWIG_arg_fail(1)) SWIG_fail;
27096 {
27097 PyThreadState* __tstate = wxPyBeginAllowThreads();
27098 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27099
27100 wxPyEndAllowThreads(__tstate);
27101 if (PyErr_Occurred()) SWIG_fail;
27102 }
27103 {
27104 resultobj = SWIG_From_int((int)(result));
27105 }
27106 return resultobj;
27107 fail:
27108 return NULL;
27109 }
27110
27111
27112 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27113 PyObject *resultobj;
27114 wxWindow *arg1 = (wxWindow *) 0 ;
27115 int result;
27116 PyObject * obj0 = 0 ;
27117 char *kwnames[] = {
27118 (char *) "self", NULL
27119 };
27120
27121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27123 if (SWIG_arg_fail(1)) SWIG_fail;
27124 {
27125 PyThreadState* __tstate = wxPyBeginAllowThreads();
27126 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27127
27128 wxPyEndAllowThreads(__tstate);
27129 if (PyErr_Occurred()) SWIG_fail;
27130 }
27131 {
27132 resultobj = SWIG_From_int((int)(result));
27133 }
27134 return resultobj;
27135 fail:
27136 return NULL;
27137 }
27138
27139
27140 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27141 PyObject *resultobj;
27142 wxWindow *arg1 = (wxWindow *) 0 ;
27143 int result;
27144 PyObject * obj0 = 0 ;
27145 char *kwnames[] = {
27146 (char *) "self", NULL
27147 };
27148
27149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27151 if (SWIG_arg_fail(1)) SWIG_fail;
27152 {
27153 PyThreadState* __tstate = wxPyBeginAllowThreads();
27154 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27155
27156 wxPyEndAllowThreads(__tstate);
27157 if (PyErr_Occurred()) SWIG_fail;
27158 }
27159 {
27160 resultobj = SWIG_From_int((int)(result));
27161 }
27162 return resultobj;
27163 fail:
27164 return NULL;
27165 }
27166
27167
27168 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27169 PyObject *resultobj;
27170 wxWindow *arg1 = (wxWindow *) 0 ;
27171 wxSize *arg2 = 0 ;
27172 wxSize temp2 ;
27173 PyObject * obj0 = 0 ;
27174 PyObject * obj1 = 0 ;
27175 char *kwnames[] = {
27176 (char *) "self",(char *) "size", NULL
27177 };
27178
27179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27181 if (SWIG_arg_fail(1)) SWIG_fail;
27182 {
27183 arg2 = &temp2;
27184 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27185 }
27186 {
27187 PyThreadState* __tstate = wxPyBeginAllowThreads();
27188 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27189
27190 wxPyEndAllowThreads(__tstate);
27191 if (PyErr_Occurred()) SWIG_fail;
27192 }
27193 Py_INCREF(Py_None); resultobj = Py_None;
27194 return resultobj;
27195 fail:
27196 return NULL;
27197 }
27198
27199
27200 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27201 PyObject *resultobj;
27202 wxWindow *arg1 = (wxWindow *) 0 ;
27203 int arg2 ;
27204 int arg3 ;
27205 PyObject * obj0 = 0 ;
27206 PyObject * obj1 = 0 ;
27207 PyObject * obj2 = 0 ;
27208 char *kwnames[] = {
27209 (char *) "self",(char *) "w",(char *) "h", NULL
27210 };
27211
27212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) 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 = (int)(SWIG_As_int(obj1));
27217 if (SWIG_arg_fail(2)) SWIG_fail;
27218 }
27219 {
27220 arg3 = (int)(SWIG_As_int(obj2));
27221 if (SWIG_arg_fail(3)) SWIG_fail;
27222 }
27223 {
27224 PyThreadState* __tstate = wxPyBeginAllowThreads();
27225 (arg1)->SetVirtualSize(arg2,arg3);
27226
27227 wxPyEndAllowThreads(__tstate);
27228 if (PyErr_Occurred()) SWIG_fail;
27229 }
27230 Py_INCREF(Py_None); resultobj = Py_None;
27231 return resultobj;
27232 fail:
27233 return NULL;
27234 }
27235
27236
27237 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27238 PyObject *resultobj;
27239 wxWindow *arg1 = (wxWindow *) 0 ;
27240 wxSize result;
27241 PyObject * obj0 = 0 ;
27242 char *kwnames[] = {
27243 (char *) "self", NULL
27244 };
27245
27246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27248 if (SWIG_arg_fail(1)) SWIG_fail;
27249 {
27250 PyThreadState* __tstate = wxPyBeginAllowThreads();
27251 result = ((wxWindow const *)arg1)->GetVirtualSize();
27252
27253 wxPyEndAllowThreads(__tstate);
27254 if (PyErr_Occurred()) SWIG_fail;
27255 }
27256 {
27257 wxSize * resultptr;
27258 resultptr = new wxSize((wxSize &)(result));
27259 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27260 }
27261 return resultobj;
27262 fail:
27263 return NULL;
27264 }
27265
27266
27267 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27268 PyObject *resultobj;
27269 wxWindow *arg1 = (wxWindow *) 0 ;
27270 int *arg2 = (int *) 0 ;
27271 int *arg3 = (int *) 0 ;
27272 int temp2 ;
27273 int res2 = 0 ;
27274 int temp3 ;
27275 int res3 = 0 ;
27276 PyObject * obj0 = 0 ;
27277 char *kwnames[] = {
27278 (char *) "self", NULL
27279 };
27280
27281 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27282 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27285 if (SWIG_arg_fail(1)) SWIG_fail;
27286 {
27287 PyThreadState* __tstate = wxPyBeginAllowThreads();
27288 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27289
27290 wxPyEndAllowThreads(__tstate);
27291 if (PyErr_Occurred()) SWIG_fail;
27292 }
27293 Py_INCREF(Py_None); resultobj = Py_None;
27294 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27295 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27296 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27297 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27298 return resultobj;
27299 fail:
27300 return NULL;
27301 }
27302
27303
27304 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27305 PyObject *resultobj;
27306 wxWindow *arg1 = (wxWindow *) 0 ;
27307 wxSize result;
27308 PyObject * obj0 = 0 ;
27309 char *kwnames[] = {
27310 (char *) "self", NULL
27311 };
27312
27313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27315 if (SWIG_arg_fail(1)) SWIG_fail;
27316 {
27317 PyThreadState* __tstate = wxPyBeginAllowThreads();
27318 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27319
27320 wxPyEndAllowThreads(__tstate);
27321 if (PyErr_Occurred()) SWIG_fail;
27322 }
27323 {
27324 wxSize * resultptr;
27325 resultptr = new wxSize((wxSize &)(result));
27326 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27327 }
27328 return resultobj;
27329 fail:
27330 return NULL;
27331 }
27332
27333
27334 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27335 PyObject *resultobj;
27336 wxWindow *arg1 = (wxWindow *) 0 ;
27337 bool arg2 = (bool) true ;
27338 bool result;
27339 PyObject * obj0 = 0 ;
27340 PyObject * obj1 = 0 ;
27341 char *kwnames[] = {
27342 (char *) "self",(char *) "show", NULL
27343 };
27344
27345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27347 if (SWIG_arg_fail(1)) SWIG_fail;
27348 if (obj1) {
27349 {
27350 arg2 = (bool)(SWIG_As_bool(obj1));
27351 if (SWIG_arg_fail(2)) SWIG_fail;
27352 }
27353 }
27354 {
27355 PyThreadState* __tstate = wxPyBeginAllowThreads();
27356 result = (bool)(arg1)->Show(arg2);
27357
27358 wxPyEndAllowThreads(__tstate);
27359 if (PyErr_Occurred()) SWIG_fail;
27360 }
27361 {
27362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27363 }
27364 return resultobj;
27365 fail:
27366 return NULL;
27367 }
27368
27369
27370 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27371 PyObject *resultobj;
27372 wxWindow *arg1 = (wxWindow *) 0 ;
27373 bool result;
27374 PyObject * obj0 = 0 ;
27375 char *kwnames[] = {
27376 (char *) "self", NULL
27377 };
27378
27379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27381 if (SWIG_arg_fail(1)) SWIG_fail;
27382 {
27383 PyThreadState* __tstate = wxPyBeginAllowThreads();
27384 result = (bool)(arg1)->Hide();
27385
27386 wxPyEndAllowThreads(__tstate);
27387 if (PyErr_Occurred()) SWIG_fail;
27388 }
27389 {
27390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27391 }
27392 return resultobj;
27393 fail:
27394 return NULL;
27395 }
27396
27397
27398 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27399 PyObject *resultobj;
27400 wxWindow *arg1 = (wxWindow *) 0 ;
27401 bool arg2 = (bool) true ;
27402 bool result;
27403 PyObject * obj0 = 0 ;
27404 PyObject * obj1 = 0 ;
27405 char *kwnames[] = {
27406 (char *) "self",(char *) "enable", NULL
27407 };
27408
27409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
27410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27411 if (SWIG_arg_fail(1)) SWIG_fail;
27412 if (obj1) {
27413 {
27414 arg2 = (bool)(SWIG_As_bool(obj1));
27415 if (SWIG_arg_fail(2)) SWIG_fail;
27416 }
27417 }
27418 {
27419 PyThreadState* __tstate = wxPyBeginAllowThreads();
27420 result = (bool)(arg1)->Enable(arg2);
27421
27422 wxPyEndAllowThreads(__tstate);
27423 if (PyErr_Occurred()) SWIG_fail;
27424 }
27425 {
27426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27427 }
27428 return resultobj;
27429 fail:
27430 return NULL;
27431 }
27432
27433
27434 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27435 PyObject *resultobj;
27436 wxWindow *arg1 = (wxWindow *) 0 ;
27437 bool result;
27438 PyObject * obj0 = 0 ;
27439 char *kwnames[] = {
27440 (char *) "self", NULL
27441 };
27442
27443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27445 if (SWIG_arg_fail(1)) SWIG_fail;
27446 {
27447 PyThreadState* __tstate = wxPyBeginAllowThreads();
27448 result = (bool)(arg1)->Disable();
27449
27450 wxPyEndAllowThreads(__tstate);
27451 if (PyErr_Occurred()) SWIG_fail;
27452 }
27453 {
27454 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27455 }
27456 return resultobj;
27457 fail:
27458 return NULL;
27459 }
27460
27461
27462 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27463 PyObject *resultobj;
27464 wxWindow *arg1 = (wxWindow *) 0 ;
27465 bool result;
27466 PyObject * obj0 = 0 ;
27467 char *kwnames[] = {
27468 (char *) "self", NULL
27469 };
27470
27471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27473 if (SWIG_arg_fail(1)) SWIG_fail;
27474 {
27475 PyThreadState* __tstate = wxPyBeginAllowThreads();
27476 result = (bool)((wxWindow const *)arg1)->IsShown();
27477
27478 wxPyEndAllowThreads(__tstate);
27479 if (PyErr_Occurred()) SWIG_fail;
27480 }
27481 {
27482 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27483 }
27484 return resultobj;
27485 fail:
27486 return NULL;
27487 }
27488
27489
27490 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27491 PyObject *resultobj;
27492 wxWindow *arg1 = (wxWindow *) 0 ;
27493 bool result;
27494 PyObject * obj0 = 0 ;
27495 char *kwnames[] = {
27496 (char *) "self", NULL
27497 };
27498
27499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27501 if (SWIG_arg_fail(1)) SWIG_fail;
27502 {
27503 PyThreadState* __tstate = wxPyBeginAllowThreads();
27504 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27505
27506 wxPyEndAllowThreads(__tstate);
27507 if (PyErr_Occurred()) SWIG_fail;
27508 }
27509 {
27510 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27511 }
27512 return resultobj;
27513 fail:
27514 return NULL;
27515 }
27516
27517
27518 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27519 PyObject *resultobj;
27520 wxWindow *arg1 = (wxWindow *) 0 ;
27521 long arg2 ;
27522 PyObject * obj0 = 0 ;
27523 PyObject * obj1 = 0 ;
27524 char *kwnames[] = {
27525 (char *) "self",(char *) "style", NULL
27526 };
27527
27528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27530 if (SWIG_arg_fail(1)) SWIG_fail;
27531 {
27532 arg2 = (long)(SWIG_As_long(obj1));
27533 if (SWIG_arg_fail(2)) SWIG_fail;
27534 }
27535 {
27536 PyThreadState* __tstate = wxPyBeginAllowThreads();
27537 (arg1)->SetWindowStyleFlag(arg2);
27538
27539 wxPyEndAllowThreads(__tstate);
27540 if (PyErr_Occurred()) SWIG_fail;
27541 }
27542 Py_INCREF(Py_None); resultobj = Py_None;
27543 return resultobj;
27544 fail:
27545 return NULL;
27546 }
27547
27548
27549 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27550 PyObject *resultobj;
27551 wxWindow *arg1 = (wxWindow *) 0 ;
27552 long result;
27553 PyObject * obj0 = 0 ;
27554 char *kwnames[] = {
27555 (char *) "self", NULL
27556 };
27557
27558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27560 if (SWIG_arg_fail(1)) SWIG_fail;
27561 {
27562 PyThreadState* __tstate = wxPyBeginAllowThreads();
27563 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27564
27565 wxPyEndAllowThreads(__tstate);
27566 if (PyErr_Occurred()) SWIG_fail;
27567 }
27568 {
27569 resultobj = SWIG_From_long((long)(result));
27570 }
27571 return resultobj;
27572 fail:
27573 return NULL;
27574 }
27575
27576
27577 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27578 PyObject *resultobj;
27579 wxWindow *arg1 = (wxWindow *) 0 ;
27580 int arg2 ;
27581 bool result;
27582 PyObject * obj0 = 0 ;
27583 PyObject * obj1 = 0 ;
27584 char *kwnames[] = {
27585 (char *) "self",(char *) "flag", NULL
27586 };
27587
27588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27590 if (SWIG_arg_fail(1)) SWIG_fail;
27591 {
27592 arg2 = (int)(SWIG_As_int(obj1));
27593 if (SWIG_arg_fail(2)) SWIG_fail;
27594 }
27595 {
27596 PyThreadState* __tstate = wxPyBeginAllowThreads();
27597 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27598
27599 wxPyEndAllowThreads(__tstate);
27600 if (PyErr_Occurred()) SWIG_fail;
27601 }
27602 {
27603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27604 }
27605 return resultobj;
27606 fail:
27607 return NULL;
27608 }
27609
27610
27611 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27612 PyObject *resultobj;
27613 wxWindow *arg1 = (wxWindow *) 0 ;
27614 bool result;
27615 PyObject * obj0 = 0 ;
27616 char *kwnames[] = {
27617 (char *) "self", NULL
27618 };
27619
27620 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27621 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27622 if (SWIG_arg_fail(1)) SWIG_fail;
27623 {
27624 PyThreadState* __tstate = wxPyBeginAllowThreads();
27625 result = (bool)((wxWindow const *)arg1)->IsRetained();
27626
27627 wxPyEndAllowThreads(__tstate);
27628 if (PyErr_Occurred()) SWIG_fail;
27629 }
27630 {
27631 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27632 }
27633 return resultobj;
27634 fail:
27635 return NULL;
27636 }
27637
27638
27639 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27640 PyObject *resultobj;
27641 wxWindow *arg1 = (wxWindow *) 0 ;
27642 long arg2 ;
27643 PyObject * obj0 = 0 ;
27644 PyObject * obj1 = 0 ;
27645 char *kwnames[] = {
27646 (char *) "self",(char *) "exStyle", NULL
27647 };
27648
27649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27651 if (SWIG_arg_fail(1)) SWIG_fail;
27652 {
27653 arg2 = (long)(SWIG_As_long(obj1));
27654 if (SWIG_arg_fail(2)) SWIG_fail;
27655 }
27656 {
27657 PyThreadState* __tstate = wxPyBeginAllowThreads();
27658 (arg1)->SetExtraStyle(arg2);
27659
27660 wxPyEndAllowThreads(__tstate);
27661 if (PyErr_Occurred()) SWIG_fail;
27662 }
27663 Py_INCREF(Py_None); resultobj = Py_None;
27664 return resultobj;
27665 fail:
27666 return NULL;
27667 }
27668
27669
27670 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27671 PyObject *resultobj;
27672 wxWindow *arg1 = (wxWindow *) 0 ;
27673 long result;
27674 PyObject * obj0 = 0 ;
27675 char *kwnames[] = {
27676 (char *) "self", NULL
27677 };
27678
27679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27680 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27681 if (SWIG_arg_fail(1)) SWIG_fail;
27682 {
27683 PyThreadState* __tstate = wxPyBeginAllowThreads();
27684 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27685
27686 wxPyEndAllowThreads(__tstate);
27687 if (PyErr_Occurred()) SWIG_fail;
27688 }
27689 {
27690 resultobj = SWIG_From_long((long)(result));
27691 }
27692 return resultobj;
27693 fail:
27694 return NULL;
27695 }
27696
27697
27698 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27699 PyObject *resultobj;
27700 wxWindow *arg1 = (wxWindow *) 0 ;
27701 bool arg2 = (bool) true ;
27702 PyObject * obj0 = 0 ;
27703 PyObject * obj1 = 0 ;
27704 char *kwnames[] = {
27705 (char *) "self",(char *) "modal", NULL
27706 };
27707
27708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27710 if (SWIG_arg_fail(1)) SWIG_fail;
27711 if (obj1) {
27712 {
27713 arg2 = (bool)(SWIG_As_bool(obj1));
27714 if (SWIG_arg_fail(2)) SWIG_fail;
27715 }
27716 }
27717 {
27718 PyThreadState* __tstate = wxPyBeginAllowThreads();
27719 (arg1)->MakeModal(arg2);
27720
27721 wxPyEndAllowThreads(__tstate);
27722 if (PyErr_Occurred()) SWIG_fail;
27723 }
27724 Py_INCREF(Py_None); resultobj = Py_None;
27725 return resultobj;
27726 fail:
27727 return NULL;
27728 }
27729
27730
27731 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27732 PyObject *resultobj;
27733 wxWindow *arg1 = (wxWindow *) 0 ;
27734 bool arg2 ;
27735 PyObject * obj0 = 0 ;
27736 PyObject * obj1 = 0 ;
27737 char *kwnames[] = {
27738 (char *) "self",(char *) "enableTheme", NULL
27739 };
27740
27741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27743 if (SWIG_arg_fail(1)) SWIG_fail;
27744 {
27745 arg2 = (bool)(SWIG_As_bool(obj1));
27746 if (SWIG_arg_fail(2)) SWIG_fail;
27747 }
27748 {
27749 PyThreadState* __tstate = wxPyBeginAllowThreads();
27750 (arg1)->SetThemeEnabled(arg2);
27751
27752 wxPyEndAllowThreads(__tstate);
27753 if (PyErr_Occurred()) SWIG_fail;
27754 }
27755 Py_INCREF(Py_None); resultobj = Py_None;
27756 return resultobj;
27757 fail:
27758 return NULL;
27759 }
27760
27761
27762 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27763 PyObject *resultobj;
27764 wxWindow *arg1 = (wxWindow *) 0 ;
27765 bool result;
27766 PyObject * obj0 = 0 ;
27767 char *kwnames[] = {
27768 (char *) "self", NULL
27769 };
27770
27771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27773 if (SWIG_arg_fail(1)) SWIG_fail;
27774 {
27775 PyThreadState* __tstate = wxPyBeginAllowThreads();
27776 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27777
27778 wxPyEndAllowThreads(__tstate);
27779 if (PyErr_Occurred()) SWIG_fail;
27780 }
27781 {
27782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27783 }
27784 return resultobj;
27785 fail:
27786 return NULL;
27787 }
27788
27789
27790 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27791 PyObject *resultobj;
27792 wxWindow *arg1 = (wxWindow *) 0 ;
27793 PyObject * obj0 = 0 ;
27794 char *kwnames[] = {
27795 (char *) "self", NULL
27796 };
27797
27798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27800 if (SWIG_arg_fail(1)) SWIG_fail;
27801 {
27802 PyThreadState* __tstate = wxPyBeginAllowThreads();
27803 (arg1)->SetFocus();
27804
27805 wxPyEndAllowThreads(__tstate);
27806 if (PyErr_Occurred()) SWIG_fail;
27807 }
27808 Py_INCREF(Py_None); resultobj = Py_None;
27809 return resultobj;
27810 fail:
27811 return NULL;
27812 }
27813
27814
27815 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27816 PyObject *resultobj;
27817 wxWindow *arg1 = (wxWindow *) 0 ;
27818 PyObject * obj0 = 0 ;
27819 char *kwnames[] = {
27820 (char *) "self", NULL
27821 };
27822
27823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27825 if (SWIG_arg_fail(1)) SWIG_fail;
27826 {
27827 PyThreadState* __tstate = wxPyBeginAllowThreads();
27828 (arg1)->SetFocusFromKbd();
27829
27830 wxPyEndAllowThreads(__tstate);
27831 if (PyErr_Occurred()) SWIG_fail;
27832 }
27833 Py_INCREF(Py_None); resultobj = Py_None;
27834 return resultobj;
27835 fail:
27836 return NULL;
27837 }
27838
27839
27840 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27841 PyObject *resultobj;
27842 wxWindow *result;
27843 char *kwnames[] = {
27844 NULL
27845 };
27846
27847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27848 {
27849 if (!wxPyCheckForApp()) SWIG_fail;
27850 PyThreadState* __tstate = wxPyBeginAllowThreads();
27851 result = (wxWindow *)wxWindow::FindFocus();
27852
27853 wxPyEndAllowThreads(__tstate);
27854 if (PyErr_Occurred()) SWIG_fail;
27855 }
27856 {
27857 resultobj = wxPyMake_wxObject(result, 0);
27858 }
27859 return resultobj;
27860 fail:
27861 return NULL;
27862 }
27863
27864
27865 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27866 PyObject *resultobj;
27867 wxWindow *arg1 = (wxWindow *) 0 ;
27868 bool result;
27869 PyObject * obj0 = 0 ;
27870 char *kwnames[] = {
27871 (char *) "self", NULL
27872 };
27873
27874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27876 if (SWIG_arg_fail(1)) SWIG_fail;
27877 {
27878 PyThreadState* __tstate = wxPyBeginAllowThreads();
27879 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27880
27881 wxPyEndAllowThreads(__tstate);
27882 if (PyErr_Occurred()) SWIG_fail;
27883 }
27884 {
27885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27886 }
27887 return resultobj;
27888 fail:
27889 return NULL;
27890 }
27891
27892
27893 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27894 PyObject *resultobj;
27895 wxWindow *arg1 = (wxWindow *) 0 ;
27896 bool result;
27897 PyObject * obj0 = 0 ;
27898 char *kwnames[] = {
27899 (char *) "self", NULL
27900 };
27901
27902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27904 if (SWIG_arg_fail(1)) SWIG_fail;
27905 {
27906 PyThreadState* __tstate = wxPyBeginAllowThreads();
27907 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27908
27909 wxPyEndAllowThreads(__tstate);
27910 if (PyErr_Occurred()) SWIG_fail;
27911 }
27912 {
27913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27914 }
27915 return resultobj;
27916 fail:
27917 return NULL;
27918 }
27919
27920
27921 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27922 PyObject *resultobj;
27923 wxWindow *arg1 = (wxWindow *) 0 ;
27924 wxWindow *result;
27925 PyObject * obj0 = 0 ;
27926 char *kwnames[] = {
27927 (char *) "self", NULL
27928 };
27929
27930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27932 if (SWIG_arg_fail(1)) SWIG_fail;
27933 {
27934 PyThreadState* __tstate = wxPyBeginAllowThreads();
27935 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27936
27937 wxPyEndAllowThreads(__tstate);
27938 if (PyErr_Occurred()) SWIG_fail;
27939 }
27940 {
27941 resultobj = wxPyMake_wxObject(result, 0);
27942 }
27943 return resultobj;
27944 fail:
27945 return NULL;
27946 }
27947
27948
27949 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27950 PyObject *resultobj;
27951 wxWindow *arg1 = (wxWindow *) 0 ;
27952 wxWindow *arg2 = (wxWindow *) 0 ;
27953 wxWindow *result;
27954 PyObject * obj0 = 0 ;
27955 PyObject * obj1 = 0 ;
27956 char *kwnames[] = {
27957 (char *) "self",(char *) "child", NULL
27958 };
27959
27960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27962 if (SWIG_arg_fail(1)) SWIG_fail;
27963 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27964 if (SWIG_arg_fail(2)) SWIG_fail;
27965 {
27966 PyThreadState* __tstate = wxPyBeginAllowThreads();
27967 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27968
27969 wxPyEndAllowThreads(__tstate);
27970 if (PyErr_Occurred()) SWIG_fail;
27971 }
27972 {
27973 resultobj = wxPyMake_wxObject(result, 0);
27974 }
27975 return resultobj;
27976 fail:
27977 return NULL;
27978 }
27979
27980
27981 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27982 PyObject *resultobj;
27983 wxWindow *arg1 = (wxWindow *) 0 ;
27984 wxWindow *arg2 = (wxWindow *) 0 ;
27985 PyObject * obj0 = 0 ;
27986 PyObject * obj1 = 0 ;
27987 char *kwnames[] = {
27988 (char *) "self",(char *) "win", NULL
27989 };
27990
27991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27993 if (SWIG_arg_fail(1)) SWIG_fail;
27994 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27995 if (SWIG_arg_fail(2)) SWIG_fail;
27996 {
27997 PyThreadState* __tstate = wxPyBeginAllowThreads();
27998 (arg1)->SetTmpDefaultItem(arg2);
27999
28000 wxPyEndAllowThreads(__tstate);
28001 if (PyErr_Occurred()) SWIG_fail;
28002 }
28003 Py_INCREF(Py_None); resultobj = Py_None;
28004 return resultobj;
28005 fail:
28006 return NULL;
28007 }
28008
28009
28010 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28011 PyObject *resultobj;
28012 wxWindow *arg1 = (wxWindow *) 0 ;
28013 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28014 bool result;
28015 PyObject * obj0 = 0 ;
28016 PyObject * obj1 = 0 ;
28017 char *kwnames[] = {
28018 (char *) "self",(char *) "flags", NULL
28019 };
28020
28021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28023 if (SWIG_arg_fail(1)) SWIG_fail;
28024 if (obj1) {
28025 {
28026 arg2 = (int)(SWIG_As_int(obj1));
28027 if (SWIG_arg_fail(2)) SWIG_fail;
28028 }
28029 }
28030 {
28031 PyThreadState* __tstate = wxPyBeginAllowThreads();
28032 result = (bool)(arg1)->Navigate(arg2);
28033
28034 wxPyEndAllowThreads(__tstate);
28035 if (PyErr_Occurred()) SWIG_fail;
28036 }
28037 {
28038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28039 }
28040 return resultobj;
28041 fail:
28042 return NULL;
28043 }
28044
28045
28046 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28047 PyObject *resultobj;
28048 wxWindow *arg1 = (wxWindow *) 0 ;
28049 wxWindow *arg2 = (wxWindow *) 0 ;
28050 PyObject * obj0 = 0 ;
28051 PyObject * obj1 = 0 ;
28052 char *kwnames[] = {
28053 (char *) "self",(char *) "win", NULL
28054 };
28055
28056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28058 if (SWIG_arg_fail(1)) SWIG_fail;
28059 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28060 if (SWIG_arg_fail(2)) SWIG_fail;
28061 {
28062 PyThreadState* __tstate = wxPyBeginAllowThreads();
28063 (arg1)->MoveAfterInTabOrder(arg2);
28064
28065 wxPyEndAllowThreads(__tstate);
28066 if (PyErr_Occurred()) SWIG_fail;
28067 }
28068 Py_INCREF(Py_None); resultobj = Py_None;
28069 return resultobj;
28070 fail:
28071 return NULL;
28072 }
28073
28074
28075 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28076 PyObject *resultobj;
28077 wxWindow *arg1 = (wxWindow *) 0 ;
28078 wxWindow *arg2 = (wxWindow *) 0 ;
28079 PyObject * obj0 = 0 ;
28080 PyObject * obj1 = 0 ;
28081 char *kwnames[] = {
28082 (char *) "self",(char *) "win", NULL
28083 };
28084
28085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28087 if (SWIG_arg_fail(1)) SWIG_fail;
28088 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28089 if (SWIG_arg_fail(2)) SWIG_fail;
28090 {
28091 PyThreadState* __tstate = wxPyBeginAllowThreads();
28092 (arg1)->MoveBeforeInTabOrder(arg2);
28093
28094 wxPyEndAllowThreads(__tstate);
28095 if (PyErr_Occurred()) SWIG_fail;
28096 }
28097 Py_INCREF(Py_None); resultobj = Py_None;
28098 return resultobj;
28099 fail:
28100 return NULL;
28101 }
28102
28103
28104 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28105 PyObject *resultobj;
28106 wxWindow *arg1 = (wxWindow *) 0 ;
28107 PyObject *result;
28108 PyObject * obj0 = 0 ;
28109 char *kwnames[] = {
28110 (char *) "self", NULL
28111 };
28112
28113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28115 if (SWIG_arg_fail(1)) SWIG_fail;
28116 {
28117 PyThreadState* __tstate = wxPyBeginAllowThreads();
28118 result = (PyObject *)wxWindow_GetChildren(arg1);
28119
28120 wxPyEndAllowThreads(__tstate);
28121 if (PyErr_Occurred()) SWIG_fail;
28122 }
28123 resultobj = result;
28124 return resultobj;
28125 fail:
28126 return NULL;
28127 }
28128
28129
28130 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28131 PyObject *resultobj;
28132 wxWindow *arg1 = (wxWindow *) 0 ;
28133 wxWindow *result;
28134 PyObject * obj0 = 0 ;
28135 char *kwnames[] = {
28136 (char *) "self", NULL
28137 };
28138
28139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28141 if (SWIG_arg_fail(1)) SWIG_fail;
28142 {
28143 PyThreadState* __tstate = wxPyBeginAllowThreads();
28144 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28145
28146 wxPyEndAllowThreads(__tstate);
28147 if (PyErr_Occurred()) SWIG_fail;
28148 }
28149 {
28150 resultobj = wxPyMake_wxObject(result, 0);
28151 }
28152 return resultobj;
28153 fail:
28154 return NULL;
28155 }
28156
28157
28158 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28159 PyObject *resultobj;
28160 wxWindow *arg1 = (wxWindow *) 0 ;
28161 wxWindow *result;
28162 PyObject * obj0 = 0 ;
28163 char *kwnames[] = {
28164 (char *) "self", NULL
28165 };
28166
28167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28169 if (SWIG_arg_fail(1)) SWIG_fail;
28170 {
28171 PyThreadState* __tstate = wxPyBeginAllowThreads();
28172 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28173
28174 wxPyEndAllowThreads(__tstate);
28175 if (PyErr_Occurred()) SWIG_fail;
28176 }
28177 {
28178 resultobj = wxPyMake_wxObject(result, 0);
28179 }
28180 return resultobj;
28181 fail:
28182 return NULL;
28183 }
28184
28185
28186 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28187 PyObject *resultobj;
28188 wxWindow *arg1 = (wxWindow *) 0 ;
28189 bool result;
28190 PyObject * obj0 = 0 ;
28191 char *kwnames[] = {
28192 (char *) "self", NULL
28193 };
28194
28195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28197 if (SWIG_arg_fail(1)) SWIG_fail;
28198 {
28199 PyThreadState* __tstate = wxPyBeginAllowThreads();
28200 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28201
28202 wxPyEndAllowThreads(__tstate);
28203 if (PyErr_Occurred()) SWIG_fail;
28204 }
28205 {
28206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28207 }
28208 return resultobj;
28209 fail:
28210 return NULL;
28211 }
28212
28213
28214 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28215 PyObject *resultobj;
28216 wxWindow *arg1 = (wxWindow *) 0 ;
28217 wxWindow *arg2 = (wxWindow *) 0 ;
28218 bool result;
28219 PyObject * obj0 = 0 ;
28220 PyObject * obj1 = 0 ;
28221 char *kwnames[] = {
28222 (char *) "self",(char *) "newParent", NULL
28223 };
28224
28225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28227 if (SWIG_arg_fail(1)) SWIG_fail;
28228 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28229 if (SWIG_arg_fail(2)) SWIG_fail;
28230 {
28231 PyThreadState* __tstate = wxPyBeginAllowThreads();
28232 result = (bool)(arg1)->Reparent(arg2);
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_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28247 PyObject *resultobj;
28248 wxWindow *arg1 = (wxWindow *) 0 ;
28249 wxWindow *arg2 = (wxWindow *) 0 ;
28250 PyObject * obj0 = 0 ;
28251 PyObject * obj1 = 0 ;
28252 char *kwnames[] = {
28253 (char *) "self",(char *) "child", NULL
28254 };
28255
28256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28258 if (SWIG_arg_fail(1)) SWIG_fail;
28259 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28260 if (SWIG_arg_fail(2)) SWIG_fail;
28261 {
28262 PyThreadState* __tstate = wxPyBeginAllowThreads();
28263 (arg1)->AddChild(arg2);
28264
28265 wxPyEndAllowThreads(__tstate);
28266 if (PyErr_Occurred()) SWIG_fail;
28267 }
28268 Py_INCREF(Py_None); resultobj = Py_None;
28269 return resultobj;
28270 fail:
28271 return NULL;
28272 }
28273
28274
28275 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28276 PyObject *resultobj;
28277 wxWindow *arg1 = (wxWindow *) 0 ;
28278 wxWindow *arg2 = (wxWindow *) 0 ;
28279 PyObject * obj0 = 0 ;
28280 PyObject * obj1 = 0 ;
28281 char *kwnames[] = {
28282 (char *) "self",(char *) "child", NULL
28283 };
28284
28285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28287 if (SWIG_arg_fail(1)) SWIG_fail;
28288 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28289 if (SWIG_arg_fail(2)) SWIG_fail;
28290 {
28291 PyThreadState* __tstate = wxPyBeginAllowThreads();
28292 (arg1)->RemoveChild(arg2);
28293
28294 wxPyEndAllowThreads(__tstate);
28295 if (PyErr_Occurred()) SWIG_fail;
28296 }
28297 Py_INCREF(Py_None); resultobj = Py_None;
28298 return resultobj;
28299 fail:
28300 return NULL;
28301 }
28302
28303
28304 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28305 PyObject *resultobj;
28306 wxWindow *arg1 = (wxWindow *) 0 ;
28307 long arg2 ;
28308 wxWindow *result;
28309 PyObject * obj0 = 0 ;
28310 PyObject * obj1 = 0 ;
28311 char *kwnames[] = {
28312 (char *) "self",(char *) "winid", NULL
28313 };
28314
28315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) 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 arg2 = (long)(SWIG_As_long(obj1));
28320 if (SWIG_arg_fail(2)) SWIG_fail;
28321 }
28322 {
28323 PyThreadState* __tstate = wxPyBeginAllowThreads();
28324 result = (wxWindow *)(arg1)->FindWindow(arg2);
28325
28326 wxPyEndAllowThreads(__tstate);
28327 if (PyErr_Occurred()) SWIG_fail;
28328 }
28329 {
28330 resultobj = wxPyMake_wxObject(result, 0);
28331 }
28332 return resultobj;
28333 fail:
28334 return NULL;
28335 }
28336
28337
28338 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28339 PyObject *resultobj;
28340 wxWindow *arg1 = (wxWindow *) 0 ;
28341 wxString *arg2 = 0 ;
28342 wxWindow *result;
28343 bool temp2 = false ;
28344 PyObject * obj0 = 0 ;
28345 PyObject * obj1 = 0 ;
28346 char *kwnames[] = {
28347 (char *) "self",(char *) "name", NULL
28348 };
28349
28350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28352 if (SWIG_arg_fail(1)) SWIG_fail;
28353 {
28354 arg2 = wxString_in_helper(obj1);
28355 if (arg2 == NULL) SWIG_fail;
28356 temp2 = true;
28357 }
28358 {
28359 PyThreadState* __tstate = wxPyBeginAllowThreads();
28360 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28361
28362 wxPyEndAllowThreads(__tstate);
28363 if (PyErr_Occurred()) SWIG_fail;
28364 }
28365 {
28366 resultobj = wxPyMake_wxObject(result, 0);
28367 }
28368 {
28369 if (temp2)
28370 delete arg2;
28371 }
28372 return resultobj;
28373 fail:
28374 {
28375 if (temp2)
28376 delete arg2;
28377 }
28378 return NULL;
28379 }
28380
28381
28382 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28383 PyObject *resultobj;
28384 wxWindow *arg1 = (wxWindow *) 0 ;
28385 wxEvtHandler *result;
28386 PyObject * obj0 = 0 ;
28387 char *kwnames[] = {
28388 (char *) "self", NULL
28389 };
28390
28391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28393 if (SWIG_arg_fail(1)) SWIG_fail;
28394 {
28395 PyThreadState* __tstate = wxPyBeginAllowThreads();
28396 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28397
28398 wxPyEndAllowThreads(__tstate);
28399 if (PyErr_Occurred()) SWIG_fail;
28400 }
28401 {
28402 resultobj = wxPyMake_wxObject(result, 0);
28403 }
28404 return resultobj;
28405 fail:
28406 return NULL;
28407 }
28408
28409
28410 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28411 PyObject *resultobj;
28412 wxWindow *arg1 = (wxWindow *) 0 ;
28413 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28414 PyObject * obj0 = 0 ;
28415 PyObject * obj1 = 0 ;
28416 char *kwnames[] = {
28417 (char *) "self",(char *) "handler", NULL
28418 };
28419
28420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28422 if (SWIG_arg_fail(1)) SWIG_fail;
28423 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28424 if (SWIG_arg_fail(2)) SWIG_fail;
28425 {
28426 PyThreadState* __tstate = wxPyBeginAllowThreads();
28427 (arg1)->SetEventHandler(arg2);
28428
28429 wxPyEndAllowThreads(__tstate);
28430 if (PyErr_Occurred()) SWIG_fail;
28431 }
28432 Py_INCREF(Py_None); resultobj = Py_None;
28433 return resultobj;
28434 fail:
28435 return NULL;
28436 }
28437
28438
28439 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28440 PyObject *resultobj;
28441 wxWindow *arg1 = (wxWindow *) 0 ;
28442 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28443 PyObject * obj0 = 0 ;
28444 PyObject * obj1 = 0 ;
28445 char *kwnames[] = {
28446 (char *) "self",(char *) "handler", NULL
28447 };
28448
28449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28451 if (SWIG_arg_fail(1)) SWIG_fail;
28452 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28453 if (SWIG_arg_fail(2)) SWIG_fail;
28454 {
28455 PyThreadState* __tstate = wxPyBeginAllowThreads();
28456 (arg1)->PushEventHandler(arg2);
28457
28458 wxPyEndAllowThreads(__tstate);
28459 if (PyErr_Occurred()) SWIG_fail;
28460 }
28461 Py_INCREF(Py_None); resultobj = Py_None;
28462 return resultobj;
28463 fail:
28464 return NULL;
28465 }
28466
28467
28468 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28469 PyObject *resultobj;
28470 wxWindow *arg1 = (wxWindow *) 0 ;
28471 bool arg2 = (bool) false ;
28472 wxEvtHandler *result;
28473 PyObject * obj0 = 0 ;
28474 PyObject * obj1 = 0 ;
28475 char *kwnames[] = {
28476 (char *) "self",(char *) "deleteHandler", NULL
28477 };
28478
28479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28481 if (SWIG_arg_fail(1)) SWIG_fail;
28482 if (obj1) {
28483 {
28484 arg2 = (bool)(SWIG_As_bool(obj1));
28485 if (SWIG_arg_fail(2)) SWIG_fail;
28486 }
28487 }
28488 {
28489 PyThreadState* __tstate = wxPyBeginAllowThreads();
28490 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28491
28492 wxPyEndAllowThreads(__tstate);
28493 if (PyErr_Occurred()) SWIG_fail;
28494 }
28495 {
28496 resultobj = wxPyMake_wxObject(result, 0);
28497 }
28498 return resultobj;
28499 fail:
28500 return NULL;
28501 }
28502
28503
28504 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28505 PyObject *resultobj;
28506 wxWindow *arg1 = (wxWindow *) 0 ;
28507 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28508 bool result;
28509 PyObject * obj0 = 0 ;
28510 PyObject * obj1 = 0 ;
28511 char *kwnames[] = {
28512 (char *) "self",(char *) "handler", NULL
28513 };
28514
28515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28517 if (SWIG_arg_fail(1)) SWIG_fail;
28518 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28519 if (SWIG_arg_fail(2)) SWIG_fail;
28520 {
28521 PyThreadState* __tstate = wxPyBeginAllowThreads();
28522 result = (bool)(arg1)->RemoveEventHandler(arg2);
28523
28524 wxPyEndAllowThreads(__tstate);
28525 if (PyErr_Occurred()) SWIG_fail;
28526 }
28527 {
28528 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28529 }
28530 return resultobj;
28531 fail:
28532 return NULL;
28533 }
28534
28535
28536 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28537 PyObject *resultobj;
28538 wxWindow *arg1 = (wxWindow *) 0 ;
28539 wxValidator *arg2 = 0 ;
28540 PyObject * obj0 = 0 ;
28541 PyObject * obj1 = 0 ;
28542 char *kwnames[] = {
28543 (char *) "self",(char *) "validator", NULL
28544 };
28545
28546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28548 if (SWIG_arg_fail(1)) SWIG_fail;
28549 {
28550 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28551 if (SWIG_arg_fail(2)) SWIG_fail;
28552 if (arg2 == NULL) {
28553 SWIG_null_ref("wxValidator");
28554 }
28555 if (SWIG_arg_fail(2)) SWIG_fail;
28556 }
28557 {
28558 PyThreadState* __tstate = wxPyBeginAllowThreads();
28559 (arg1)->SetValidator((wxValidator const &)*arg2);
28560
28561 wxPyEndAllowThreads(__tstate);
28562 if (PyErr_Occurred()) SWIG_fail;
28563 }
28564 Py_INCREF(Py_None); resultobj = Py_None;
28565 return resultobj;
28566 fail:
28567 return NULL;
28568 }
28569
28570
28571 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28572 PyObject *resultobj;
28573 wxWindow *arg1 = (wxWindow *) 0 ;
28574 wxValidator *result;
28575 PyObject * obj0 = 0 ;
28576 char *kwnames[] = {
28577 (char *) "self", NULL
28578 };
28579
28580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28582 if (SWIG_arg_fail(1)) SWIG_fail;
28583 {
28584 PyThreadState* __tstate = wxPyBeginAllowThreads();
28585 result = (wxValidator *)(arg1)->GetValidator();
28586
28587 wxPyEndAllowThreads(__tstate);
28588 if (PyErr_Occurred()) SWIG_fail;
28589 }
28590 {
28591 resultobj = wxPyMake_wxObject(result, 0);
28592 }
28593 return resultobj;
28594 fail:
28595 return NULL;
28596 }
28597
28598
28599 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28600 PyObject *resultobj;
28601 wxWindow *arg1 = (wxWindow *) 0 ;
28602 bool result;
28603 PyObject * obj0 = 0 ;
28604 char *kwnames[] = {
28605 (char *) "self", NULL
28606 };
28607
28608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28610 if (SWIG_arg_fail(1)) SWIG_fail;
28611 {
28612 PyThreadState* __tstate = wxPyBeginAllowThreads();
28613 result = (bool)(arg1)->Validate();
28614
28615 wxPyEndAllowThreads(__tstate);
28616 if (PyErr_Occurred()) SWIG_fail;
28617 }
28618 {
28619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28620 }
28621 return resultobj;
28622 fail:
28623 return NULL;
28624 }
28625
28626
28627 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28628 PyObject *resultobj;
28629 wxWindow *arg1 = (wxWindow *) 0 ;
28630 bool result;
28631 PyObject * obj0 = 0 ;
28632 char *kwnames[] = {
28633 (char *) "self", NULL
28634 };
28635
28636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28638 if (SWIG_arg_fail(1)) SWIG_fail;
28639 {
28640 PyThreadState* __tstate = wxPyBeginAllowThreads();
28641 result = (bool)(arg1)->TransferDataToWindow();
28642
28643 wxPyEndAllowThreads(__tstate);
28644 if (PyErr_Occurred()) SWIG_fail;
28645 }
28646 {
28647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28648 }
28649 return resultobj;
28650 fail:
28651 return NULL;
28652 }
28653
28654
28655 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28656 PyObject *resultobj;
28657 wxWindow *arg1 = (wxWindow *) 0 ;
28658 bool result;
28659 PyObject * obj0 = 0 ;
28660 char *kwnames[] = {
28661 (char *) "self", NULL
28662 };
28663
28664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28666 if (SWIG_arg_fail(1)) SWIG_fail;
28667 {
28668 PyThreadState* __tstate = wxPyBeginAllowThreads();
28669 result = (bool)(arg1)->TransferDataFromWindow();
28670
28671 wxPyEndAllowThreads(__tstate);
28672 if (PyErr_Occurred()) SWIG_fail;
28673 }
28674 {
28675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28676 }
28677 return resultobj;
28678 fail:
28679 return NULL;
28680 }
28681
28682
28683 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28684 PyObject *resultobj;
28685 wxWindow *arg1 = (wxWindow *) 0 ;
28686 PyObject * obj0 = 0 ;
28687 char *kwnames[] = {
28688 (char *) "self", NULL
28689 };
28690
28691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28693 if (SWIG_arg_fail(1)) SWIG_fail;
28694 {
28695 PyThreadState* __tstate = wxPyBeginAllowThreads();
28696 (arg1)->InitDialog();
28697
28698 wxPyEndAllowThreads(__tstate);
28699 if (PyErr_Occurred()) SWIG_fail;
28700 }
28701 Py_INCREF(Py_None); resultobj = Py_None;
28702 return resultobj;
28703 fail:
28704 return NULL;
28705 }
28706
28707
28708 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28709 PyObject *resultobj;
28710 wxWindow *arg1 = (wxWindow *) 0 ;
28711 wxAcceleratorTable *arg2 = 0 ;
28712 PyObject * obj0 = 0 ;
28713 PyObject * obj1 = 0 ;
28714 char *kwnames[] = {
28715 (char *) "self",(char *) "accel", NULL
28716 };
28717
28718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28720 if (SWIG_arg_fail(1)) SWIG_fail;
28721 {
28722 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28723 if (SWIG_arg_fail(2)) SWIG_fail;
28724 if (arg2 == NULL) {
28725 SWIG_null_ref("wxAcceleratorTable");
28726 }
28727 if (SWIG_arg_fail(2)) SWIG_fail;
28728 }
28729 {
28730 PyThreadState* __tstate = wxPyBeginAllowThreads();
28731 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28732
28733 wxPyEndAllowThreads(__tstate);
28734 if (PyErr_Occurred()) SWIG_fail;
28735 }
28736 Py_INCREF(Py_None); resultobj = Py_None;
28737 return resultobj;
28738 fail:
28739 return NULL;
28740 }
28741
28742
28743 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28744 PyObject *resultobj;
28745 wxWindow *arg1 = (wxWindow *) 0 ;
28746 wxAcceleratorTable *result;
28747 PyObject * obj0 = 0 ;
28748 char *kwnames[] = {
28749 (char *) "self", NULL
28750 };
28751
28752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28754 if (SWIG_arg_fail(1)) SWIG_fail;
28755 {
28756 PyThreadState* __tstate = wxPyBeginAllowThreads();
28757 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28758
28759 wxPyEndAllowThreads(__tstate);
28760 if (PyErr_Occurred()) SWIG_fail;
28761 }
28762 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28763 return resultobj;
28764 fail:
28765 return NULL;
28766 }
28767
28768
28769 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28770 PyObject *resultobj;
28771 wxWindow *arg1 = (wxWindow *) 0 ;
28772 int arg2 ;
28773 int arg3 ;
28774 int arg4 ;
28775 bool result;
28776 PyObject * obj0 = 0 ;
28777 PyObject * obj1 = 0 ;
28778 PyObject * obj2 = 0 ;
28779 PyObject * obj3 = 0 ;
28780 char *kwnames[] = {
28781 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28782 };
28783
28784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28786 if (SWIG_arg_fail(1)) SWIG_fail;
28787 {
28788 arg2 = (int)(SWIG_As_int(obj1));
28789 if (SWIG_arg_fail(2)) SWIG_fail;
28790 }
28791 {
28792 arg3 = (int)(SWIG_As_int(obj2));
28793 if (SWIG_arg_fail(3)) SWIG_fail;
28794 }
28795 {
28796 arg4 = (int)(SWIG_As_int(obj3));
28797 if (SWIG_arg_fail(4)) SWIG_fail;
28798 }
28799 {
28800 PyThreadState* __tstate = wxPyBeginAllowThreads();
28801 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28802
28803 wxPyEndAllowThreads(__tstate);
28804 if (PyErr_Occurred()) SWIG_fail;
28805 }
28806 {
28807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28808 }
28809 return resultobj;
28810 fail:
28811 return NULL;
28812 }
28813
28814
28815 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28816 PyObject *resultobj;
28817 wxWindow *arg1 = (wxWindow *) 0 ;
28818 int arg2 ;
28819 bool result;
28820 PyObject * obj0 = 0 ;
28821 PyObject * obj1 = 0 ;
28822 char *kwnames[] = {
28823 (char *) "self",(char *) "hotkeyId", NULL
28824 };
28825
28826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) 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 = (int)(SWIG_As_int(obj1));
28831 if (SWIG_arg_fail(2)) SWIG_fail;
28832 }
28833 {
28834 PyThreadState* __tstate = wxPyBeginAllowThreads();
28835 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28836
28837 wxPyEndAllowThreads(__tstate);
28838 if (PyErr_Occurred()) SWIG_fail;
28839 }
28840 {
28841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28842 }
28843 return resultobj;
28844 fail:
28845 return NULL;
28846 }
28847
28848
28849 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28850 PyObject *resultobj;
28851 wxWindow *arg1 = (wxWindow *) 0 ;
28852 wxPoint *arg2 = 0 ;
28853 wxPoint result;
28854 wxPoint temp2 ;
28855 PyObject * obj0 = 0 ;
28856 PyObject * obj1 = 0 ;
28857 char *kwnames[] = {
28858 (char *) "self",(char *) "pt", NULL
28859 };
28860
28861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
28866 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28867 }
28868 {
28869 PyThreadState* __tstate = wxPyBeginAllowThreads();
28870 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28871
28872 wxPyEndAllowThreads(__tstate);
28873 if (PyErr_Occurred()) SWIG_fail;
28874 }
28875 {
28876 wxPoint * resultptr;
28877 resultptr = new wxPoint((wxPoint &)(result));
28878 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28879 }
28880 return resultobj;
28881 fail:
28882 return NULL;
28883 }
28884
28885
28886 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28887 PyObject *resultobj;
28888 wxWindow *arg1 = (wxWindow *) 0 ;
28889 wxSize *arg2 = 0 ;
28890 wxSize result;
28891 wxSize temp2 ;
28892 PyObject * obj0 = 0 ;
28893 PyObject * obj1 = 0 ;
28894 char *kwnames[] = {
28895 (char *) "self",(char *) "sz", NULL
28896 };
28897
28898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28900 if (SWIG_arg_fail(1)) SWIG_fail;
28901 {
28902 arg2 = &temp2;
28903 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28904 }
28905 {
28906 PyThreadState* __tstate = wxPyBeginAllowThreads();
28907 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28908
28909 wxPyEndAllowThreads(__tstate);
28910 if (PyErr_Occurred()) SWIG_fail;
28911 }
28912 {
28913 wxSize * resultptr;
28914 resultptr = new wxSize((wxSize &)(result));
28915 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28916 }
28917 return resultobj;
28918 fail:
28919 return NULL;
28920 }
28921
28922
28923 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28924 PyObject *resultobj;
28925 wxWindow *arg1 = (wxWindow *) 0 ;
28926 wxPoint *arg2 = 0 ;
28927 wxPoint result;
28928 wxPoint temp2 ;
28929 PyObject * obj0 = 0 ;
28930 PyObject * obj1 = 0 ;
28931 char *kwnames[] = {
28932 (char *) "self",(char *) "pt", NULL
28933 };
28934
28935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28937 if (SWIG_arg_fail(1)) SWIG_fail;
28938 {
28939 arg2 = &temp2;
28940 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28941 }
28942 {
28943 PyThreadState* __tstate = wxPyBeginAllowThreads();
28944 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28945
28946 wxPyEndAllowThreads(__tstate);
28947 if (PyErr_Occurred()) SWIG_fail;
28948 }
28949 {
28950 wxPoint * resultptr;
28951 resultptr = new wxPoint((wxPoint &)(result));
28952 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28953 }
28954 return resultobj;
28955 fail:
28956 return NULL;
28957 }
28958
28959
28960 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28961 PyObject *resultobj;
28962 wxWindow *arg1 = (wxWindow *) 0 ;
28963 wxSize *arg2 = 0 ;
28964 wxSize result;
28965 wxSize temp2 ;
28966 PyObject * obj0 = 0 ;
28967 PyObject * obj1 = 0 ;
28968 char *kwnames[] = {
28969 (char *) "self",(char *) "sz", NULL
28970 };
28971
28972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28974 if (SWIG_arg_fail(1)) SWIG_fail;
28975 {
28976 arg2 = &temp2;
28977 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28978 }
28979 {
28980 PyThreadState* __tstate = wxPyBeginAllowThreads();
28981 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28982
28983 wxPyEndAllowThreads(__tstate);
28984 if (PyErr_Occurred()) SWIG_fail;
28985 }
28986 {
28987 wxSize * resultptr;
28988 resultptr = new wxSize((wxSize &)(result));
28989 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28990 }
28991 return resultobj;
28992 fail:
28993 return NULL;
28994 }
28995
28996
28997 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28998 PyObject *resultobj;
28999 wxWindow *arg1 = (wxWindow *) 0 ;
29000 wxPoint *arg2 = 0 ;
29001 wxPoint result;
29002 wxPoint temp2 ;
29003 PyObject * obj0 = 0 ;
29004 PyObject * obj1 = 0 ;
29005 char *kwnames[] = {
29006 (char *) "self",(char *) "pt", NULL
29007 };
29008
29009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29011 if (SWIG_arg_fail(1)) SWIG_fail;
29012 {
29013 arg2 = &temp2;
29014 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29015 }
29016 {
29017 PyThreadState* __tstate = wxPyBeginAllowThreads();
29018 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29019
29020 wxPyEndAllowThreads(__tstate);
29021 if (PyErr_Occurred()) SWIG_fail;
29022 }
29023 {
29024 wxPoint * resultptr;
29025 resultptr = new wxPoint((wxPoint &)(result));
29026 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29027 }
29028 return resultobj;
29029 fail:
29030 return NULL;
29031 }
29032
29033
29034 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29035 PyObject *resultobj;
29036 wxWindow *arg1 = (wxWindow *) 0 ;
29037 wxSize *arg2 = 0 ;
29038 wxSize result;
29039 wxSize temp2 ;
29040 PyObject * obj0 = 0 ;
29041 PyObject * obj1 = 0 ;
29042 char *kwnames[] = {
29043 (char *) "self",(char *) "sz", NULL
29044 };
29045
29046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29048 if (SWIG_arg_fail(1)) SWIG_fail;
29049 {
29050 arg2 = &temp2;
29051 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29052 }
29053 {
29054 PyThreadState* __tstate = wxPyBeginAllowThreads();
29055 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29056
29057 wxPyEndAllowThreads(__tstate);
29058 if (PyErr_Occurred()) SWIG_fail;
29059 }
29060 {
29061 wxSize * resultptr;
29062 resultptr = new wxSize((wxSize &)(result));
29063 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29064 }
29065 return resultobj;
29066 fail:
29067 return NULL;
29068 }
29069
29070
29071 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29072 PyObject *resultobj;
29073 wxWindow *arg1 = (wxWindow *) 0 ;
29074 int arg2 ;
29075 int arg3 ;
29076 PyObject * obj0 = 0 ;
29077 PyObject * obj1 = 0 ;
29078 PyObject * obj2 = 0 ;
29079 char *kwnames[] = {
29080 (char *) "self",(char *) "x",(char *) "y", NULL
29081 };
29082
29083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29085 if (SWIG_arg_fail(1)) SWIG_fail;
29086 {
29087 arg2 = (int)(SWIG_As_int(obj1));
29088 if (SWIG_arg_fail(2)) SWIG_fail;
29089 }
29090 {
29091 arg3 = (int)(SWIG_As_int(obj2));
29092 if (SWIG_arg_fail(3)) SWIG_fail;
29093 }
29094 {
29095 PyThreadState* __tstate = wxPyBeginAllowThreads();
29096 (arg1)->WarpPointer(arg2,arg3);
29097
29098 wxPyEndAllowThreads(__tstate);
29099 if (PyErr_Occurred()) SWIG_fail;
29100 }
29101 Py_INCREF(Py_None); resultobj = Py_None;
29102 return resultobj;
29103 fail:
29104 return NULL;
29105 }
29106
29107
29108 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29109 PyObject *resultobj;
29110 wxWindow *arg1 = (wxWindow *) 0 ;
29111 PyObject * obj0 = 0 ;
29112 char *kwnames[] = {
29113 (char *) "self", NULL
29114 };
29115
29116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29118 if (SWIG_arg_fail(1)) SWIG_fail;
29119 {
29120 PyThreadState* __tstate = wxPyBeginAllowThreads();
29121 (arg1)->CaptureMouse();
29122
29123 wxPyEndAllowThreads(__tstate);
29124 if (PyErr_Occurred()) SWIG_fail;
29125 }
29126 Py_INCREF(Py_None); resultobj = Py_None;
29127 return resultobj;
29128 fail:
29129 return NULL;
29130 }
29131
29132
29133 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29134 PyObject *resultobj;
29135 wxWindow *arg1 = (wxWindow *) 0 ;
29136 PyObject * obj0 = 0 ;
29137 char *kwnames[] = {
29138 (char *) "self", NULL
29139 };
29140
29141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29143 if (SWIG_arg_fail(1)) SWIG_fail;
29144 {
29145 PyThreadState* __tstate = wxPyBeginAllowThreads();
29146 (arg1)->ReleaseMouse();
29147
29148 wxPyEndAllowThreads(__tstate);
29149 if (PyErr_Occurred()) SWIG_fail;
29150 }
29151 Py_INCREF(Py_None); resultobj = Py_None;
29152 return resultobj;
29153 fail:
29154 return NULL;
29155 }
29156
29157
29158 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29159 PyObject *resultobj;
29160 wxWindow *result;
29161 char *kwnames[] = {
29162 NULL
29163 };
29164
29165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29166 {
29167 if (!wxPyCheckForApp()) SWIG_fail;
29168 PyThreadState* __tstate = wxPyBeginAllowThreads();
29169 result = (wxWindow *)wxWindow::GetCapture();
29170
29171 wxPyEndAllowThreads(__tstate);
29172 if (PyErr_Occurred()) SWIG_fail;
29173 }
29174 {
29175 resultobj = wxPyMake_wxObject(result, 0);
29176 }
29177 return resultobj;
29178 fail:
29179 return NULL;
29180 }
29181
29182
29183 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29184 PyObject *resultobj;
29185 wxWindow *arg1 = (wxWindow *) 0 ;
29186 bool result;
29187 PyObject * obj0 = 0 ;
29188 char *kwnames[] = {
29189 (char *) "self", NULL
29190 };
29191
29192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29194 if (SWIG_arg_fail(1)) SWIG_fail;
29195 {
29196 PyThreadState* __tstate = wxPyBeginAllowThreads();
29197 result = (bool)((wxWindow const *)arg1)->HasCapture();
29198
29199 wxPyEndAllowThreads(__tstate);
29200 if (PyErr_Occurred()) SWIG_fail;
29201 }
29202 {
29203 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29204 }
29205 return resultobj;
29206 fail:
29207 return NULL;
29208 }
29209
29210
29211 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29212 PyObject *resultobj;
29213 wxWindow *arg1 = (wxWindow *) 0 ;
29214 bool arg2 = (bool) true ;
29215 wxRect *arg3 = (wxRect *) NULL ;
29216 PyObject * obj0 = 0 ;
29217 PyObject * obj1 = 0 ;
29218 PyObject * obj2 = 0 ;
29219 char *kwnames[] = {
29220 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29221 };
29222
29223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29225 if (SWIG_arg_fail(1)) SWIG_fail;
29226 if (obj1) {
29227 {
29228 arg2 = (bool)(SWIG_As_bool(obj1));
29229 if (SWIG_arg_fail(2)) SWIG_fail;
29230 }
29231 }
29232 if (obj2) {
29233 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29234 if (SWIG_arg_fail(3)) SWIG_fail;
29235 }
29236 {
29237 PyThreadState* __tstate = wxPyBeginAllowThreads();
29238 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29239
29240 wxPyEndAllowThreads(__tstate);
29241 if (PyErr_Occurred()) SWIG_fail;
29242 }
29243 Py_INCREF(Py_None); resultobj = Py_None;
29244 return resultobj;
29245 fail:
29246 return NULL;
29247 }
29248
29249
29250 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29251 PyObject *resultobj;
29252 wxWindow *arg1 = (wxWindow *) 0 ;
29253 wxRect *arg2 = 0 ;
29254 bool arg3 = (bool) true ;
29255 wxRect temp2 ;
29256 PyObject * obj0 = 0 ;
29257 PyObject * obj1 = 0 ;
29258 PyObject * obj2 = 0 ;
29259 char *kwnames[] = {
29260 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29261 };
29262
29263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29265 if (SWIG_arg_fail(1)) SWIG_fail;
29266 {
29267 arg2 = &temp2;
29268 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29269 }
29270 if (obj2) {
29271 {
29272 arg3 = (bool)(SWIG_As_bool(obj2));
29273 if (SWIG_arg_fail(3)) SWIG_fail;
29274 }
29275 }
29276 {
29277 PyThreadState* __tstate = wxPyBeginAllowThreads();
29278 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29279
29280 wxPyEndAllowThreads(__tstate);
29281 if (PyErr_Occurred()) SWIG_fail;
29282 }
29283 Py_INCREF(Py_None); resultobj = Py_None;
29284 return resultobj;
29285 fail:
29286 return NULL;
29287 }
29288
29289
29290 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29291 PyObject *resultobj;
29292 wxWindow *arg1 = (wxWindow *) 0 ;
29293 PyObject * obj0 = 0 ;
29294 char *kwnames[] = {
29295 (char *) "self", NULL
29296 };
29297
29298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29300 if (SWIG_arg_fail(1)) SWIG_fail;
29301 {
29302 PyThreadState* __tstate = wxPyBeginAllowThreads();
29303 (arg1)->Update();
29304
29305 wxPyEndAllowThreads(__tstate);
29306 if (PyErr_Occurred()) SWIG_fail;
29307 }
29308 Py_INCREF(Py_None); resultobj = Py_None;
29309 return resultobj;
29310 fail:
29311 return NULL;
29312 }
29313
29314
29315 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29316 PyObject *resultobj;
29317 wxWindow *arg1 = (wxWindow *) 0 ;
29318 PyObject * obj0 = 0 ;
29319 char *kwnames[] = {
29320 (char *) "self", NULL
29321 };
29322
29323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29325 if (SWIG_arg_fail(1)) SWIG_fail;
29326 {
29327 PyThreadState* __tstate = wxPyBeginAllowThreads();
29328 (arg1)->ClearBackground();
29329
29330 wxPyEndAllowThreads(__tstate);
29331 if (PyErr_Occurred()) SWIG_fail;
29332 }
29333 Py_INCREF(Py_None); resultobj = Py_None;
29334 return resultobj;
29335 fail:
29336 return NULL;
29337 }
29338
29339
29340 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29341 PyObject *resultobj;
29342 wxWindow *arg1 = (wxWindow *) 0 ;
29343 PyObject * obj0 = 0 ;
29344 char *kwnames[] = {
29345 (char *) "self", NULL
29346 };
29347
29348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29350 if (SWIG_arg_fail(1)) SWIG_fail;
29351 {
29352 PyThreadState* __tstate = wxPyBeginAllowThreads();
29353 (arg1)->Freeze();
29354
29355 wxPyEndAllowThreads(__tstate);
29356 if (PyErr_Occurred()) SWIG_fail;
29357 }
29358 Py_INCREF(Py_None); resultobj = Py_None;
29359 return resultobj;
29360 fail:
29361 return NULL;
29362 }
29363
29364
29365 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29366 PyObject *resultobj;
29367 wxWindow *arg1 = (wxWindow *) 0 ;
29368 PyObject * obj0 = 0 ;
29369 char *kwnames[] = {
29370 (char *) "self", NULL
29371 };
29372
29373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29375 if (SWIG_arg_fail(1)) SWIG_fail;
29376 {
29377 PyThreadState* __tstate = wxPyBeginAllowThreads();
29378 (arg1)->Thaw();
29379
29380 wxPyEndAllowThreads(__tstate);
29381 if (PyErr_Occurred()) SWIG_fail;
29382 }
29383 Py_INCREF(Py_None); resultobj = Py_None;
29384 return resultobj;
29385 fail:
29386 return NULL;
29387 }
29388
29389
29390 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29391 PyObject *resultobj;
29392 wxWindow *arg1 = (wxWindow *) 0 ;
29393 wxDC *arg2 = 0 ;
29394 PyObject * obj0 = 0 ;
29395 PyObject * obj1 = 0 ;
29396 char *kwnames[] = {
29397 (char *) "self",(char *) "dc", NULL
29398 };
29399
29400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29402 if (SWIG_arg_fail(1)) SWIG_fail;
29403 {
29404 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29405 if (SWIG_arg_fail(2)) SWIG_fail;
29406 if (arg2 == NULL) {
29407 SWIG_null_ref("wxDC");
29408 }
29409 if (SWIG_arg_fail(2)) SWIG_fail;
29410 }
29411 {
29412 PyThreadState* __tstate = wxPyBeginAllowThreads();
29413 (arg1)->PrepareDC(*arg2);
29414
29415 wxPyEndAllowThreads(__tstate);
29416 if (PyErr_Occurred()) SWIG_fail;
29417 }
29418 Py_INCREF(Py_None); resultobj = Py_None;
29419 return resultobj;
29420 fail:
29421 return NULL;
29422 }
29423
29424
29425 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29426 PyObject *resultobj;
29427 wxWindow *arg1 = (wxWindow *) 0 ;
29428 wxRegion *result;
29429 PyObject * obj0 = 0 ;
29430 char *kwnames[] = {
29431 (char *) "self", NULL
29432 };
29433
29434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29436 if (SWIG_arg_fail(1)) SWIG_fail;
29437 {
29438 PyThreadState* __tstate = wxPyBeginAllowThreads();
29439 {
29440 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29441 result = (wxRegion *) &_result_ref;
29442 }
29443
29444 wxPyEndAllowThreads(__tstate);
29445 if (PyErr_Occurred()) SWIG_fail;
29446 }
29447 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29448 return resultobj;
29449 fail:
29450 return NULL;
29451 }
29452
29453
29454 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29455 PyObject *resultobj;
29456 wxWindow *arg1 = (wxWindow *) 0 ;
29457 wxRect result;
29458 PyObject * obj0 = 0 ;
29459 char *kwnames[] = {
29460 (char *) "self", NULL
29461 };
29462
29463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29465 if (SWIG_arg_fail(1)) SWIG_fail;
29466 {
29467 PyThreadState* __tstate = wxPyBeginAllowThreads();
29468 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29469
29470 wxPyEndAllowThreads(__tstate);
29471 if (PyErr_Occurred()) SWIG_fail;
29472 }
29473 {
29474 wxRect * resultptr;
29475 resultptr = new wxRect((wxRect &)(result));
29476 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29477 }
29478 return resultobj;
29479 fail:
29480 return NULL;
29481 }
29482
29483
29484 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29485 PyObject *resultobj;
29486 wxWindow *arg1 = (wxWindow *) 0 ;
29487 int arg2 ;
29488 int arg3 ;
29489 int arg4 = (int) 1 ;
29490 int arg5 = (int) 1 ;
29491 bool result;
29492 PyObject * obj0 = 0 ;
29493 PyObject * obj1 = 0 ;
29494 PyObject * obj2 = 0 ;
29495 PyObject * obj3 = 0 ;
29496 PyObject * obj4 = 0 ;
29497 char *kwnames[] = {
29498 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29499 };
29500
29501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29503 if (SWIG_arg_fail(1)) SWIG_fail;
29504 {
29505 arg2 = (int)(SWIG_As_int(obj1));
29506 if (SWIG_arg_fail(2)) SWIG_fail;
29507 }
29508 {
29509 arg3 = (int)(SWIG_As_int(obj2));
29510 if (SWIG_arg_fail(3)) SWIG_fail;
29511 }
29512 if (obj3) {
29513 {
29514 arg4 = (int)(SWIG_As_int(obj3));
29515 if (SWIG_arg_fail(4)) SWIG_fail;
29516 }
29517 }
29518 if (obj4) {
29519 {
29520 arg5 = (int)(SWIG_As_int(obj4));
29521 if (SWIG_arg_fail(5)) SWIG_fail;
29522 }
29523 }
29524 {
29525 PyThreadState* __tstate = wxPyBeginAllowThreads();
29526 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29527
29528 wxPyEndAllowThreads(__tstate);
29529 if (PyErr_Occurred()) SWIG_fail;
29530 }
29531 {
29532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29533 }
29534 return resultobj;
29535 fail:
29536 return NULL;
29537 }
29538
29539
29540 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29541 PyObject *resultobj;
29542 wxWindow *arg1 = (wxWindow *) 0 ;
29543 wxPoint *arg2 = 0 ;
29544 bool result;
29545 wxPoint temp2 ;
29546 PyObject * obj0 = 0 ;
29547 PyObject * obj1 = 0 ;
29548 char *kwnames[] = {
29549 (char *) "self",(char *) "pt", NULL
29550 };
29551
29552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29554 if (SWIG_arg_fail(1)) SWIG_fail;
29555 {
29556 arg2 = &temp2;
29557 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29558 }
29559 {
29560 PyThreadState* __tstate = wxPyBeginAllowThreads();
29561 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29562
29563 wxPyEndAllowThreads(__tstate);
29564 if (PyErr_Occurred()) SWIG_fail;
29565 }
29566 {
29567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29568 }
29569 return resultobj;
29570 fail:
29571 return NULL;
29572 }
29573
29574
29575 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29576 PyObject *resultobj;
29577 wxWindow *arg1 = (wxWindow *) 0 ;
29578 wxRect *arg2 = 0 ;
29579 bool result;
29580 wxRect temp2 ;
29581 PyObject * obj0 = 0 ;
29582 PyObject * obj1 = 0 ;
29583 char *kwnames[] = {
29584 (char *) "self",(char *) "rect", NULL
29585 };
29586
29587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",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 arg2 = &temp2;
29592 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29593 }
29594 {
29595 PyThreadState* __tstate = wxPyBeginAllowThreads();
29596 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29597
29598 wxPyEndAllowThreads(__tstate);
29599 if (PyErr_Occurred()) SWIG_fail;
29600 }
29601 {
29602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29603 }
29604 return resultobj;
29605 fail:
29606 return NULL;
29607 }
29608
29609
29610 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29611 PyObject *resultobj;
29612 wxWindow *arg1 = (wxWindow *) 0 ;
29613 wxVisualAttributes result;
29614 PyObject * obj0 = 0 ;
29615 char *kwnames[] = {
29616 (char *) "self", NULL
29617 };
29618
29619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29621 if (SWIG_arg_fail(1)) SWIG_fail;
29622 {
29623 PyThreadState* __tstate = wxPyBeginAllowThreads();
29624 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29625
29626 wxPyEndAllowThreads(__tstate);
29627 if (PyErr_Occurred()) SWIG_fail;
29628 }
29629 {
29630 wxVisualAttributes * resultptr;
29631 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29632 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29633 }
29634 return resultobj;
29635 fail:
29636 return NULL;
29637 }
29638
29639
29640 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29641 PyObject *resultobj;
29642 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29643 wxVisualAttributes result;
29644 PyObject * obj0 = 0 ;
29645 char *kwnames[] = {
29646 (char *) "variant", NULL
29647 };
29648
29649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29650 if (obj0) {
29651 {
29652 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29653 if (SWIG_arg_fail(1)) SWIG_fail;
29654 }
29655 }
29656 {
29657 if (!wxPyCheckForApp()) SWIG_fail;
29658 PyThreadState* __tstate = wxPyBeginAllowThreads();
29659 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29660
29661 wxPyEndAllowThreads(__tstate);
29662 if (PyErr_Occurred()) SWIG_fail;
29663 }
29664 {
29665 wxVisualAttributes * resultptr;
29666 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29667 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29668 }
29669 return resultobj;
29670 fail:
29671 return NULL;
29672 }
29673
29674
29675 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29676 PyObject *resultobj;
29677 wxWindow *arg1 = (wxWindow *) 0 ;
29678 wxColour *arg2 = 0 ;
29679 bool result;
29680 wxColour temp2 ;
29681 PyObject * obj0 = 0 ;
29682 PyObject * obj1 = 0 ;
29683 char *kwnames[] = {
29684 (char *) "self",(char *) "colour", NULL
29685 };
29686
29687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29689 if (SWIG_arg_fail(1)) SWIG_fail;
29690 {
29691 arg2 = &temp2;
29692 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29693 }
29694 {
29695 PyThreadState* __tstate = wxPyBeginAllowThreads();
29696 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29697
29698 wxPyEndAllowThreads(__tstate);
29699 if (PyErr_Occurred()) SWIG_fail;
29700 }
29701 {
29702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29703 }
29704 return resultobj;
29705 fail:
29706 return NULL;
29707 }
29708
29709
29710 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29711 PyObject *resultobj;
29712 wxWindow *arg1 = (wxWindow *) 0 ;
29713 wxColour *arg2 = 0 ;
29714 wxColour temp2 ;
29715 PyObject * obj0 = 0 ;
29716 PyObject * obj1 = 0 ;
29717 char *kwnames[] = {
29718 (char *) "self",(char *) "colour", NULL
29719 };
29720
29721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29723 if (SWIG_arg_fail(1)) SWIG_fail;
29724 {
29725 arg2 = &temp2;
29726 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29727 }
29728 {
29729 PyThreadState* __tstate = wxPyBeginAllowThreads();
29730 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29731
29732 wxPyEndAllowThreads(__tstate);
29733 if (PyErr_Occurred()) SWIG_fail;
29734 }
29735 Py_INCREF(Py_None); resultobj = Py_None;
29736 return resultobj;
29737 fail:
29738 return NULL;
29739 }
29740
29741
29742 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29743 PyObject *resultobj;
29744 wxWindow *arg1 = (wxWindow *) 0 ;
29745 wxColour *arg2 = 0 ;
29746 bool result;
29747 wxColour temp2 ;
29748 PyObject * obj0 = 0 ;
29749 PyObject * obj1 = 0 ;
29750 char *kwnames[] = {
29751 (char *) "self",(char *) "colour", NULL
29752 };
29753
29754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29756 if (SWIG_arg_fail(1)) SWIG_fail;
29757 {
29758 arg2 = &temp2;
29759 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29760 }
29761 {
29762 PyThreadState* __tstate = wxPyBeginAllowThreads();
29763 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29764
29765 wxPyEndAllowThreads(__tstate);
29766 if (PyErr_Occurred()) SWIG_fail;
29767 }
29768 {
29769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29770 }
29771 return resultobj;
29772 fail:
29773 return NULL;
29774 }
29775
29776
29777 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29778 PyObject *resultobj;
29779 wxWindow *arg1 = (wxWindow *) 0 ;
29780 wxColour *arg2 = 0 ;
29781 wxColour temp2 ;
29782 PyObject * obj0 = 0 ;
29783 PyObject * obj1 = 0 ;
29784 char *kwnames[] = {
29785 (char *) "self",(char *) "colour", NULL
29786 };
29787
29788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29790 if (SWIG_arg_fail(1)) SWIG_fail;
29791 {
29792 arg2 = &temp2;
29793 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29794 }
29795 {
29796 PyThreadState* __tstate = wxPyBeginAllowThreads();
29797 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29798
29799 wxPyEndAllowThreads(__tstate);
29800 if (PyErr_Occurred()) SWIG_fail;
29801 }
29802 Py_INCREF(Py_None); resultobj = Py_None;
29803 return resultobj;
29804 fail:
29805 return NULL;
29806 }
29807
29808
29809 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29810 PyObject *resultobj;
29811 wxWindow *arg1 = (wxWindow *) 0 ;
29812 wxColour result;
29813 PyObject * obj0 = 0 ;
29814 char *kwnames[] = {
29815 (char *) "self", NULL
29816 };
29817
29818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29820 if (SWIG_arg_fail(1)) SWIG_fail;
29821 {
29822 PyThreadState* __tstate = wxPyBeginAllowThreads();
29823 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29824
29825 wxPyEndAllowThreads(__tstate);
29826 if (PyErr_Occurred()) SWIG_fail;
29827 }
29828 {
29829 wxColour * resultptr;
29830 resultptr = new wxColour((wxColour &)(result));
29831 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29832 }
29833 return resultobj;
29834 fail:
29835 return NULL;
29836 }
29837
29838
29839 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29840 PyObject *resultobj;
29841 wxWindow *arg1 = (wxWindow *) 0 ;
29842 wxColour result;
29843 PyObject * obj0 = 0 ;
29844 char *kwnames[] = {
29845 (char *) "self", NULL
29846 };
29847
29848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29850 if (SWIG_arg_fail(1)) SWIG_fail;
29851 {
29852 PyThreadState* __tstate = wxPyBeginAllowThreads();
29853 result = ((wxWindow const *)arg1)->GetForegroundColour();
29854
29855 wxPyEndAllowThreads(__tstate);
29856 if (PyErr_Occurred()) SWIG_fail;
29857 }
29858 {
29859 wxColour * resultptr;
29860 resultptr = new wxColour((wxColour &)(result));
29861 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29862 }
29863 return resultobj;
29864 fail:
29865 return NULL;
29866 }
29867
29868
29869 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29870 PyObject *resultobj;
29871 wxWindow *arg1 = (wxWindow *) 0 ;
29872 bool result;
29873 PyObject * obj0 = 0 ;
29874 char *kwnames[] = {
29875 (char *) "self", NULL
29876 };
29877
29878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29880 if (SWIG_arg_fail(1)) SWIG_fail;
29881 {
29882 PyThreadState* __tstate = wxPyBeginAllowThreads();
29883 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29884
29885 wxPyEndAllowThreads(__tstate);
29886 if (PyErr_Occurred()) SWIG_fail;
29887 }
29888 {
29889 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29890 }
29891 return resultobj;
29892 fail:
29893 return NULL;
29894 }
29895
29896
29897 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29898 PyObject *resultobj;
29899 wxWindow *arg1 = (wxWindow *) 0 ;
29900 bool result;
29901 PyObject * obj0 = 0 ;
29902 char *kwnames[] = {
29903 (char *) "self", NULL
29904 };
29905
29906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29908 if (SWIG_arg_fail(1)) SWIG_fail;
29909 {
29910 PyThreadState* __tstate = wxPyBeginAllowThreads();
29911 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29912
29913 wxPyEndAllowThreads(__tstate);
29914 if (PyErr_Occurred()) SWIG_fail;
29915 }
29916 {
29917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29918 }
29919 return resultobj;
29920 fail:
29921 return NULL;
29922 }
29923
29924
29925 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29926 PyObject *resultobj;
29927 wxWindow *arg1 = (wxWindow *) 0 ;
29928 wxBackgroundStyle arg2 ;
29929 bool result;
29930 PyObject * obj0 = 0 ;
29931 PyObject * obj1 = 0 ;
29932 char *kwnames[] = {
29933 (char *) "self",(char *) "style", NULL
29934 };
29935
29936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29938 if (SWIG_arg_fail(1)) SWIG_fail;
29939 {
29940 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29941 if (SWIG_arg_fail(2)) SWIG_fail;
29942 }
29943 {
29944 PyThreadState* __tstate = wxPyBeginAllowThreads();
29945 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29946
29947 wxPyEndAllowThreads(__tstate);
29948 if (PyErr_Occurred()) SWIG_fail;
29949 }
29950 {
29951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29952 }
29953 return resultobj;
29954 fail:
29955 return NULL;
29956 }
29957
29958
29959 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29960 PyObject *resultobj;
29961 wxWindow *arg1 = (wxWindow *) 0 ;
29962 wxBackgroundStyle result;
29963 PyObject * obj0 = 0 ;
29964 char *kwnames[] = {
29965 (char *) "self", NULL
29966 };
29967
29968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29970 if (SWIG_arg_fail(1)) SWIG_fail;
29971 {
29972 PyThreadState* __tstate = wxPyBeginAllowThreads();
29973 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29974
29975 wxPyEndAllowThreads(__tstate);
29976 if (PyErr_Occurred()) SWIG_fail;
29977 }
29978 resultobj = SWIG_From_int((result));
29979 return resultobj;
29980 fail:
29981 return NULL;
29982 }
29983
29984
29985 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29986 PyObject *resultobj;
29987 wxWindow *arg1 = (wxWindow *) 0 ;
29988 bool result;
29989 PyObject * obj0 = 0 ;
29990 char *kwnames[] = {
29991 (char *) "self", NULL
29992 };
29993
29994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29996 if (SWIG_arg_fail(1)) SWIG_fail;
29997 {
29998 PyThreadState* __tstate = wxPyBeginAllowThreads();
29999 result = (bool)(arg1)->HasTransparentBackground();
30000
30001 wxPyEndAllowThreads(__tstate);
30002 if (PyErr_Occurred()) SWIG_fail;
30003 }
30004 {
30005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30006 }
30007 return resultobj;
30008 fail:
30009 return NULL;
30010 }
30011
30012
30013 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30014 PyObject *resultobj;
30015 wxWindow *arg1 = (wxWindow *) 0 ;
30016 wxCursor *arg2 = 0 ;
30017 bool result;
30018 PyObject * obj0 = 0 ;
30019 PyObject * obj1 = 0 ;
30020 char *kwnames[] = {
30021 (char *) "self",(char *) "cursor", NULL
30022 };
30023
30024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30026 if (SWIG_arg_fail(1)) SWIG_fail;
30027 {
30028 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30029 if (SWIG_arg_fail(2)) SWIG_fail;
30030 if (arg2 == NULL) {
30031 SWIG_null_ref("wxCursor");
30032 }
30033 if (SWIG_arg_fail(2)) SWIG_fail;
30034 }
30035 {
30036 PyThreadState* __tstate = wxPyBeginAllowThreads();
30037 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30038
30039 wxPyEndAllowThreads(__tstate);
30040 if (PyErr_Occurred()) SWIG_fail;
30041 }
30042 {
30043 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30044 }
30045 return resultobj;
30046 fail:
30047 return NULL;
30048 }
30049
30050
30051 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30052 PyObject *resultobj;
30053 wxWindow *arg1 = (wxWindow *) 0 ;
30054 wxCursor result;
30055 PyObject * obj0 = 0 ;
30056 char *kwnames[] = {
30057 (char *) "self", NULL
30058 };
30059
30060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30062 if (SWIG_arg_fail(1)) SWIG_fail;
30063 {
30064 PyThreadState* __tstate = wxPyBeginAllowThreads();
30065 result = (arg1)->GetCursor();
30066
30067 wxPyEndAllowThreads(__tstate);
30068 if (PyErr_Occurred()) SWIG_fail;
30069 }
30070 {
30071 wxCursor * resultptr;
30072 resultptr = new wxCursor((wxCursor &)(result));
30073 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30074 }
30075 return resultobj;
30076 fail:
30077 return NULL;
30078 }
30079
30080
30081 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30082 PyObject *resultobj;
30083 wxWindow *arg1 = (wxWindow *) 0 ;
30084 wxFont *arg2 = 0 ;
30085 bool result;
30086 PyObject * obj0 = 0 ;
30087 PyObject * obj1 = 0 ;
30088 char *kwnames[] = {
30089 (char *) "self",(char *) "font", NULL
30090 };
30091
30092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30094 if (SWIG_arg_fail(1)) SWIG_fail;
30095 {
30096 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30097 if (SWIG_arg_fail(2)) SWIG_fail;
30098 if (arg2 == NULL) {
30099 SWIG_null_ref("wxFont");
30100 }
30101 if (SWIG_arg_fail(2)) SWIG_fail;
30102 }
30103 {
30104 PyThreadState* __tstate = wxPyBeginAllowThreads();
30105 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30106
30107 wxPyEndAllowThreads(__tstate);
30108 if (PyErr_Occurred()) SWIG_fail;
30109 }
30110 {
30111 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30112 }
30113 return resultobj;
30114 fail:
30115 return NULL;
30116 }
30117
30118
30119 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30120 PyObject *resultobj;
30121 wxWindow *arg1 = (wxWindow *) 0 ;
30122 wxFont *arg2 = 0 ;
30123 PyObject * obj0 = 0 ;
30124 PyObject * obj1 = 0 ;
30125 char *kwnames[] = {
30126 (char *) "self",(char *) "font", NULL
30127 };
30128
30129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30131 if (SWIG_arg_fail(1)) SWIG_fail;
30132 {
30133 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30134 if (SWIG_arg_fail(2)) SWIG_fail;
30135 if (arg2 == NULL) {
30136 SWIG_null_ref("wxFont");
30137 }
30138 if (SWIG_arg_fail(2)) SWIG_fail;
30139 }
30140 {
30141 PyThreadState* __tstate = wxPyBeginAllowThreads();
30142 (arg1)->SetOwnFont((wxFont const &)*arg2);
30143
30144 wxPyEndAllowThreads(__tstate);
30145 if (PyErr_Occurred()) SWIG_fail;
30146 }
30147 Py_INCREF(Py_None); resultobj = Py_None;
30148 return resultobj;
30149 fail:
30150 return NULL;
30151 }
30152
30153
30154 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30155 PyObject *resultobj;
30156 wxWindow *arg1 = (wxWindow *) 0 ;
30157 wxFont result;
30158 PyObject * obj0 = 0 ;
30159 char *kwnames[] = {
30160 (char *) "self", NULL
30161 };
30162
30163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30165 if (SWIG_arg_fail(1)) SWIG_fail;
30166 {
30167 PyThreadState* __tstate = wxPyBeginAllowThreads();
30168 result = (arg1)->GetFont();
30169
30170 wxPyEndAllowThreads(__tstate);
30171 if (PyErr_Occurred()) SWIG_fail;
30172 }
30173 {
30174 wxFont * resultptr;
30175 resultptr = new wxFont((wxFont &)(result));
30176 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30177 }
30178 return resultobj;
30179 fail:
30180 return NULL;
30181 }
30182
30183
30184 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30185 PyObject *resultobj;
30186 wxWindow *arg1 = (wxWindow *) 0 ;
30187 wxCaret *arg2 = (wxCaret *) 0 ;
30188 PyObject * obj0 = 0 ;
30189 PyObject * obj1 = 0 ;
30190 char *kwnames[] = {
30191 (char *) "self",(char *) "caret", NULL
30192 };
30193
30194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30196 if (SWIG_arg_fail(1)) SWIG_fail;
30197 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30198 if (SWIG_arg_fail(2)) SWIG_fail;
30199 {
30200 PyThreadState* __tstate = wxPyBeginAllowThreads();
30201 (arg1)->SetCaret(arg2);
30202
30203 wxPyEndAllowThreads(__tstate);
30204 if (PyErr_Occurred()) SWIG_fail;
30205 }
30206 Py_INCREF(Py_None); resultobj = Py_None;
30207 return resultobj;
30208 fail:
30209 return NULL;
30210 }
30211
30212
30213 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30214 PyObject *resultobj;
30215 wxWindow *arg1 = (wxWindow *) 0 ;
30216 wxCaret *result;
30217 PyObject * obj0 = 0 ;
30218 char *kwnames[] = {
30219 (char *) "self", NULL
30220 };
30221
30222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30224 if (SWIG_arg_fail(1)) SWIG_fail;
30225 {
30226 PyThreadState* __tstate = wxPyBeginAllowThreads();
30227 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30228
30229 wxPyEndAllowThreads(__tstate);
30230 if (PyErr_Occurred()) SWIG_fail;
30231 }
30232 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30233 return resultobj;
30234 fail:
30235 return NULL;
30236 }
30237
30238
30239 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30240 PyObject *resultobj;
30241 wxWindow *arg1 = (wxWindow *) 0 ;
30242 int result;
30243 PyObject * obj0 = 0 ;
30244 char *kwnames[] = {
30245 (char *) "self", NULL
30246 };
30247
30248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30250 if (SWIG_arg_fail(1)) SWIG_fail;
30251 {
30252 PyThreadState* __tstate = wxPyBeginAllowThreads();
30253 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30254
30255 wxPyEndAllowThreads(__tstate);
30256 if (PyErr_Occurred()) SWIG_fail;
30257 }
30258 {
30259 resultobj = SWIG_From_int((int)(result));
30260 }
30261 return resultobj;
30262 fail:
30263 return NULL;
30264 }
30265
30266
30267 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30268 PyObject *resultobj;
30269 wxWindow *arg1 = (wxWindow *) 0 ;
30270 int result;
30271 PyObject * obj0 = 0 ;
30272 char *kwnames[] = {
30273 (char *) "self", NULL
30274 };
30275
30276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30278 if (SWIG_arg_fail(1)) SWIG_fail;
30279 {
30280 PyThreadState* __tstate = wxPyBeginAllowThreads();
30281 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30282
30283 wxPyEndAllowThreads(__tstate);
30284 if (PyErr_Occurred()) SWIG_fail;
30285 }
30286 {
30287 resultobj = SWIG_From_int((int)(result));
30288 }
30289 return resultobj;
30290 fail:
30291 return NULL;
30292 }
30293
30294
30295 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30296 PyObject *resultobj;
30297 wxWindow *arg1 = (wxWindow *) 0 ;
30298 wxString *arg2 = 0 ;
30299 int *arg3 = (int *) 0 ;
30300 int *arg4 = (int *) 0 ;
30301 bool temp2 = false ;
30302 int temp3 ;
30303 int res3 = 0 ;
30304 int temp4 ;
30305 int res4 = 0 ;
30306 PyObject * obj0 = 0 ;
30307 PyObject * obj1 = 0 ;
30308 char *kwnames[] = {
30309 (char *) "self",(char *) "string", NULL
30310 };
30311
30312 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30313 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30316 if (SWIG_arg_fail(1)) SWIG_fail;
30317 {
30318 arg2 = wxString_in_helper(obj1);
30319 if (arg2 == NULL) SWIG_fail;
30320 temp2 = true;
30321 }
30322 {
30323 PyThreadState* __tstate = wxPyBeginAllowThreads();
30324 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30325
30326 wxPyEndAllowThreads(__tstate);
30327 if (PyErr_Occurred()) SWIG_fail;
30328 }
30329 Py_INCREF(Py_None); resultobj = Py_None;
30330 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30331 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30332 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30333 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30334 {
30335 if (temp2)
30336 delete arg2;
30337 }
30338 return resultobj;
30339 fail:
30340 {
30341 if (temp2)
30342 delete arg2;
30343 }
30344 return NULL;
30345 }
30346
30347
30348 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30349 PyObject *resultobj;
30350 wxWindow *arg1 = (wxWindow *) 0 ;
30351 wxString *arg2 = 0 ;
30352 int *arg3 = (int *) 0 ;
30353 int *arg4 = (int *) 0 ;
30354 int *arg5 = (int *) 0 ;
30355 int *arg6 = (int *) 0 ;
30356 wxFont *arg7 = (wxFont *) NULL ;
30357 bool temp2 = false ;
30358 int temp3 ;
30359 int res3 = 0 ;
30360 int temp4 ;
30361 int res4 = 0 ;
30362 int temp5 ;
30363 int res5 = 0 ;
30364 int temp6 ;
30365 int res6 = 0 ;
30366 PyObject * obj0 = 0 ;
30367 PyObject * obj1 = 0 ;
30368 PyObject * obj2 = 0 ;
30369 char *kwnames[] = {
30370 (char *) "self",(char *) "string",(char *) "font", NULL
30371 };
30372
30373 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30374 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30375 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30376 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30379 if (SWIG_arg_fail(1)) SWIG_fail;
30380 {
30381 arg2 = wxString_in_helper(obj1);
30382 if (arg2 == NULL) SWIG_fail;
30383 temp2 = true;
30384 }
30385 if (obj2) {
30386 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30387 if (SWIG_arg_fail(7)) SWIG_fail;
30388 }
30389 {
30390 PyThreadState* __tstate = wxPyBeginAllowThreads();
30391 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30392
30393 wxPyEndAllowThreads(__tstate);
30394 if (PyErr_Occurred()) SWIG_fail;
30395 }
30396 Py_INCREF(Py_None); resultobj = Py_None;
30397 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30398 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30399 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30400 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30401 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30402 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30403 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30404 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30405 {
30406 if (temp2)
30407 delete arg2;
30408 }
30409 return resultobj;
30410 fail:
30411 {
30412 if (temp2)
30413 delete arg2;
30414 }
30415 return NULL;
30416 }
30417
30418
30419 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30420 PyObject *resultobj;
30421 wxWindow *arg1 = (wxWindow *) 0 ;
30422 int *arg2 = (int *) 0 ;
30423 int *arg3 = (int *) 0 ;
30424 int temp2 ;
30425 int res2 = 0 ;
30426 int temp3 ;
30427 int res3 = 0 ;
30428 PyObject * obj0 = 0 ;
30429 PyObject * obj1 = 0 ;
30430 PyObject * obj2 = 0 ;
30431 char *kwnames[] = {
30432 (char *) "self",(char *) "x",(char *) "y", NULL
30433 };
30434
30435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30437 if (SWIG_arg_fail(1)) SWIG_fail;
30438 {
30439 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30440 temp2 = SWIG_As_int(obj1);
30441 if (SWIG_arg_fail(2)) SWIG_fail;
30442 arg2 = &temp2;
30443 res2 = SWIG_NEWOBJ;
30444 }
30445 }
30446 {
30447 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30448 temp3 = SWIG_As_int(obj2);
30449 if (SWIG_arg_fail(3)) SWIG_fail;
30450 arg3 = &temp3;
30451 res3 = SWIG_NEWOBJ;
30452 }
30453 }
30454 {
30455 PyThreadState* __tstate = wxPyBeginAllowThreads();
30456 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30457
30458 wxPyEndAllowThreads(__tstate);
30459 if (PyErr_Occurred()) SWIG_fail;
30460 }
30461 Py_INCREF(Py_None); resultobj = Py_None;
30462 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30463 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30464 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30465 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30466 return resultobj;
30467 fail:
30468 return NULL;
30469 }
30470
30471
30472 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30473 PyObject *resultobj;
30474 wxWindow *arg1 = (wxWindow *) 0 ;
30475 int *arg2 = (int *) 0 ;
30476 int *arg3 = (int *) 0 ;
30477 int temp2 ;
30478 int res2 = 0 ;
30479 int temp3 ;
30480 int res3 = 0 ;
30481 PyObject * obj0 = 0 ;
30482 PyObject * obj1 = 0 ;
30483 PyObject * obj2 = 0 ;
30484 char *kwnames[] = {
30485 (char *) "self",(char *) "x",(char *) "y", NULL
30486 };
30487
30488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30489 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30490 if (SWIG_arg_fail(1)) SWIG_fail;
30491 {
30492 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30493 temp2 = SWIG_As_int(obj1);
30494 if (SWIG_arg_fail(2)) SWIG_fail;
30495 arg2 = &temp2;
30496 res2 = SWIG_NEWOBJ;
30497 }
30498 }
30499 {
30500 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30501 temp3 = SWIG_As_int(obj2);
30502 if (SWIG_arg_fail(3)) SWIG_fail;
30503 arg3 = &temp3;
30504 res3 = SWIG_NEWOBJ;
30505 }
30506 }
30507 {
30508 PyThreadState* __tstate = wxPyBeginAllowThreads();
30509 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30510
30511 wxPyEndAllowThreads(__tstate);
30512 if (PyErr_Occurred()) SWIG_fail;
30513 }
30514 Py_INCREF(Py_None); resultobj = Py_None;
30515 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30516 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30517 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30518 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30519 return resultobj;
30520 fail:
30521 return NULL;
30522 }
30523
30524
30525 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30526 PyObject *resultobj;
30527 wxWindow *arg1 = (wxWindow *) 0 ;
30528 wxPoint *arg2 = 0 ;
30529 wxPoint result;
30530 wxPoint temp2 ;
30531 PyObject * obj0 = 0 ;
30532 PyObject * obj1 = 0 ;
30533 char *kwnames[] = {
30534 (char *) "self",(char *) "pt", NULL
30535 };
30536
30537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30539 if (SWIG_arg_fail(1)) SWIG_fail;
30540 {
30541 arg2 = &temp2;
30542 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30543 }
30544 {
30545 PyThreadState* __tstate = wxPyBeginAllowThreads();
30546 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30547
30548 wxPyEndAllowThreads(__tstate);
30549 if (PyErr_Occurred()) SWIG_fail;
30550 }
30551 {
30552 wxPoint * resultptr;
30553 resultptr = new wxPoint((wxPoint &)(result));
30554 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30555 }
30556 return resultobj;
30557 fail:
30558 return NULL;
30559 }
30560
30561
30562 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30563 PyObject *resultobj;
30564 wxWindow *arg1 = (wxWindow *) 0 ;
30565 wxPoint *arg2 = 0 ;
30566 wxPoint result;
30567 wxPoint temp2 ;
30568 PyObject * obj0 = 0 ;
30569 PyObject * obj1 = 0 ;
30570 char *kwnames[] = {
30571 (char *) "self",(char *) "pt", NULL
30572 };
30573
30574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
30575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30576 if (SWIG_arg_fail(1)) SWIG_fail;
30577 {
30578 arg2 = &temp2;
30579 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30580 }
30581 {
30582 PyThreadState* __tstate = wxPyBeginAllowThreads();
30583 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30584
30585 wxPyEndAllowThreads(__tstate);
30586 if (PyErr_Occurred()) SWIG_fail;
30587 }
30588 {
30589 wxPoint * resultptr;
30590 resultptr = new wxPoint((wxPoint &)(result));
30591 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30592 }
30593 return resultobj;
30594 fail:
30595 return NULL;
30596 }
30597
30598
30599 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30600 PyObject *resultobj;
30601 wxWindow *arg1 = (wxWindow *) 0 ;
30602 int arg2 ;
30603 int arg3 ;
30604 wxHitTest result;
30605 PyObject * obj0 = 0 ;
30606 PyObject * obj1 = 0 ;
30607 PyObject * obj2 = 0 ;
30608 char *kwnames[] = {
30609 (char *) "self",(char *) "x",(char *) "y", NULL
30610 };
30611
30612 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30613 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30614 if (SWIG_arg_fail(1)) SWIG_fail;
30615 {
30616 arg2 = (int)(SWIG_As_int(obj1));
30617 if (SWIG_arg_fail(2)) SWIG_fail;
30618 }
30619 {
30620 arg3 = (int)(SWIG_As_int(obj2));
30621 if (SWIG_arg_fail(3)) SWIG_fail;
30622 }
30623 {
30624 PyThreadState* __tstate = wxPyBeginAllowThreads();
30625 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30626
30627 wxPyEndAllowThreads(__tstate);
30628 if (PyErr_Occurred()) SWIG_fail;
30629 }
30630 resultobj = SWIG_From_int((result));
30631 return resultobj;
30632 fail:
30633 return NULL;
30634 }
30635
30636
30637 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30638 PyObject *resultobj;
30639 wxWindow *arg1 = (wxWindow *) 0 ;
30640 wxPoint *arg2 = 0 ;
30641 wxHitTest result;
30642 wxPoint temp2 ;
30643 PyObject * obj0 = 0 ;
30644 PyObject * obj1 = 0 ;
30645 char *kwnames[] = {
30646 (char *) "self",(char *) "pt", NULL
30647 };
30648
30649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30651 if (SWIG_arg_fail(1)) SWIG_fail;
30652 {
30653 arg2 = &temp2;
30654 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30655 }
30656 {
30657 PyThreadState* __tstate = wxPyBeginAllowThreads();
30658 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30659
30660 wxPyEndAllowThreads(__tstate);
30661 if (PyErr_Occurred()) SWIG_fail;
30662 }
30663 resultobj = SWIG_From_int((result));
30664 return resultobj;
30665 fail:
30666 return NULL;
30667 }
30668
30669
30670 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30671 PyObject *resultobj;
30672 wxWindow *arg1 = (wxWindow *) 0 ;
30673 long arg2 ;
30674 wxBorder result;
30675 PyObject * obj0 = 0 ;
30676 PyObject * obj1 = 0 ;
30677
30678 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30680 if (SWIG_arg_fail(1)) SWIG_fail;
30681 {
30682 arg2 = (long)(SWIG_As_long(obj1));
30683 if (SWIG_arg_fail(2)) SWIG_fail;
30684 }
30685 {
30686 PyThreadState* __tstate = wxPyBeginAllowThreads();
30687 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30688
30689 wxPyEndAllowThreads(__tstate);
30690 if (PyErr_Occurred()) SWIG_fail;
30691 }
30692 resultobj = SWIG_From_int((result));
30693 return resultobj;
30694 fail:
30695 return NULL;
30696 }
30697
30698
30699 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30700 PyObject *resultobj;
30701 wxWindow *arg1 = (wxWindow *) 0 ;
30702 wxBorder result;
30703 PyObject * obj0 = 0 ;
30704
30705 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30707 if (SWIG_arg_fail(1)) SWIG_fail;
30708 {
30709 PyThreadState* __tstate = wxPyBeginAllowThreads();
30710 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30711
30712 wxPyEndAllowThreads(__tstate);
30713 if (PyErr_Occurred()) SWIG_fail;
30714 }
30715 resultobj = SWIG_From_int((result));
30716 return resultobj;
30717 fail:
30718 return NULL;
30719 }
30720
30721
30722 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30723 int argc;
30724 PyObject *argv[3];
30725 int ii;
30726
30727 argc = PyObject_Length(args);
30728 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30729 argv[ii] = PyTuple_GetItem(args,ii);
30730 }
30731 if (argc == 1) {
30732 int _v;
30733 {
30734 void *ptr;
30735 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30736 _v = 0;
30737 PyErr_Clear();
30738 } else {
30739 _v = 1;
30740 }
30741 }
30742 if (_v) {
30743 return _wrap_Window_GetBorder__SWIG_1(self,args);
30744 }
30745 }
30746 if (argc == 2) {
30747 int _v;
30748 {
30749 void *ptr;
30750 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30751 _v = 0;
30752 PyErr_Clear();
30753 } else {
30754 _v = 1;
30755 }
30756 }
30757 if (_v) {
30758 _v = SWIG_Check_long(argv[1]);
30759 if (_v) {
30760 return _wrap_Window_GetBorder__SWIG_0(self,args);
30761 }
30762 }
30763 }
30764
30765 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30766 return NULL;
30767 }
30768
30769
30770 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30771 PyObject *resultobj;
30772 wxWindow *arg1 = (wxWindow *) 0 ;
30773 long arg2 = (long) wxUPDATE_UI_NONE ;
30774 PyObject * obj0 = 0 ;
30775 PyObject * obj1 = 0 ;
30776 char *kwnames[] = {
30777 (char *) "self",(char *) "flags", NULL
30778 };
30779
30780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30782 if (SWIG_arg_fail(1)) SWIG_fail;
30783 if (obj1) {
30784 {
30785 arg2 = (long)(SWIG_As_long(obj1));
30786 if (SWIG_arg_fail(2)) SWIG_fail;
30787 }
30788 }
30789 {
30790 PyThreadState* __tstate = wxPyBeginAllowThreads();
30791 (arg1)->UpdateWindowUI(arg2);
30792
30793 wxPyEndAllowThreads(__tstate);
30794 if (PyErr_Occurred()) SWIG_fail;
30795 }
30796 Py_INCREF(Py_None); resultobj = Py_None;
30797 return resultobj;
30798 fail:
30799 return NULL;
30800 }
30801
30802
30803 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30804 PyObject *resultobj;
30805 wxWindow *arg1 = (wxWindow *) 0 ;
30806 wxMenu *arg2 = (wxMenu *) 0 ;
30807 int arg3 = (int) -1 ;
30808 int arg4 = (int) -1 ;
30809 bool result;
30810 PyObject * obj0 = 0 ;
30811 PyObject * obj1 = 0 ;
30812 PyObject * obj2 = 0 ;
30813 PyObject * obj3 = 0 ;
30814 char *kwnames[] = {
30815 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30816 };
30817
30818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30820 if (SWIG_arg_fail(1)) SWIG_fail;
30821 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30822 if (SWIG_arg_fail(2)) SWIG_fail;
30823 if (obj2) {
30824 {
30825 arg3 = (int)(SWIG_As_int(obj2));
30826 if (SWIG_arg_fail(3)) SWIG_fail;
30827 }
30828 }
30829 if (obj3) {
30830 {
30831 arg4 = (int)(SWIG_As_int(obj3));
30832 if (SWIG_arg_fail(4)) SWIG_fail;
30833 }
30834 }
30835 {
30836 PyThreadState* __tstate = wxPyBeginAllowThreads();
30837 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30838
30839 wxPyEndAllowThreads(__tstate);
30840 if (PyErr_Occurred()) SWIG_fail;
30841 }
30842 {
30843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30844 }
30845 return resultobj;
30846 fail:
30847 return NULL;
30848 }
30849
30850
30851 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30852 PyObject *resultobj;
30853 wxWindow *arg1 = (wxWindow *) 0 ;
30854 wxMenu *arg2 = (wxMenu *) 0 ;
30855 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30856 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30857 bool result;
30858 wxPoint temp3 ;
30859 PyObject * obj0 = 0 ;
30860 PyObject * obj1 = 0 ;
30861 PyObject * obj2 = 0 ;
30862 char *kwnames[] = {
30863 (char *) "self",(char *) "menu",(char *) "pos", NULL
30864 };
30865
30866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30870 if (SWIG_arg_fail(2)) SWIG_fail;
30871 if (obj2) {
30872 {
30873 arg3 = &temp3;
30874 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30875 }
30876 }
30877 {
30878 PyThreadState* __tstate = wxPyBeginAllowThreads();
30879 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30880
30881 wxPyEndAllowThreads(__tstate);
30882 if (PyErr_Occurred()) SWIG_fail;
30883 }
30884 {
30885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30886 }
30887 return resultobj;
30888 fail:
30889 return NULL;
30890 }
30891
30892
30893 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30894 PyObject *resultobj;
30895 wxWindow *arg1 = (wxWindow *) 0 ;
30896 long result;
30897 PyObject * obj0 = 0 ;
30898 char *kwnames[] = {
30899 (char *) "self", NULL
30900 };
30901
30902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30904 if (SWIG_arg_fail(1)) SWIG_fail;
30905 {
30906 PyThreadState* __tstate = wxPyBeginAllowThreads();
30907 result = (long)wxWindow_GetHandle(arg1);
30908
30909 wxPyEndAllowThreads(__tstate);
30910 if (PyErr_Occurred()) SWIG_fail;
30911 }
30912 {
30913 resultobj = SWIG_From_long((long)(result));
30914 }
30915 return resultobj;
30916 fail:
30917 return NULL;
30918 }
30919
30920
30921 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30922 PyObject *resultobj;
30923 wxWindow *arg1 = (wxWindow *) 0 ;
30924 long arg2 ;
30925 PyObject * obj0 = 0 ;
30926 PyObject * obj1 = 0 ;
30927 char *kwnames[] = {
30928 (char *) "self",(char *) "handle", NULL
30929 };
30930
30931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30933 if (SWIG_arg_fail(1)) SWIG_fail;
30934 {
30935 arg2 = (long)(SWIG_As_long(obj1));
30936 if (SWIG_arg_fail(2)) SWIG_fail;
30937 }
30938 {
30939 PyThreadState* __tstate = wxPyBeginAllowThreads();
30940 wxWindow_AssociateHandle(arg1,arg2);
30941
30942 wxPyEndAllowThreads(__tstate);
30943 if (PyErr_Occurred()) SWIG_fail;
30944 }
30945 Py_INCREF(Py_None); resultobj = Py_None;
30946 return resultobj;
30947 fail:
30948 return NULL;
30949 }
30950
30951
30952 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30953 PyObject *resultobj;
30954 wxWindow *arg1 = (wxWindow *) 0 ;
30955 PyObject * obj0 = 0 ;
30956 char *kwnames[] = {
30957 (char *) "self", NULL
30958 };
30959
30960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30962 if (SWIG_arg_fail(1)) SWIG_fail;
30963 {
30964 PyThreadState* __tstate = wxPyBeginAllowThreads();
30965 (arg1)->DissociateHandle();
30966
30967 wxPyEndAllowThreads(__tstate);
30968 if (PyErr_Occurred()) SWIG_fail;
30969 }
30970 Py_INCREF(Py_None); resultobj = Py_None;
30971 return resultobj;
30972 fail:
30973 return NULL;
30974 }
30975
30976
30977 static PyObject *_wrap_Window_OnPaint(PyObject *, PyObject *args, PyObject *kwargs) {
30978 PyObject *resultobj;
30979 wxWindow *arg1 = (wxWindow *) 0 ;
30980 wxPaintEvent *arg2 = 0 ;
30981 PyObject * obj0 = 0 ;
30982 PyObject * obj1 = 0 ;
30983 char *kwnames[] = {
30984 (char *) "self",(char *) "event", NULL
30985 };
30986
30987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) goto fail;
30988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30989 if (SWIG_arg_fail(1)) SWIG_fail;
30990 {
30991 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_EXCEPTION | 0);
30992 if (SWIG_arg_fail(2)) SWIG_fail;
30993 if (arg2 == NULL) {
30994 SWIG_null_ref("wxPaintEvent");
30995 }
30996 if (SWIG_arg_fail(2)) SWIG_fail;
30997 }
30998 {
30999 PyThreadState* __tstate = wxPyBeginAllowThreads();
31000 (arg1)->OnPaint(*arg2);
31001
31002 wxPyEndAllowThreads(__tstate);
31003 if (PyErr_Occurred()) SWIG_fail;
31004 }
31005 Py_INCREF(Py_None); resultobj = Py_None;
31006 return resultobj;
31007 fail:
31008 return NULL;
31009 }
31010
31011
31012 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31013 PyObject *resultobj;
31014 wxWindow *arg1 = (wxWindow *) 0 ;
31015 int arg2 ;
31016 bool result;
31017 PyObject * obj0 = 0 ;
31018 PyObject * obj1 = 0 ;
31019 char *kwnames[] = {
31020 (char *) "self",(char *) "orient", NULL
31021 };
31022
31023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31025 if (SWIG_arg_fail(1)) SWIG_fail;
31026 {
31027 arg2 = (int)(SWIG_As_int(obj1));
31028 if (SWIG_arg_fail(2)) SWIG_fail;
31029 }
31030 {
31031 PyThreadState* __tstate = wxPyBeginAllowThreads();
31032 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31033
31034 wxPyEndAllowThreads(__tstate);
31035 if (PyErr_Occurred()) SWIG_fail;
31036 }
31037 {
31038 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31039 }
31040 return resultobj;
31041 fail:
31042 return NULL;
31043 }
31044
31045
31046 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31047 PyObject *resultobj;
31048 wxWindow *arg1 = (wxWindow *) 0 ;
31049 int arg2 ;
31050 int arg3 ;
31051 int arg4 ;
31052 int arg5 ;
31053 bool arg6 = (bool) true ;
31054 PyObject * obj0 = 0 ;
31055 PyObject * obj1 = 0 ;
31056 PyObject * obj2 = 0 ;
31057 PyObject * obj3 = 0 ;
31058 PyObject * obj4 = 0 ;
31059 PyObject * obj5 = 0 ;
31060 char *kwnames[] = {
31061 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31062 };
31063
31064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31066 if (SWIG_arg_fail(1)) SWIG_fail;
31067 {
31068 arg2 = (int)(SWIG_As_int(obj1));
31069 if (SWIG_arg_fail(2)) SWIG_fail;
31070 }
31071 {
31072 arg3 = (int)(SWIG_As_int(obj2));
31073 if (SWIG_arg_fail(3)) SWIG_fail;
31074 }
31075 {
31076 arg4 = (int)(SWIG_As_int(obj3));
31077 if (SWIG_arg_fail(4)) SWIG_fail;
31078 }
31079 {
31080 arg5 = (int)(SWIG_As_int(obj4));
31081 if (SWIG_arg_fail(5)) SWIG_fail;
31082 }
31083 if (obj5) {
31084 {
31085 arg6 = (bool)(SWIG_As_bool(obj5));
31086 if (SWIG_arg_fail(6)) SWIG_fail;
31087 }
31088 }
31089 {
31090 PyThreadState* __tstate = wxPyBeginAllowThreads();
31091 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31092
31093 wxPyEndAllowThreads(__tstate);
31094 if (PyErr_Occurred()) SWIG_fail;
31095 }
31096 Py_INCREF(Py_None); resultobj = Py_None;
31097 return resultobj;
31098 fail:
31099 return NULL;
31100 }
31101
31102
31103 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31104 PyObject *resultobj;
31105 wxWindow *arg1 = (wxWindow *) 0 ;
31106 int arg2 ;
31107 int arg3 ;
31108 bool arg4 = (bool) true ;
31109 PyObject * obj0 = 0 ;
31110 PyObject * obj1 = 0 ;
31111 PyObject * obj2 = 0 ;
31112 PyObject * obj3 = 0 ;
31113 char *kwnames[] = {
31114 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31115 };
31116
31117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31119 if (SWIG_arg_fail(1)) SWIG_fail;
31120 {
31121 arg2 = (int)(SWIG_As_int(obj1));
31122 if (SWIG_arg_fail(2)) SWIG_fail;
31123 }
31124 {
31125 arg3 = (int)(SWIG_As_int(obj2));
31126 if (SWIG_arg_fail(3)) SWIG_fail;
31127 }
31128 if (obj3) {
31129 {
31130 arg4 = (bool)(SWIG_As_bool(obj3));
31131 if (SWIG_arg_fail(4)) SWIG_fail;
31132 }
31133 }
31134 {
31135 PyThreadState* __tstate = wxPyBeginAllowThreads();
31136 (arg1)->SetScrollPos(arg2,arg3,arg4);
31137
31138 wxPyEndAllowThreads(__tstate);
31139 if (PyErr_Occurred()) SWIG_fail;
31140 }
31141 Py_INCREF(Py_None); resultobj = Py_None;
31142 return resultobj;
31143 fail:
31144 return NULL;
31145 }
31146
31147
31148 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31149 PyObject *resultobj;
31150 wxWindow *arg1 = (wxWindow *) 0 ;
31151 int arg2 ;
31152 int result;
31153 PyObject * obj0 = 0 ;
31154 PyObject * obj1 = 0 ;
31155 char *kwnames[] = {
31156 (char *) "self",(char *) "orientation", NULL
31157 };
31158
31159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31161 if (SWIG_arg_fail(1)) SWIG_fail;
31162 {
31163 arg2 = (int)(SWIG_As_int(obj1));
31164 if (SWIG_arg_fail(2)) SWIG_fail;
31165 }
31166 {
31167 PyThreadState* __tstate = wxPyBeginAllowThreads();
31168 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31169
31170 wxPyEndAllowThreads(__tstate);
31171 if (PyErr_Occurred()) SWIG_fail;
31172 }
31173 {
31174 resultobj = SWIG_From_int((int)(result));
31175 }
31176 return resultobj;
31177 fail:
31178 return NULL;
31179 }
31180
31181
31182 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31183 PyObject *resultobj;
31184 wxWindow *arg1 = (wxWindow *) 0 ;
31185 int arg2 ;
31186 int result;
31187 PyObject * obj0 = 0 ;
31188 PyObject * obj1 = 0 ;
31189 char *kwnames[] = {
31190 (char *) "self",(char *) "orientation", NULL
31191 };
31192
31193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31195 if (SWIG_arg_fail(1)) SWIG_fail;
31196 {
31197 arg2 = (int)(SWIG_As_int(obj1));
31198 if (SWIG_arg_fail(2)) SWIG_fail;
31199 }
31200 {
31201 PyThreadState* __tstate = wxPyBeginAllowThreads();
31202 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31203
31204 wxPyEndAllowThreads(__tstate);
31205 if (PyErr_Occurred()) SWIG_fail;
31206 }
31207 {
31208 resultobj = SWIG_From_int((int)(result));
31209 }
31210 return resultobj;
31211 fail:
31212 return NULL;
31213 }
31214
31215
31216 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31217 PyObject *resultobj;
31218 wxWindow *arg1 = (wxWindow *) 0 ;
31219 int arg2 ;
31220 int result;
31221 PyObject * obj0 = 0 ;
31222 PyObject * obj1 = 0 ;
31223 char *kwnames[] = {
31224 (char *) "self",(char *) "orientation", NULL
31225 };
31226
31227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31229 if (SWIG_arg_fail(1)) SWIG_fail;
31230 {
31231 arg2 = (int)(SWIG_As_int(obj1));
31232 if (SWIG_arg_fail(2)) SWIG_fail;
31233 }
31234 {
31235 PyThreadState* __tstate = wxPyBeginAllowThreads();
31236 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31237
31238 wxPyEndAllowThreads(__tstate);
31239 if (PyErr_Occurred()) SWIG_fail;
31240 }
31241 {
31242 resultobj = SWIG_From_int((int)(result));
31243 }
31244 return resultobj;
31245 fail:
31246 return NULL;
31247 }
31248
31249
31250 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31251 PyObject *resultobj;
31252 wxWindow *arg1 = (wxWindow *) 0 ;
31253 int arg2 ;
31254 int arg3 ;
31255 wxRect *arg4 = (wxRect *) NULL ;
31256 PyObject * obj0 = 0 ;
31257 PyObject * obj1 = 0 ;
31258 PyObject * obj2 = 0 ;
31259 PyObject * obj3 = 0 ;
31260 char *kwnames[] = {
31261 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31262 };
31263
31264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31266 if (SWIG_arg_fail(1)) SWIG_fail;
31267 {
31268 arg2 = (int)(SWIG_As_int(obj1));
31269 if (SWIG_arg_fail(2)) SWIG_fail;
31270 }
31271 {
31272 arg3 = (int)(SWIG_As_int(obj2));
31273 if (SWIG_arg_fail(3)) SWIG_fail;
31274 }
31275 if (obj3) {
31276 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31277 if (SWIG_arg_fail(4)) SWIG_fail;
31278 }
31279 {
31280 PyThreadState* __tstate = wxPyBeginAllowThreads();
31281 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31282
31283 wxPyEndAllowThreads(__tstate);
31284 if (PyErr_Occurred()) SWIG_fail;
31285 }
31286 Py_INCREF(Py_None); resultobj = Py_None;
31287 return resultobj;
31288 fail:
31289 return NULL;
31290 }
31291
31292
31293 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31294 PyObject *resultobj;
31295 wxWindow *arg1 = (wxWindow *) 0 ;
31296 int arg2 ;
31297 bool result;
31298 PyObject * obj0 = 0 ;
31299 PyObject * obj1 = 0 ;
31300 char *kwnames[] = {
31301 (char *) "self",(char *) "lines", NULL
31302 };
31303
31304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31306 if (SWIG_arg_fail(1)) SWIG_fail;
31307 {
31308 arg2 = (int)(SWIG_As_int(obj1));
31309 if (SWIG_arg_fail(2)) SWIG_fail;
31310 }
31311 {
31312 PyThreadState* __tstate = wxPyBeginAllowThreads();
31313 result = (bool)(arg1)->ScrollLines(arg2);
31314
31315 wxPyEndAllowThreads(__tstate);
31316 if (PyErr_Occurred()) SWIG_fail;
31317 }
31318 {
31319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31320 }
31321 return resultobj;
31322 fail:
31323 return NULL;
31324 }
31325
31326
31327 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31328 PyObject *resultobj;
31329 wxWindow *arg1 = (wxWindow *) 0 ;
31330 int arg2 ;
31331 bool result;
31332 PyObject * obj0 = 0 ;
31333 PyObject * obj1 = 0 ;
31334 char *kwnames[] = {
31335 (char *) "self",(char *) "pages", NULL
31336 };
31337
31338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31340 if (SWIG_arg_fail(1)) SWIG_fail;
31341 {
31342 arg2 = (int)(SWIG_As_int(obj1));
31343 if (SWIG_arg_fail(2)) SWIG_fail;
31344 }
31345 {
31346 PyThreadState* __tstate = wxPyBeginAllowThreads();
31347 result = (bool)(arg1)->ScrollPages(arg2);
31348
31349 wxPyEndAllowThreads(__tstate);
31350 if (PyErr_Occurred()) SWIG_fail;
31351 }
31352 {
31353 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31354 }
31355 return resultobj;
31356 fail:
31357 return NULL;
31358 }
31359
31360
31361 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31362 PyObject *resultobj;
31363 wxWindow *arg1 = (wxWindow *) 0 ;
31364 bool result;
31365 PyObject * obj0 = 0 ;
31366 char *kwnames[] = {
31367 (char *) "self", NULL
31368 };
31369
31370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31372 if (SWIG_arg_fail(1)) SWIG_fail;
31373 {
31374 PyThreadState* __tstate = wxPyBeginAllowThreads();
31375 result = (bool)(arg1)->LineUp();
31376
31377 wxPyEndAllowThreads(__tstate);
31378 if (PyErr_Occurred()) SWIG_fail;
31379 }
31380 {
31381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31382 }
31383 return resultobj;
31384 fail:
31385 return NULL;
31386 }
31387
31388
31389 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31390 PyObject *resultobj;
31391 wxWindow *arg1 = (wxWindow *) 0 ;
31392 bool result;
31393 PyObject * obj0 = 0 ;
31394 char *kwnames[] = {
31395 (char *) "self", NULL
31396 };
31397
31398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31400 if (SWIG_arg_fail(1)) SWIG_fail;
31401 {
31402 PyThreadState* __tstate = wxPyBeginAllowThreads();
31403 result = (bool)(arg1)->LineDown();
31404
31405 wxPyEndAllowThreads(__tstate);
31406 if (PyErr_Occurred()) SWIG_fail;
31407 }
31408 {
31409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31410 }
31411 return resultobj;
31412 fail:
31413 return NULL;
31414 }
31415
31416
31417 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31418 PyObject *resultobj;
31419 wxWindow *arg1 = (wxWindow *) 0 ;
31420 bool result;
31421 PyObject * obj0 = 0 ;
31422 char *kwnames[] = {
31423 (char *) "self", NULL
31424 };
31425
31426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31428 if (SWIG_arg_fail(1)) SWIG_fail;
31429 {
31430 PyThreadState* __tstate = wxPyBeginAllowThreads();
31431 result = (bool)(arg1)->PageUp();
31432
31433 wxPyEndAllowThreads(__tstate);
31434 if (PyErr_Occurred()) SWIG_fail;
31435 }
31436 {
31437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31438 }
31439 return resultobj;
31440 fail:
31441 return NULL;
31442 }
31443
31444
31445 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31446 PyObject *resultobj;
31447 wxWindow *arg1 = (wxWindow *) 0 ;
31448 bool result;
31449 PyObject * obj0 = 0 ;
31450 char *kwnames[] = {
31451 (char *) "self", NULL
31452 };
31453
31454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31456 if (SWIG_arg_fail(1)) SWIG_fail;
31457 {
31458 PyThreadState* __tstate = wxPyBeginAllowThreads();
31459 result = (bool)(arg1)->PageDown();
31460
31461 wxPyEndAllowThreads(__tstate);
31462 if (PyErr_Occurred()) SWIG_fail;
31463 }
31464 {
31465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31466 }
31467 return resultobj;
31468 fail:
31469 return NULL;
31470 }
31471
31472
31473 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31474 PyObject *resultobj;
31475 wxWindow *arg1 = (wxWindow *) 0 ;
31476 wxString *arg2 = 0 ;
31477 bool temp2 = false ;
31478 PyObject * obj0 = 0 ;
31479 PyObject * obj1 = 0 ;
31480 char *kwnames[] = {
31481 (char *) "self",(char *) "text", NULL
31482 };
31483
31484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31486 if (SWIG_arg_fail(1)) SWIG_fail;
31487 {
31488 arg2 = wxString_in_helper(obj1);
31489 if (arg2 == NULL) SWIG_fail;
31490 temp2 = true;
31491 }
31492 {
31493 PyThreadState* __tstate = wxPyBeginAllowThreads();
31494 (arg1)->SetHelpText((wxString const &)*arg2);
31495
31496 wxPyEndAllowThreads(__tstate);
31497 if (PyErr_Occurred()) SWIG_fail;
31498 }
31499 Py_INCREF(Py_None); resultobj = Py_None;
31500 {
31501 if (temp2)
31502 delete arg2;
31503 }
31504 return resultobj;
31505 fail:
31506 {
31507 if (temp2)
31508 delete arg2;
31509 }
31510 return NULL;
31511 }
31512
31513
31514 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31515 PyObject *resultobj;
31516 wxWindow *arg1 = (wxWindow *) 0 ;
31517 wxString *arg2 = 0 ;
31518 bool temp2 = false ;
31519 PyObject * obj0 = 0 ;
31520 PyObject * obj1 = 0 ;
31521 char *kwnames[] = {
31522 (char *) "self",(char *) "text", NULL
31523 };
31524
31525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31527 if (SWIG_arg_fail(1)) SWIG_fail;
31528 {
31529 arg2 = wxString_in_helper(obj1);
31530 if (arg2 == NULL) SWIG_fail;
31531 temp2 = true;
31532 }
31533 {
31534 PyThreadState* __tstate = wxPyBeginAllowThreads();
31535 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31536
31537 wxPyEndAllowThreads(__tstate);
31538 if (PyErr_Occurred()) SWIG_fail;
31539 }
31540 Py_INCREF(Py_None); resultobj = Py_None;
31541 {
31542 if (temp2)
31543 delete arg2;
31544 }
31545 return resultobj;
31546 fail:
31547 {
31548 if (temp2)
31549 delete arg2;
31550 }
31551 return NULL;
31552 }
31553
31554
31555 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31556 PyObject *resultobj;
31557 wxWindow *arg1 = (wxWindow *) 0 ;
31558 wxString result;
31559 PyObject * obj0 = 0 ;
31560 char *kwnames[] = {
31561 (char *) "self", NULL
31562 };
31563
31564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31566 if (SWIG_arg_fail(1)) SWIG_fail;
31567 {
31568 PyThreadState* __tstate = wxPyBeginAllowThreads();
31569 result = ((wxWindow const *)arg1)->GetHelpText();
31570
31571 wxPyEndAllowThreads(__tstate);
31572 if (PyErr_Occurred()) SWIG_fail;
31573 }
31574 {
31575 #if wxUSE_UNICODE
31576 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31577 #else
31578 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31579 #endif
31580 }
31581 return resultobj;
31582 fail:
31583 return NULL;
31584 }
31585
31586
31587 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31588 PyObject *resultobj;
31589 wxWindow *arg1 = (wxWindow *) 0 ;
31590 wxString *arg2 = 0 ;
31591 bool temp2 = false ;
31592 PyObject * obj0 = 0 ;
31593 PyObject * obj1 = 0 ;
31594 char *kwnames[] = {
31595 (char *) "self",(char *) "tip", NULL
31596 };
31597
31598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31600 if (SWIG_arg_fail(1)) SWIG_fail;
31601 {
31602 arg2 = wxString_in_helper(obj1);
31603 if (arg2 == NULL) SWIG_fail;
31604 temp2 = true;
31605 }
31606 {
31607 PyThreadState* __tstate = wxPyBeginAllowThreads();
31608 (arg1)->SetToolTip((wxString const &)*arg2);
31609
31610 wxPyEndAllowThreads(__tstate);
31611 if (PyErr_Occurred()) SWIG_fail;
31612 }
31613 Py_INCREF(Py_None); resultobj = Py_None;
31614 {
31615 if (temp2)
31616 delete arg2;
31617 }
31618 return resultobj;
31619 fail:
31620 {
31621 if (temp2)
31622 delete arg2;
31623 }
31624 return NULL;
31625 }
31626
31627
31628 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31629 PyObject *resultobj;
31630 wxWindow *arg1 = (wxWindow *) 0 ;
31631 wxToolTip *arg2 = (wxToolTip *) 0 ;
31632 PyObject * obj0 = 0 ;
31633 PyObject * obj1 = 0 ;
31634 char *kwnames[] = {
31635 (char *) "self",(char *) "tip", NULL
31636 };
31637
31638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31640 if (SWIG_arg_fail(1)) SWIG_fail;
31641 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31642 if (SWIG_arg_fail(2)) SWIG_fail;
31643 {
31644 PyThreadState* __tstate = wxPyBeginAllowThreads();
31645 (arg1)->SetToolTip(arg2);
31646
31647 wxPyEndAllowThreads(__tstate);
31648 if (PyErr_Occurred()) SWIG_fail;
31649 }
31650 Py_INCREF(Py_None); resultobj = Py_None;
31651 return resultobj;
31652 fail:
31653 return NULL;
31654 }
31655
31656
31657 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31658 PyObject *resultobj;
31659 wxWindow *arg1 = (wxWindow *) 0 ;
31660 wxToolTip *result;
31661 PyObject * obj0 = 0 ;
31662 char *kwnames[] = {
31663 (char *) "self", NULL
31664 };
31665
31666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31668 if (SWIG_arg_fail(1)) SWIG_fail;
31669 {
31670 PyThreadState* __tstate = wxPyBeginAllowThreads();
31671 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31672
31673 wxPyEndAllowThreads(__tstate);
31674 if (PyErr_Occurred()) SWIG_fail;
31675 }
31676 {
31677 resultobj = wxPyMake_wxObject(result, 0);
31678 }
31679 return resultobj;
31680 fail:
31681 return NULL;
31682 }
31683
31684
31685 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31686 PyObject *resultobj;
31687 wxWindow *arg1 = (wxWindow *) 0 ;
31688 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31689 PyObject * obj0 = 0 ;
31690 PyObject * obj1 = 0 ;
31691 char *kwnames[] = {
31692 (char *) "self",(char *) "dropTarget", NULL
31693 };
31694
31695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31697 if (SWIG_arg_fail(1)) SWIG_fail;
31698 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31699 if (SWIG_arg_fail(2)) SWIG_fail;
31700 {
31701 PyThreadState* __tstate = wxPyBeginAllowThreads();
31702 (arg1)->SetDropTarget(arg2);
31703
31704 wxPyEndAllowThreads(__tstate);
31705 if (PyErr_Occurred()) SWIG_fail;
31706 }
31707 Py_INCREF(Py_None); resultobj = Py_None;
31708 return resultobj;
31709 fail:
31710 return NULL;
31711 }
31712
31713
31714 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31715 PyObject *resultobj;
31716 wxWindow *arg1 = (wxWindow *) 0 ;
31717 wxPyDropTarget *result;
31718 PyObject * obj0 = 0 ;
31719 char *kwnames[] = {
31720 (char *) "self", NULL
31721 };
31722
31723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31725 if (SWIG_arg_fail(1)) SWIG_fail;
31726 {
31727 PyThreadState* __tstate = wxPyBeginAllowThreads();
31728 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31729
31730 wxPyEndAllowThreads(__tstate);
31731 if (PyErr_Occurred()) SWIG_fail;
31732 }
31733 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31734 return resultobj;
31735 fail:
31736 return NULL;
31737 }
31738
31739
31740 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
31741 PyObject *resultobj;
31742 wxWindow *arg1 = (wxWindow *) 0 ;
31743 bool arg2 ;
31744 PyObject * obj0 = 0 ;
31745 PyObject * obj1 = 0 ;
31746 char *kwnames[] = {
31747 (char *) "self",(char *) "accept", NULL
31748 };
31749
31750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
31751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31752 if (SWIG_arg_fail(1)) SWIG_fail;
31753 {
31754 arg2 = (bool)(SWIG_As_bool(obj1));
31755 if (SWIG_arg_fail(2)) SWIG_fail;
31756 }
31757 {
31758 PyThreadState* __tstate = wxPyBeginAllowThreads();
31759 (arg1)->DragAcceptFiles(arg2);
31760
31761 wxPyEndAllowThreads(__tstate);
31762 if (PyErr_Occurred()) SWIG_fail;
31763 }
31764 Py_INCREF(Py_None); resultobj = Py_None;
31765 return resultobj;
31766 fail:
31767 return NULL;
31768 }
31769
31770
31771 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31772 PyObject *resultobj;
31773 wxWindow *arg1 = (wxWindow *) 0 ;
31774 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31775 PyObject * obj0 = 0 ;
31776 PyObject * obj1 = 0 ;
31777 char *kwnames[] = {
31778 (char *) "self",(char *) "constraints", NULL
31779 };
31780
31781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31783 if (SWIG_arg_fail(1)) SWIG_fail;
31784 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31785 if (SWIG_arg_fail(2)) SWIG_fail;
31786 {
31787 PyThreadState* __tstate = wxPyBeginAllowThreads();
31788 (arg1)->SetConstraints(arg2);
31789
31790 wxPyEndAllowThreads(__tstate);
31791 if (PyErr_Occurred()) SWIG_fail;
31792 }
31793 Py_INCREF(Py_None); resultobj = Py_None;
31794 return resultobj;
31795 fail:
31796 return NULL;
31797 }
31798
31799
31800 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31801 PyObject *resultobj;
31802 wxWindow *arg1 = (wxWindow *) 0 ;
31803 wxLayoutConstraints *result;
31804 PyObject * obj0 = 0 ;
31805 char *kwnames[] = {
31806 (char *) "self", NULL
31807 };
31808
31809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31811 if (SWIG_arg_fail(1)) SWIG_fail;
31812 {
31813 PyThreadState* __tstate = wxPyBeginAllowThreads();
31814 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31815
31816 wxPyEndAllowThreads(__tstate);
31817 if (PyErr_Occurred()) SWIG_fail;
31818 }
31819 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31820 return resultobj;
31821 fail:
31822 return NULL;
31823 }
31824
31825
31826 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31827 PyObject *resultobj;
31828 wxWindow *arg1 = (wxWindow *) 0 ;
31829 bool arg2 ;
31830 PyObject * obj0 = 0 ;
31831 PyObject * obj1 = 0 ;
31832 char *kwnames[] = {
31833 (char *) "self",(char *) "autoLayout", NULL
31834 };
31835
31836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31838 if (SWIG_arg_fail(1)) SWIG_fail;
31839 {
31840 arg2 = (bool)(SWIG_As_bool(obj1));
31841 if (SWIG_arg_fail(2)) SWIG_fail;
31842 }
31843 {
31844 PyThreadState* __tstate = wxPyBeginAllowThreads();
31845 (arg1)->SetAutoLayout(arg2);
31846
31847 wxPyEndAllowThreads(__tstate);
31848 if (PyErr_Occurred()) SWIG_fail;
31849 }
31850 Py_INCREF(Py_None); resultobj = Py_None;
31851 return resultobj;
31852 fail:
31853 return NULL;
31854 }
31855
31856
31857 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31858 PyObject *resultobj;
31859 wxWindow *arg1 = (wxWindow *) 0 ;
31860 bool result;
31861 PyObject * obj0 = 0 ;
31862 char *kwnames[] = {
31863 (char *) "self", NULL
31864 };
31865
31866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31868 if (SWIG_arg_fail(1)) SWIG_fail;
31869 {
31870 PyThreadState* __tstate = wxPyBeginAllowThreads();
31871 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31872
31873 wxPyEndAllowThreads(__tstate);
31874 if (PyErr_Occurred()) SWIG_fail;
31875 }
31876 {
31877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31878 }
31879 return resultobj;
31880 fail:
31881 return NULL;
31882 }
31883
31884
31885 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31886 PyObject *resultobj;
31887 wxWindow *arg1 = (wxWindow *) 0 ;
31888 bool result;
31889 PyObject * obj0 = 0 ;
31890 char *kwnames[] = {
31891 (char *) "self", NULL
31892 };
31893
31894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31896 if (SWIG_arg_fail(1)) SWIG_fail;
31897 {
31898 PyThreadState* __tstate = wxPyBeginAllowThreads();
31899 result = (bool)(arg1)->Layout();
31900
31901 wxPyEndAllowThreads(__tstate);
31902 if (PyErr_Occurred()) SWIG_fail;
31903 }
31904 {
31905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31906 }
31907 return resultobj;
31908 fail:
31909 return NULL;
31910 }
31911
31912
31913 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31914 PyObject *resultobj;
31915 wxWindow *arg1 = (wxWindow *) 0 ;
31916 wxSizer *arg2 = (wxSizer *) 0 ;
31917 bool arg3 = (bool) true ;
31918 PyObject * obj0 = 0 ;
31919 PyObject * obj1 = 0 ;
31920 PyObject * obj2 = 0 ;
31921 char *kwnames[] = {
31922 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31923 };
31924
31925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31927 if (SWIG_arg_fail(1)) SWIG_fail;
31928 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31929 if (SWIG_arg_fail(2)) SWIG_fail;
31930 if (obj2) {
31931 {
31932 arg3 = (bool)(SWIG_As_bool(obj2));
31933 if (SWIG_arg_fail(3)) SWIG_fail;
31934 }
31935 }
31936 {
31937 PyThreadState* __tstate = wxPyBeginAllowThreads();
31938 (arg1)->SetSizer(arg2,arg3);
31939
31940 wxPyEndAllowThreads(__tstate);
31941 if (PyErr_Occurred()) SWIG_fail;
31942 }
31943 Py_INCREF(Py_None); resultobj = Py_None;
31944 return resultobj;
31945 fail:
31946 return NULL;
31947 }
31948
31949
31950 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31951 PyObject *resultobj;
31952 wxWindow *arg1 = (wxWindow *) 0 ;
31953 wxSizer *arg2 = (wxSizer *) 0 ;
31954 bool arg3 = (bool) true ;
31955 PyObject * obj0 = 0 ;
31956 PyObject * obj1 = 0 ;
31957 PyObject * obj2 = 0 ;
31958 char *kwnames[] = {
31959 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31960 };
31961
31962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31964 if (SWIG_arg_fail(1)) SWIG_fail;
31965 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31966 if (SWIG_arg_fail(2)) SWIG_fail;
31967 if (obj2) {
31968 {
31969 arg3 = (bool)(SWIG_As_bool(obj2));
31970 if (SWIG_arg_fail(3)) SWIG_fail;
31971 }
31972 }
31973 {
31974 PyThreadState* __tstate = wxPyBeginAllowThreads();
31975 (arg1)->SetSizerAndFit(arg2,arg3);
31976
31977 wxPyEndAllowThreads(__tstate);
31978 if (PyErr_Occurred()) SWIG_fail;
31979 }
31980 Py_INCREF(Py_None); resultobj = Py_None;
31981 return resultobj;
31982 fail:
31983 return NULL;
31984 }
31985
31986
31987 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31988 PyObject *resultobj;
31989 wxWindow *arg1 = (wxWindow *) 0 ;
31990 wxSizer *result;
31991 PyObject * obj0 = 0 ;
31992 char *kwnames[] = {
31993 (char *) "self", NULL
31994 };
31995
31996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31998 if (SWIG_arg_fail(1)) SWIG_fail;
31999 {
32000 PyThreadState* __tstate = wxPyBeginAllowThreads();
32001 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32002
32003 wxPyEndAllowThreads(__tstate);
32004 if (PyErr_Occurred()) SWIG_fail;
32005 }
32006 {
32007 resultobj = wxPyMake_wxSizer(result, 0);
32008 }
32009 return resultobj;
32010 fail:
32011 return NULL;
32012 }
32013
32014
32015 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32016 PyObject *resultobj;
32017 wxWindow *arg1 = (wxWindow *) 0 ;
32018 wxSizer *arg2 = (wxSizer *) 0 ;
32019 PyObject * obj0 = 0 ;
32020 PyObject * obj1 = 0 ;
32021 char *kwnames[] = {
32022 (char *) "self",(char *) "sizer", NULL
32023 };
32024
32025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32027 if (SWIG_arg_fail(1)) SWIG_fail;
32028 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32029 if (SWIG_arg_fail(2)) SWIG_fail;
32030 {
32031 PyThreadState* __tstate = wxPyBeginAllowThreads();
32032 (arg1)->SetContainingSizer(arg2);
32033
32034 wxPyEndAllowThreads(__tstate);
32035 if (PyErr_Occurred()) SWIG_fail;
32036 }
32037 Py_INCREF(Py_None); resultobj = Py_None;
32038 return resultobj;
32039 fail:
32040 return NULL;
32041 }
32042
32043
32044 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32045 PyObject *resultobj;
32046 wxWindow *arg1 = (wxWindow *) 0 ;
32047 wxSizer *result;
32048 PyObject * obj0 = 0 ;
32049 char *kwnames[] = {
32050 (char *) "self", NULL
32051 };
32052
32053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32055 if (SWIG_arg_fail(1)) SWIG_fail;
32056 {
32057 PyThreadState* __tstate = wxPyBeginAllowThreads();
32058 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32059
32060 wxPyEndAllowThreads(__tstate);
32061 if (PyErr_Occurred()) SWIG_fail;
32062 }
32063 {
32064 resultobj = wxPyMake_wxSizer(result, 0);
32065 }
32066 return resultobj;
32067 fail:
32068 return NULL;
32069 }
32070
32071
32072 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32073 PyObject *resultobj;
32074 wxWindow *arg1 = (wxWindow *) 0 ;
32075 PyObject * obj0 = 0 ;
32076 char *kwnames[] = {
32077 (char *) "self", NULL
32078 };
32079
32080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32082 if (SWIG_arg_fail(1)) SWIG_fail;
32083 {
32084 PyThreadState* __tstate = wxPyBeginAllowThreads();
32085 (arg1)->InheritAttributes();
32086
32087 wxPyEndAllowThreads(__tstate);
32088 if (PyErr_Occurred()) SWIG_fail;
32089 }
32090 Py_INCREF(Py_None); resultobj = Py_None;
32091 return resultobj;
32092 fail:
32093 return NULL;
32094 }
32095
32096
32097 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32098 PyObject *resultobj;
32099 wxWindow *arg1 = (wxWindow *) 0 ;
32100 bool result;
32101 PyObject * obj0 = 0 ;
32102 char *kwnames[] = {
32103 (char *) "self", NULL
32104 };
32105
32106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32108 if (SWIG_arg_fail(1)) SWIG_fail;
32109 {
32110 PyThreadState* __tstate = wxPyBeginAllowThreads();
32111 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32112
32113 wxPyEndAllowThreads(__tstate);
32114 if (PyErr_Occurred()) SWIG_fail;
32115 }
32116 {
32117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32118 }
32119 return resultobj;
32120 fail:
32121 return NULL;
32122 }
32123
32124
32125 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32126 PyObject *obj;
32127 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32128 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32129 Py_INCREF(obj);
32130 return Py_BuildValue((char *)"");
32131 }
32132 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32133 PyObject *resultobj;
32134 long arg1 ;
32135 wxWindow *arg2 = (wxWindow *) NULL ;
32136 wxWindow *result;
32137 PyObject * obj0 = 0 ;
32138 PyObject * obj1 = 0 ;
32139 char *kwnames[] = {
32140 (char *) "id",(char *) "parent", NULL
32141 };
32142
32143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32144 {
32145 arg1 = (long)(SWIG_As_long(obj0));
32146 if (SWIG_arg_fail(1)) SWIG_fail;
32147 }
32148 if (obj1) {
32149 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32150 if (SWIG_arg_fail(2)) SWIG_fail;
32151 }
32152 {
32153 if (!wxPyCheckForApp()) SWIG_fail;
32154 PyThreadState* __tstate = wxPyBeginAllowThreads();
32155 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32156
32157 wxPyEndAllowThreads(__tstate);
32158 if (PyErr_Occurred()) SWIG_fail;
32159 }
32160 {
32161 resultobj = wxPyMake_wxObject(result, 0);
32162 }
32163 return resultobj;
32164 fail:
32165 return NULL;
32166 }
32167
32168
32169 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32170 PyObject *resultobj;
32171 wxString *arg1 = 0 ;
32172 wxWindow *arg2 = (wxWindow *) NULL ;
32173 wxWindow *result;
32174 bool temp1 = false ;
32175 PyObject * obj0 = 0 ;
32176 PyObject * obj1 = 0 ;
32177 char *kwnames[] = {
32178 (char *) "name",(char *) "parent", NULL
32179 };
32180
32181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32182 {
32183 arg1 = wxString_in_helper(obj0);
32184 if (arg1 == NULL) SWIG_fail;
32185 temp1 = true;
32186 }
32187 if (obj1) {
32188 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32189 if (SWIG_arg_fail(2)) SWIG_fail;
32190 }
32191 {
32192 if (!wxPyCheckForApp()) SWIG_fail;
32193 PyThreadState* __tstate = wxPyBeginAllowThreads();
32194 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32195
32196 wxPyEndAllowThreads(__tstate);
32197 if (PyErr_Occurred()) SWIG_fail;
32198 }
32199 {
32200 resultobj = wxPyMake_wxObject(result, 0);
32201 }
32202 {
32203 if (temp1)
32204 delete arg1;
32205 }
32206 return resultobj;
32207 fail:
32208 {
32209 if (temp1)
32210 delete arg1;
32211 }
32212 return NULL;
32213 }
32214
32215
32216 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32217 PyObject *resultobj;
32218 wxString *arg1 = 0 ;
32219 wxWindow *arg2 = (wxWindow *) NULL ;
32220 wxWindow *result;
32221 bool temp1 = false ;
32222 PyObject * obj0 = 0 ;
32223 PyObject * obj1 = 0 ;
32224 char *kwnames[] = {
32225 (char *) "label",(char *) "parent", NULL
32226 };
32227
32228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32229 {
32230 arg1 = wxString_in_helper(obj0);
32231 if (arg1 == NULL) SWIG_fail;
32232 temp1 = true;
32233 }
32234 if (obj1) {
32235 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32236 if (SWIG_arg_fail(2)) SWIG_fail;
32237 }
32238 {
32239 if (!wxPyCheckForApp()) SWIG_fail;
32240 PyThreadState* __tstate = wxPyBeginAllowThreads();
32241 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32242
32243 wxPyEndAllowThreads(__tstate);
32244 if (PyErr_Occurred()) SWIG_fail;
32245 }
32246 {
32247 resultobj = wxPyMake_wxObject(result, 0);
32248 }
32249 {
32250 if (temp1)
32251 delete arg1;
32252 }
32253 return resultobj;
32254 fail:
32255 {
32256 if (temp1)
32257 delete arg1;
32258 }
32259 return NULL;
32260 }
32261
32262
32263 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32264 PyObject *resultobj;
32265 wxWindow *arg1 = (wxWindow *) 0 ;
32266 unsigned long arg2 ;
32267 wxWindow *result;
32268 PyObject * obj0 = 0 ;
32269 PyObject * obj1 = 0 ;
32270 char *kwnames[] = {
32271 (char *) "parent",(char *) "_hWnd", NULL
32272 };
32273
32274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32276 if (SWIG_arg_fail(1)) SWIG_fail;
32277 {
32278 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32279 if (SWIG_arg_fail(2)) SWIG_fail;
32280 }
32281 {
32282 PyThreadState* __tstate = wxPyBeginAllowThreads();
32283 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32284
32285 wxPyEndAllowThreads(__tstate);
32286 if (PyErr_Occurred()) SWIG_fail;
32287 }
32288 {
32289 resultobj = wxPyMake_wxObject(result, 0);
32290 }
32291 return resultobj;
32292 fail:
32293 return NULL;
32294 }
32295
32296
32297 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32298 PyObject *resultobj;
32299 wxValidator *result;
32300 char *kwnames[] = {
32301 NULL
32302 };
32303
32304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32305 {
32306 PyThreadState* __tstate = wxPyBeginAllowThreads();
32307 result = (wxValidator *)new wxValidator();
32308
32309 wxPyEndAllowThreads(__tstate);
32310 if (PyErr_Occurred()) SWIG_fail;
32311 }
32312 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32313 return resultobj;
32314 fail:
32315 return NULL;
32316 }
32317
32318
32319 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32320 PyObject *resultobj;
32321 wxValidator *arg1 = (wxValidator *) 0 ;
32322 wxValidator *result;
32323 PyObject * obj0 = 0 ;
32324 char *kwnames[] = {
32325 (char *) "self", NULL
32326 };
32327
32328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32330 if (SWIG_arg_fail(1)) SWIG_fail;
32331 {
32332 PyThreadState* __tstate = wxPyBeginAllowThreads();
32333 result = (wxValidator *)(arg1)->Clone();
32334
32335 wxPyEndAllowThreads(__tstate);
32336 if (PyErr_Occurred()) SWIG_fail;
32337 }
32338 {
32339 resultobj = wxPyMake_wxObject(result, 0);
32340 }
32341 return resultobj;
32342 fail:
32343 return NULL;
32344 }
32345
32346
32347 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32348 PyObject *resultobj;
32349 wxValidator *arg1 = (wxValidator *) 0 ;
32350 wxWindow *arg2 = (wxWindow *) 0 ;
32351 bool result;
32352 PyObject * obj0 = 0 ;
32353 PyObject * obj1 = 0 ;
32354 char *kwnames[] = {
32355 (char *) "self",(char *) "parent", NULL
32356 };
32357
32358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32360 if (SWIG_arg_fail(1)) SWIG_fail;
32361 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32362 if (SWIG_arg_fail(2)) SWIG_fail;
32363 {
32364 PyThreadState* __tstate = wxPyBeginAllowThreads();
32365 result = (bool)(arg1)->Validate(arg2);
32366
32367 wxPyEndAllowThreads(__tstate);
32368 if (PyErr_Occurred()) SWIG_fail;
32369 }
32370 {
32371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32372 }
32373 return resultobj;
32374 fail:
32375 return NULL;
32376 }
32377
32378
32379 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32380 PyObject *resultobj;
32381 wxValidator *arg1 = (wxValidator *) 0 ;
32382 bool result;
32383 PyObject * obj0 = 0 ;
32384 char *kwnames[] = {
32385 (char *) "self", NULL
32386 };
32387
32388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32390 if (SWIG_arg_fail(1)) SWIG_fail;
32391 {
32392 PyThreadState* __tstate = wxPyBeginAllowThreads();
32393 result = (bool)(arg1)->TransferToWindow();
32394
32395 wxPyEndAllowThreads(__tstate);
32396 if (PyErr_Occurred()) SWIG_fail;
32397 }
32398 {
32399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32400 }
32401 return resultobj;
32402 fail:
32403 return NULL;
32404 }
32405
32406
32407 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32408 PyObject *resultobj;
32409 wxValidator *arg1 = (wxValidator *) 0 ;
32410 bool result;
32411 PyObject * obj0 = 0 ;
32412 char *kwnames[] = {
32413 (char *) "self", NULL
32414 };
32415
32416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32418 if (SWIG_arg_fail(1)) SWIG_fail;
32419 {
32420 PyThreadState* __tstate = wxPyBeginAllowThreads();
32421 result = (bool)(arg1)->TransferFromWindow();
32422
32423 wxPyEndAllowThreads(__tstate);
32424 if (PyErr_Occurred()) SWIG_fail;
32425 }
32426 {
32427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32428 }
32429 return resultobj;
32430 fail:
32431 return NULL;
32432 }
32433
32434
32435 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32436 PyObject *resultobj;
32437 wxValidator *arg1 = (wxValidator *) 0 ;
32438 wxWindow *result;
32439 PyObject * obj0 = 0 ;
32440 char *kwnames[] = {
32441 (char *) "self", NULL
32442 };
32443
32444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32446 if (SWIG_arg_fail(1)) SWIG_fail;
32447 {
32448 PyThreadState* __tstate = wxPyBeginAllowThreads();
32449 result = (wxWindow *)(arg1)->GetWindow();
32450
32451 wxPyEndAllowThreads(__tstate);
32452 if (PyErr_Occurred()) SWIG_fail;
32453 }
32454 {
32455 resultobj = wxPyMake_wxObject(result, 0);
32456 }
32457 return resultobj;
32458 fail:
32459 return NULL;
32460 }
32461
32462
32463 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32464 PyObject *resultobj;
32465 wxValidator *arg1 = (wxValidator *) 0 ;
32466 wxWindow *arg2 = (wxWindow *) 0 ;
32467 PyObject * obj0 = 0 ;
32468 PyObject * obj1 = 0 ;
32469 char *kwnames[] = {
32470 (char *) "self",(char *) "window", NULL
32471 };
32472
32473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32475 if (SWIG_arg_fail(1)) SWIG_fail;
32476 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32477 if (SWIG_arg_fail(2)) SWIG_fail;
32478 {
32479 PyThreadState* __tstate = wxPyBeginAllowThreads();
32480 (arg1)->SetWindow(arg2);
32481
32482 wxPyEndAllowThreads(__tstate);
32483 if (PyErr_Occurred()) SWIG_fail;
32484 }
32485 Py_INCREF(Py_None); resultobj = Py_None;
32486 return resultobj;
32487 fail:
32488 return NULL;
32489 }
32490
32491
32492 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32493 PyObject *resultobj;
32494 bool result;
32495 char *kwnames[] = {
32496 NULL
32497 };
32498
32499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32500 {
32501 PyThreadState* __tstate = wxPyBeginAllowThreads();
32502 result = (bool)wxValidator::IsSilent();
32503
32504 wxPyEndAllowThreads(__tstate);
32505 if (PyErr_Occurred()) SWIG_fail;
32506 }
32507 {
32508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32509 }
32510 return resultobj;
32511 fail:
32512 return NULL;
32513 }
32514
32515
32516 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32517 PyObject *resultobj;
32518 int arg1 = (int) true ;
32519 PyObject * obj0 = 0 ;
32520 char *kwnames[] = {
32521 (char *) "doIt", NULL
32522 };
32523
32524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32525 if (obj0) {
32526 {
32527 arg1 = (int)(SWIG_As_int(obj0));
32528 if (SWIG_arg_fail(1)) SWIG_fail;
32529 }
32530 }
32531 {
32532 PyThreadState* __tstate = wxPyBeginAllowThreads();
32533 wxValidator::SetBellOnError(arg1);
32534
32535 wxPyEndAllowThreads(__tstate);
32536 if (PyErr_Occurred()) SWIG_fail;
32537 }
32538 Py_INCREF(Py_None); resultobj = Py_None;
32539 return resultobj;
32540 fail:
32541 return NULL;
32542 }
32543
32544
32545 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32546 PyObject *obj;
32547 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32548 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32549 Py_INCREF(obj);
32550 return Py_BuildValue((char *)"");
32551 }
32552 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32553 PyObject *resultobj;
32554 wxPyValidator *result;
32555 char *kwnames[] = {
32556 NULL
32557 };
32558
32559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32560 {
32561 PyThreadState* __tstate = wxPyBeginAllowThreads();
32562 result = (wxPyValidator *)new wxPyValidator();
32563
32564 wxPyEndAllowThreads(__tstate);
32565 if (PyErr_Occurred()) SWIG_fail;
32566 }
32567 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32568 return resultobj;
32569 fail:
32570 return NULL;
32571 }
32572
32573
32574 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32575 PyObject *resultobj;
32576 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32577 PyObject *arg2 = (PyObject *) 0 ;
32578 PyObject *arg3 = (PyObject *) 0 ;
32579 int arg4 = (int) true ;
32580 PyObject * obj0 = 0 ;
32581 PyObject * obj1 = 0 ;
32582 PyObject * obj2 = 0 ;
32583 PyObject * obj3 = 0 ;
32584 char *kwnames[] = {
32585 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32586 };
32587
32588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32590 if (SWIG_arg_fail(1)) SWIG_fail;
32591 arg2 = obj1;
32592 arg3 = obj2;
32593 if (obj3) {
32594 {
32595 arg4 = (int)(SWIG_As_int(obj3));
32596 if (SWIG_arg_fail(4)) SWIG_fail;
32597 }
32598 }
32599 {
32600 PyThreadState* __tstate = wxPyBeginAllowThreads();
32601 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32602
32603 wxPyEndAllowThreads(__tstate);
32604 if (PyErr_Occurred()) SWIG_fail;
32605 }
32606 Py_INCREF(Py_None); resultobj = Py_None;
32607 return resultobj;
32608 fail:
32609 return NULL;
32610 }
32611
32612
32613 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32614 PyObject *obj;
32615 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32616 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32617 Py_INCREF(obj);
32618 return Py_BuildValue((char *)"");
32619 }
32620 static int _wrap_DefaultValidator_set(PyObject *) {
32621 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32622 return 1;
32623 }
32624
32625
32626 static PyObject *_wrap_DefaultValidator_get(void) {
32627 PyObject *pyobj;
32628
32629 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32630 return pyobj;
32631 }
32632
32633
32634 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32635 PyObject *resultobj;
32636 wxString const &arg1_defvalue = wxPyEmptyString ;
32637 wxString *arg1 = (wxString *) &arg1_defvalue ;
32638 long arg2 = (long) 0 ;
32639 wxMenu *result;
32640 bool temp1 = false ;
32641 PyObject * obj0 = 0 ;
32642 PyObject * obj1 = 0 ;
32643 char *kwnames[] = {
32644 (char *) "title",(char *) "style", NULL
32645 };
32646
32647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32648 if (obj0) {
32649 {
32650 arg1 = wxString_in_helper(obj0);
32651 if (arg1 == NULL) SWIG_fail;
32652 temp1 = true;
32653 }
32654 }
32655 if (obj1) {
32656 {
32657 arg2 = (long)(SWIG_As_long(obj1));
32658 if (SWIG_arg_fail(2)) SWIG_fail;
32659 }
32660 }
32661 {
32662 if (!wxPyCheckForApp()) SWIG_fail;
32663 PyThreadState* __tstate = wxPyBeginAllowThreads();
32664 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32665
32666 wxPyEndAllowThreads(__tstate);
32667 if (PyErr_Occurred()) SWIG_fail;
32668 }
32669 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32670 {
32671 if (temp1)
32672 delete arg1;
32673 }
32674 return resultobj;
32675 fail:
32676 {
32677 if (temp1)
32678 delete arg1;
32679 }
32680 return NULL;
32681 }
32682
32683
32684 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32685 PyObject *resultobj;
32686 wxMenu *arg1 = (wxMenu *) 0 ;
32687 int arg2 ;
32688 wxString *arg3 = 0 ;
32689 wxString const &arg4_defvalue = wxPyEmptyString ;
32690 wxString *arg4 = (wxString *) &arg4_defvalue ;
32691 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32692 wxMenuItem *result;
32693 bool temp3 = false ;
32694 bool temp4 = false ;
32695 PyObject * obj0 = 0 ;
32696 PyObject * obj1 = 0 ;
32697 PyObject * obj2 = 0 ;
32698 PyObject * obj3 = 0 ;
32699 PyObject * obj4 = 0 ;
32700 char *kwnames[] = {
32701 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32702 };
32703
32704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32706 if (SWIG_arg_fail(1)) SWIG_fail;
32707 {
32708 arg2 = (int)(SWIG_As_int(obj1));
32709 if (SWIG_arg_fail(2)) SWIG_fail;
32710 }
32711 {
32712 arg3 = wxString_in_helper(obj2);
32713 if (arg3 == NULL) SWIG_fail;
32714 temp3 = true;
32715 }
32716 if (obj3) {
32717 {
32718 arg4 = wxString_in_helper(obj3);
32719 if (arg4 == NULL) SWIG_fail;
32720 temp4 = true;
32721 }
32722 }
32723 if (obj4) {
32724 {
32725 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32726 if (SWIG_arg_fail(5)) SWIG_fail;
32727 }
32728 }
32729 {
32730 PyThreadState* __tstate = wxPyBeginAllowThreads();
32731 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32732
32733 wxPyEndAllowThreads(__tstate);
32734 if (PyErr_Occurred()) SWIG_fail;
32735 }
32736 {
32737 resultobj = wxPyMake_wxObject(result, 0);
32738 }
32739 {
32740 if (temp3)
32741 delete arg3;
32742 }
32743 {
32744 if (temp4)
32745 delete arg4;
32746 }
32747 return resultobj;
32748 fail:
32749 {
32750 if (temp3)
32751 delete arg3;
32752 }
32753 {
32754 if (temp4)
32755 delete arg4;
32756 }
32757 return NULL;
32758 }
32759
32760
32761 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32762 PyObject *resultobj;
32763 wxMenu *arg1 = (wxMenu *) 0 ;
32764 wxMenuItem *result;
32765 PyObject * obj0 = 0 ;
32766 char *kwnames[] = {
32767 (char *) "self", NULL
32768 };
32769
32770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32772 if (SWIG_arg_fail(1)) SWIG_fail;
32773 {
32774 PyThreadState* __tstate = wxPyBeginAllowThreads();
32775 result = (wxMenuItem *)(arg1)->AppendSeparator();
32776
32777 wxPyEndAllowThreads(__tstate);
32778 if (PyErr_Occurred()) SWIG_fail;
32779 }
32780 {
32781 resultobj = wxPyMake_wxObject(result, 0);
32782 }
32783 return resultobj;
32784 fail:
32785 return NULL;
32786 }
32787
32788
32789 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32790 PyObject *resultobj;
32791 wxMenu *arg1 = (wxMenu *) 0 ;
32792 int arg2 ;
32793 wxString *arg3 = 0 ;
32794 wxString const &arg4_defvalue = wxPyEmptyString ;
32795 wxString *arg4 = (wxString *) &arg4_defvalue ;
32796 wxMenuItem *result;
32797 bool temp3 = false ;
32798 bool temp4 = false ;
32799 PyObject * obj0 = 0 ;
32800 PyObject * obj1 = 0 ;
32801 PyObject * obj2 = 0 ;
32802 PyObject * obj3 = 0 ;
32803 char *kwnames[] = {
32804 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32805 };
32806
32807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32809 if (SWIG_arg_fail(1)) SWIG_fail;
32810 {
32811 arg2 = (int)(SWIG_As_int(obj1));
32812 if (SWIG_arg_fail(2)) SWIG_fail;
32813 }
32814 {
32815 arg3 = wxString_in_helper(obj2);
32816 if (arg3 == NULL) SWIG_fail;
32817 temp3 = true;
32818 }
32819 if (obj3) {
32820 {
32821 arg4 = wxString_in_helper(obj3);
32822 if (arg4 == NULL) SWIG_fail;
32823 temp4 = true;
32824 }
32825 }
32826 {
32827 PyThreadState* __tstate = wxPyBeginAllowThreads();
32828 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32829
32830 wxPyEndAllowThreads(__tstate);
32831 if (PyErr_Occurred()) SWIG_fail;
32832 }
32833 {
32834 resultobj = wxPyMake_wxObject(result, 0);
32835 }
32836 {
32837 if (temp3)
32838 delete arg3;
32839 }
32840 {
32841 if (temp4)
32842 delete arg4;
32843 }
32844 return resultobj;
32845 fail:
32846 {
32847 if (temp3)
32848 delete arg3;
32849 }
32850 {
32851 if (temp4)
32852 delete arg4;
32853 }
32854 return NULL;
32855 }
32856
32857
32858 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32859 PyObject *resultobj;
32860 wxMenu *arg1 = (wxMenu *) 0 ;
32861 int arg2 ;
32862 wxString *arg3 = 0 ;
32863 wxString const &arg4_defvalue = wxPyEmptyString ;
32864 wxString *arg4 = (wxString *) &arg4_defvalue ;
32865 wxMenuItem *result;
32866 bool temp3 = false ;
32867 bool temp4 = false ;
32868 PyObject * obj0 = 0 ;
32869 PyObject * obj1 = 0 ;
32870 PyObject * obj2 = 0 ;
32871 PyObject * obj3 = 0 ;
32872 char *kwnames[] = {
32873 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32874 };
32875
32876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32878 if (SWIG_arg_fail(1)) SWIG_fail;
32879 {
32880 arg2 = (int)(SWIG_As_int(obj1));
32881 if (SWIG_arg_fail(2)) SWIG_fail;
32882 }
32883 {
32884 arg3 = wxString_in_helper(obj2);
32885 if (arg3 == NULL) SWIG_fail;
32886 temp3 = true;
32887 }
32888 if (obj3) {
32889 {
32890 arg4 = wxString_in_helper(obj3);
32891 if (arg4 == NULL) SWIG_fail;
32892 temp4 = true;
32893 }
32894 }
32895 {
32896 PyThreadState* __tstate = wxPyBeginAllowThreads();
32897 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32898
32899 wxPyEndAllowThreads(__tstate);
32900 if (PyErr_Occurred()) SWIG_fail;
32901 }
32902 {
32903 resultobj = wxPyMake_wxObject(result, 0);
32904 }
32905 {
32906 if (temp3)
32907 delete arg3;
32908 }
32909 {
32910 if (temp4)
32911 delete arg4;
32912 }
32913 return resultobj;
32914 fail:
32915 {
32916 if (temp3)
32917 delete arg3;
32918 }
32919 {
32920 if (temp4)
32921 delete arg4;
32922 }
32923 return NULL;
32924 }
32925
32926
32927 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32928 PyObject *resultobj;
32929 wxMenu *arg1 = (wxMenu *) 0 ;
32930 int arg2 ;
32931 wxString *arg3 = 0 ;
32932 wxMenu *arg4 = (wxMenu *) 0 ;
32933 wxString const &arg5_defvalue = wxPyEmptyString ;
32934 wxString *arg5 = (wxString *) &arg5_defvalue ;
32935 wxMenuItem *result;
32936 bool temp3 = false ;
32937 bool temp5 = false ;
32938 PyObject * obj0 = 0 ;
32939 PyObject * obj1 = 0 ;
32940 PyObject * obj2 = 0 ;
32941 PyObject * obj3 = 0 ;
32942 PyObject * obj4 = 0 ;
32943 char *kwnames[] = {
32944 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32945 };
32946
32947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32949 if (SWIG_arg_fail(1)) SWIG_fail;
32950 {
32951 arg2 = (int)(SWIG_As_int(obj1));
32952 if (SWIG_arg_fail(2)) SWIG_fail;
32953 }
32954 {
32955 arg3 = wxString_in_helper(obj2);
32956 if (arg3 == NULL) SWIG_fail;
32957 temp3 = true;
32958 }
32959 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32960 if (SWIG_arg_fail(4)) SWIG_fail;
32961 if (obj4) {
32962 {
32963 arg5 = wxString_in_helper(obj4);
32964 if (arg5 == NULL) SWIG_fail;
32965 temp5 = true;
32966 }
32967 }
32968 {
32969 PyThreadState* __tstate = wxPyBeginAllowThreads();
32970 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32971
32972 wxPyEndAllowThreads(__tstate);
32973 if (PyErr_Occurred()) SWIG_fail;
32974 }
32975 {
32976 resultobj = wxPyMake_wxObject(result, 0);
32977 }
32978 {
32979 if (temp3)
32980 delete arg3;
32981 }
32982 {
32983 if (temp5)
32984 delete arg5;
32985 }
32986 return resultobj;
32987 fail:
32988 {
32989 if (temp3)
32990 delete arg3;
32991 }
32992 {
32993 if (temp5)
32994 delete arg5;
32995 }
32996 return NULL;
32997 }
32998
32999
33000 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33001 PyObject *resultobj;
33002 wxMenu *arg1 = (wxMenu *) 0 ;
33003 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33004 wxMenuItem *result;
33005 PyObject * obj0 = 0 ;
33006 PyObject * obj1 = 0 ;
33007 char *kwnames[] = {
33008 (char *) "self",(char *) "item", NULL
33009 };
33010
33011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33013 if (SWIG_arg_fail(1)) SWIG_fail;
33014 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33015 if (SWIG_arg_fail(2)) SWIG_fail;
33016 {
33017 PyThreadState* __tstate = wxPyBeginAllowThreads();
33018 result = (wxMenuItem *)(arg1)->Append(arg2);
33019
33020 wxPyEndAllowThreads(__tstate);
33021 if (PyErr_Occurred()) SWIG_fail;
33022 }
33023 {
33024 resultobj = wxPyMake_wxObject(result, 0);
33025 }
33026 return resultobj;
33027 fail:
33028 return NULL;
33029 }
33030
33031
33032 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33033 PyObject *resultobj;
33034 wxMenu *arg1 = (wxMenu *) 0 ;
33035 PyObject * obj0 = 0 ;
33036 char *kwnames[] = {
33037 (char *) "self", NULL
33038 };
33039
33040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33042 if (SWIG_arg_fail(1)) SWIG_fail;
33043 {
33044 PyThreadState* __tstate = wxPyBeginAllowThreads();
33045 (arg1)->Break();
33046
33047 wxPyEndAllowThreads(__tstate);
33048 if (PyErr_Occurred()) SWIG_fail;
33049 }
33050 Py_INCREF(Py_None); resultobj = Py_None;
33051 return resultobj;
33052 fail:
33053 return NULL;
33054 }
33055
33056
33057 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33058 PyObject *resultobj;
33059 wxMenu *arg1 = (wxMenu *) 0 ;
33060 size_t arg2 ;
33061 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33062 wxMenuItem *result;
33063 PyObject * obj0 = 0 ;
33064 PyObject * obj1 = 0 ;
33065 PyObject * obj2 = 0 ;
33066 char *kwnames[] = {
33067 (char *) "self",(char *) "pos",(char *) "item", NULL
33068 };
33069
33070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33072 if (SWIG_arg_fail(1)) SWIG_fail;
33073 {
33074 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33075 if (SWIG_arg_fail(2)) SWIG_fail;
33076 }
33077 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33078 if (SWIG_arg_fail(3)) SWIG_fail;
33079 {
33080 PyThreadState* __tstate = wxPyBeginAllowThreads();
33081 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33082
33083 wxPyEndAllowThreads(__tstate);
33084 if (PyErr_Occurred()) SWIG_fail;
33085 }
33086 {
33087 resultobj = wxPyMake_wxObject(result, 0);
33088 }
33089 return resultobj;
33090 fail:
33091 return NULL;
33092 }
33093
33094
33095 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33096 PyObject *resultobj;
33097 wxMenu *arg1 = (wxMenu *) 0 ;
33098 size_t arg2 ;
33099 int arg3 ;
33100 wxString *arg4 = 0 ;
33101 wxString const &arg5_defvalue = wxPyEmptyString ;
33102 wxString *arg5 = (wxString *) &arg5_defvalue ;
33103 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33104 wxMenuItem *result;
33105 bool temp4 = false ;
33106 bool temp5 = false ;
33107 PyObject * obj0 = 0 ;
33108 PyObject * obj1 = 0 ;
33109 PyObject * obj2 = 0 ;
33110 PyObject * obj3 = 0 ;
33111 PyObject * obj4 = 0 ;
33112 PyObject * obj5 = 0 ;
33113 char *kwnames[] = {
33114 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33115 };
33116
33117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33119 if (SWIG_arg_fail(1)) SWIG_fail;
33120 {
33121 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33122 if (SWIG_arg_fail(2)) SWIG_fail;
33123 }
33124 {
33125 arg3 = (int)(SWIG_As_int(obj2));
33126 if (SWIG_arg_fail(3)) SWIG_fail;
33127 }
33128 {
33129 arg4 = wxString_in_helper(obj3);
33130 if (arg4 == NULL) SWIG_fail;
33131 temp4 = true;
33132 }
33133 if (obj4) {
33134 {
33135 arg5 = wxString_in_helper(obj4);
33136 if (arg5 == NULL) SWIG_fail;
33137 temp5 = true;
33138 }
33139 }
33140 if (obj5) {
33141 {
33142 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33143 if (SWIG_arg_fail(6)) SWIG_fail;
33144 }
33145 }
33146 {
33147 PyThreadState* __tstate = wxPyBeginAllowThreads();
33148 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33149
33150 wxPyEndAllowThreads(__tstate);
33151 if (PyErr_Occurred()) SWIG_fail;
33152 }
33153 {
33154 resultobj = wxPyMake_wxObject(result, 0);
33155 }
33156 {
33157 if (temp4)
33158 delete arg4;
33159 }
33160 {
33161 if (temp5)
33162 delete arg5;
33163 }
33164 return resultobj;
33165 fail:
33166 {
33167 if (temp4)
33168 delete arg4;
33169 }
33170 {
33171 if (temp5)
33172 delete arg5;
33173 }
33174 return NULL;
33175 }
33176
33177
33178 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33179 PyObject *resultobj;
33180 wxMenu *arg1 = (wxMenu *) 0 ;
33181 size_t arg2 ;
33182 wxMenuItem *result;
33183 PyObject * obj0 = 0 ;
33184 PyObject * obj1 = 0 ;
33185 char *kwnames[] = {
33186 (char *) "self",(char *) "pos", NULL
33187 };
33188
33189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33191 if (SWIG_arg_fail(1)) SWIG_fail;
33192 {
33193 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33194 if (SWIG_arg_fail(2)) SWIG_fail;
33195 }
33196 {
33197 PyThreadState* __tstate = wxPyBeginAllowThreads();
33198 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33199
33200 wxPyEndAllowThreads(__tstate);
33201 if (PyErr_Occurred()) SWIG_fail;
33202 }
33203 {
33204 resultobj = wxPyMake_wxObject(result, 0);
33205 }
33206 return resultobj;
33207 fail:
33208 return NULL;
33209 }
33210
33211
33212 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33213 PyObject *resultobj;
33214 wxMenu *arg1 = (wxMenu *) 0 ;
33215 size_t arg2 ;
33216 int arg3 ;
33217 wxString *arg4 = 0 ;
33218 wxString const &arg5_defvalue = wxPyEmptyString ;
33219 wxString *arg5 = (wxString *) &arg5_defvalue ;
33220 wxMenuItem *result;
33221 bool temp4 = false ;
33222 bool temp5 = false ;
33223 PyObject * obj0 = 0 ;
33224 PyObject * obj1 = 0 ;
33225 PyObject * obj2 = 0 ;
33226 PyObject * obj3 = 0 ;
33227 PyObject * obj4 = 0 ;
33228 char *kwnames[] = {
33229 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33230 };
33231
33232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33234 if (SWIG_arg_fail(1)) SWIG_fail;
33235 {
33236 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33237 if (SWIG_arg_fail(2)) SWIG_fail;
33238 }
33239 {
33240 arg3 = (int)(SWIG_As_int(obj2));
33241 if (SWIG_arg_fail(3)) SWIG_fail;
33242 }
33243 {
33244 arg4 = wxString_in_helper(obj3);
33245 if (arg4 == NULL) SWIG_fail;
33246 temp4 = true;
33247 }
33248 if (obj4) {
33249 {
33250 arg5 = wxString_in_helper(obj4);
33251 if (arg5 == NULL) SWIG_fail;
33252 temp5 = true;
33253 }
33254 }
33255 {
33256 PyThreadState* __tstate = wxPyBeginAllowThreads();
33257 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33258
33259 wxPyEndAllowThreads(__tstate);
33260 if (PyErr_Occurred()) SWIG_fail;
33261 }
33262 {
33263 resultobj = wxPyMake_wxObject(result, 0);
33264 }
33265 {
33266 if (temp4)
33267 delete arg4;
33268 }
33269 {
33270 if (temp5)
33271 delete arg5;
33272 }
33273 return resultobj;
33274 fail:
33275 {
33276 if (temp4)
33277 delete arg4;
33278 }
33279 {
33280 if (temp5)
33281 delete arg5;
33282 }
33283 return NULL;
33284 }
33285
33286
33287 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33288 PyObject *resultobj;
33289 wxMenu *arg1 = (wxMenu *) 0 ;
33290 size_t arg2 ;
33291 int arg3 ;
33292 wxString *arg4 = 0 ;
33293 wxString const &arg5_defvalue = wxPyEmptyString ;
33294 wxString *arg5 = (wxString *) &arg5_defvalue ;
33295 wxMenuItem *result;
33296 bool temp4 = false ;
33297 bool temp5 = false ;
33298 PyObject * obj0 = 0 ;
33299 PyObject * obj1 = 0 ;
33300 PyObject * obj2 = 0 ;
33301 PyObject * obj3 = 0 ;
33302 PyObject * obj4 = 0 ;
33303 char *kwnames[] = {
33304 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33305 };
33306
33307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33309 if (SWIG_arg_fail(1)) SWIG_fail;
33310 {
33311 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33312 if (SWIG_arg_fail(2)) SWIG_fail;
33313 }
33314 {
33315 arg3 = (int)(SWIG_As_int(obj2));
33316 if (SWIG_arg_fail(3)) SWIG_fail;
33317 }
33318 {
33319 arg4 = wxString_in_helper(obj3);
33320 if (arg4 == NULL) SWIG_fail;
33321 temp4 = true;
33322 }
33323 if (obj4) {
33324 {
33325 arg5 = wxString_in_helper(obj4);
33326 if (arg5 == NULL) SWIG_fail;
33327 temp5 = true;
33328 }
33329 }
33330 {
33331 PyThreadState* __tstate = wxPyBeginAllowThreads();
33332 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33333
33334 wxPyEndAllowThreads(__tstate);
33335 if (PyErr_Occurred()) SWIG_fail;
33336 }
33337 {
33338 resultobj = wxPyMake_wxObject(result, 0);
33339 }
33340 {
33341 if (temp4)
33342 delete arg4;
33343 }
33344 {
33345 if (temp5)
33346 delete arg5;
33347 }
33348 return resultobj;
33349 fail:
33350 {
33351 if (temp4)
33352 delete arg4;
33353 }
33354 {
33355 if (temp5)
33356 delete arg5;
33357 }
33358 return NULL;
33359 }
33360
33361
33362 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33363 PyObject *resultobj;
33364 wxMenu *arg1 = (wxMenu *) 0 ;
33365 size_t arg2 ;
33366 int arg3 ;
33367 wxString *arg4 = 0 ;
33368 wxMenu *arg5 = (wxMenu *) 0 ;
33369 wxString const &arg6_defvalue = wxPyEmptyString ;
33370 wxString *arg6 = (wxString *) &arg6_defvalue ;
33371 wxMenuItem *result;
33372 bool temp4 = false ;
33373 bool temp6 = false ;
33374 PyObject * obj0 = 0 ;
33375 PyObject * obj1 = 0 ;
33376 PyObject * obj2 = 0 ;
33377 PyObject * obj3 = 0 ;
33378 PyObject * obj4 = 0 ;
33379 PyObject * obj5 = 0 ;
33380 char *kwnames[] = {
33381 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33382 };
33383
33384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33386 if (SWIG_arg_fail(1)) SWIG_fail;
33387 {
33388 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33389 if (SWIG_arg_fail(2)) SWIG_fail;
33390 }
33391 {
33392 arg3 = (int)(SWIG_As_int(obj2));
33393 if (SWIG_arg_fail(3)) SWIG_fail;
33394 }
33395 {
33396 arg4 = wxString_in_helper(obj3);
33397 if (arg4 == NULL) SWIG_fail;
33398 temp4 = true;
33399 }
33400 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33401 if (SWIG_arg_fail(5)) SWIG_fail;
33402 if (obj5) {
33403 {
33404 arg6 = wxString_in_helper(obj5);
33405 if (arg6 == NULL) SWIG_fail;
33406 temp6 = true;
33407 }
33408 }
33409 {
33410 PyThreadState* __tstate = wxPyBeginAllowThreads();
33411 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33412
33413 wxPyEndAllowThreads(__tstate);
33414 if (PyErr_Occurred()) SWIG_fail;
33415 }
33416 {
33417 resultobj = wxPyMake_wxObject(result, 0);
33418 }
33419 {
33420 if (temp4)
33421 delete arg4;
33422 }
33423 {
33424 if (temp6)
33425 delete arg6;
33426 }
33427 return resultobj;
33428 fail:
33429 {
33430 if (temp4)
33431 delete arg4;
33432 }
33433 {
33434 if (temp6)
33435 delete arg6;
33436 }
33437 return NULL;
33438 }
33439
33440
33441 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33442 PyObject *resultobj;
33443 wxMenu *arg1 = (wxMenu *) 0 ;
33444 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33445 wxMenuItem *result;
33446 PyObject * obj0 = 0 ;
33447 PyObject * obj1 = 0 ;
33448 char *kwnames[] = {
33449 (char *) "self",(char *) "item", NULL
33450 };
33451
33452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33454 if (SWIG_arg_fail(1)) SWIG_fail;
33455 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33456 if (SWIG_arg_fail(2)) SWIG_fail;
33457 {
33458 PyThreadState* __tstate = wxPyBeginAllowThreads();
33459 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33460
33461 wxPyEndAllowThreads(__tstate);
33462 if (PyErr_Occurred()) SWIG_fail;
33463 }
33464 {
33465 resultobj = wxPyMake_wxObject(result, 0);
33466 }
33467 return resultobj;
33468 fail:
33469 return NULL;
33470 }
33471
33472
33473 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33474 PyObject *resultobj;
33475 wxMenu *arg1 = (wxMenu *) 0 ;
33476 int arg2 ;
33477 wxString *arg3 = 0 ;
33478 wxString const &arg4_defvalue = wxPyEmptyString ;
33479 wxString *arg4 = (wxString *) &arg4_defvalue ;
33480 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33481 wxMenuItem *result;
33482 bool temp3 = false ;
33483 bool temp4 = false ;
33484 PyObject * obj0 = 0 ;
33485 PyObject * obj1 = 0 ;
33486 PyObject * obj2 = 0 ;
33487 PyObject * obj3 = 0 ;
33488 PyObject * obj4 = 0 ;
33489 char *kwnames[] = {
33490 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33491 };
33492
33493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33495 if (SWIG_arg_fail(1)) SWIG_fail;
33496 {
33497 arg2 = (int)(SWIG_As_int(obj1));
33498 if (SWIG_arg_fail(2)) SWIG_fail;
33499 }
33500 {
33501 arg3 = wxString_in_helper(obj2);
33502 if (arg3 == NULL) SWIG_fail;
33503 temp3 = true;
33504 }
33505 if (obj3) {
33506 {
33507 arg4 = wxString_in_helper(obj3);
33508 if (arg4 == NULL) SWIG_fail;
33509 temp4 = true;
33510 }
33511 }
33512 if (obj4) {
33513 {
33514 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33515 if (SWIG_arg_fail(5)) SWIG_fail;
33516 }
33517 }
33518 {
33519 PyThreadState* __tstate = wxPyBeginAllowThreads();
33520 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33521
33522 wxPyEndAllowThreads(__tstate);
33523 if (PyErr_Occurred()) SWIG_fail;
33524 }
33525 {
33526 resultobj = wxPyMake_wxObject(result, 0);
33527 }
33528 {
33529 if (temp3)
33530 delete arg3;
33531 }
33532 {
33533 if (temp4)
33534 delete arg4;
33535 }
33536 return resultobj;
33537 fail:
33538 {
33539 if (temp3)
33540 delete arg3;
33541 }
33542 {
33543 if (temp4)
33544 delete arg4;
33545 }
33546 return NULL;
33547 }
33548
33549
33550 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33551 PyObject *resultobj;
33552 wxMenu *arg1 = (wxMenu *) 0 ;
33553 wxMenuItem *result;
33554 PyObject * obj0 = 0 ;
33555 char *kwnames[] = {
33556 (char *) "self", NULL
33557 };
33558
33559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33561 if (SWIG_arg_fail(1)) SWIG_fail;
33562 {
33563 PyThreadState* __tstate = wxPyBeginAllowThreads();
33564 result = (wxMenuItem *)(arg1)->PrependSeparator();
33565
33566 wxPyEndAllowThreads(__tstate);
33567 if (PyErr_Occurred()) SWIG_fail;
33568 }
33569 {
33570 resultobj = wxPyMake_wxObject(result, 0);
33571 }
33572 return resultobj;
33573 fail:
33574 return NULL;
33575 }
33576
33577
33578 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33579 PyObject *resultobj;
33580 wxMenu *arg1 = (wxMenu *) 0 ;
33581 int arg2 ;
33582 wxString *arg3 = 0 ;
33583 wxString const &arg4_defvalue = wxPyEmptyString ;
33584 wxString *arg4 = (wxString *) &arg4_defvalue ;
33585 wxMenuItem *result;
33586 bool temp3 = false ;
33587 bool temp4 = false ;
33588 PyObject * obj0 = 0 ;
33589 PyObject * obj1 = 0 ;
33590 PyObject * obj2 = 0 ;
33591 PyObject * obj3 = 0 ;
33592 char *kwnames[] = {
33593 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33594 };
33595
33596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33598 if (SWIG_arg_fail(1)) SWIG_fail;
33599 {
33600 arg2 = (int)(SWIG_As_int(obj1));
33601 if (SWIG_arg_fail(2)) SWIG_fail;
33602 }
33603 {
33604 arg3 = wxString_in_helper(obj2);
33605 if (arg3 == NULL) SWIG_fail;
33606 temp3 = true;
33607 }
33608 if (obj3) {
33609 {
33610 arg4 = wxString_in_helper(obj3);
33611 if (arg4 == NULL) SWIG_fail;
33612 temp4 = true;
33613 }
33614 }
33615 {
33616 PyThreadState* __tstate = wxPyBeginAllowThreads();
33617 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33618
33619 wxPyEndAllowThreads(__tstate);
33620 if (PyErr_Occurred()) SWIG_fail;
33621 }
33622 {
33623 resultobj = wxPyMake_wxObject(result, 0);
33624 }
33625 {
33626 if (temp3)
33627 delete arg3;
33628 }
33629 {
33630 if (temp4)
33631 delete arg4;
33632 }
33633 return resultobj;
33634 fail:
33635 {
33636 if (temp3)
33637 delete arg3;
33638 }
33639 {
33640 if (temp4)
33641 delete arg4;
33642 }
33643 return NULL;
33644 }
33645
33646
33647 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33648 PyObject *resultobj;
33649 wxMenu *arg1 = (wxMenu *) 0 ;
33650 int arg2 ;
33651 wxString *arg3 = 0 ;
33652 wxString const &arg4_defvalue = wxPyEmptyString ;
33653 wxString *arg4 = (wxString *) &arg4_defvalue ;
33654 wxMenuItem *result;
33655 bool temp3 = false ;
33656 bool temp4 = false ;
33657 PyObject * obj0 = 0 ;
33658 PyObject * obj1 = 0 ;
33659 PyObject * obj2 = 0 ;
33660 PyObject * obj3 = 0 ;
33661 char *kwnames[] = {
33662 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33663 };
33664
33665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33667 if (SWIG_arg_fail(1)) SWIG_fail;
33668 {
33669 arg2 = (int)(SWIG_As_int(obj1));
33670 if (SWIG_arg_fail(2)) SWIG_fail;
33671 }
33672 {
33673 arg3 = wxString_in_helper(obj2);
33674 if (arg3 == NULL) SWIG_fail;
33675 temp3 = true;
33676 }
33677 if (obj3) {
33678 {
33679 arg4 = wxString_in_helper(obj3);
33680 if (arg4 == NULL) SWIG_fail;
33681 temp4 = true;
33682 }
33683 }
33684 {
33685 PyThreadState* __tstate = wxPyBeginAllowThreads();
33686 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33687
33688 wxPyEndAllowThreads(__tstate);
33689 if (PyErr_Occurred()) SWIG_fail;
33690 }
33691 {
33692 resultobj = wxPyMake_wxObject(result, 0);
33693 }
33694 {
33695 if (temp3)
33696 delete arg3;
33697 }
33698 {
33699 if (temp4)
33700 delete arg4;
33701 }
33702 return resultobj;
33703 fail:
33704 {
33705 if (temp3)
33706 delete arg3;
33707 }
33708 {
33709 if (temp4)
33710 delete arg4;
33711 }
33712 return NULL;
33713 }
33714
33715
33716 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33717 PyObject *resultobj;
33718 wxMenu *arg1 = (wxMenu *) 0 ;
33719 int arg2 ;
33720 wxString *arg3 = 0 ;
33721 wxMenu *arg4 = (wxMenu *) 0 ;
33722 wxString const &arg5_defvalue = wxPyEmptyString ;
33723 wxString *arg5 = (wxString *) &arg5_defvalue ;
33724 wxMenuItem *result;
33725 bool temp3 = false ;
33726 bool temp5 = false ;
33727 PyObject * obj0 = 0 ;
33728 PyObject * obj1 = 0 ;
33729 PyObject * obj2 = 0 ;
33730 PyObject * obj3 = 0 ;
33731 PyObject * obj4 = 0 ;
33732 char *kwnames[] = {
33733 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33734 };
33735
33736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33738 if (SWIG_arg_fail(1)) SWIG_fail;
33739 {
33740 arg2 = (int)(SWIG_As_int(obj1));
33741 if (SWIG_arg_fail(2)) SWIG_fail;
33742 }
33743 {
33744 arg3 = wxString_in_helper(obj2);
33745 if (arg3 == NULL) SWIG_fail;
33746 temp3 = true;
33747 }
33748 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33749 if (SWIG_arg_fail(4)) SWIG_fail;
33750 if (obj4) {
33751 {
33752 arg5 = wxString_in_helper(obj4);
33753 if (arg5 == NULL) SWIG_fail;
33754 temp5 = true;
33755 }
33756 }
33757 {
33758 PyThreadState* __tstate = wxPyBeginAllowThreads();
33759 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33760
33761 wxPyEndAllowThreads(__tstate);
33762 if (PyErr_Occurred()) SWIG_fail;
33763 }
33764 {
33765 resultobj = wxPyMake_wxObject(result, 0);
33766 }
33767 {
33768 if (temp3)
33769 delete arg3;
33770 }
33771 {
33772 if (temp5)
33773 delete arg5;
33774 }
33775 return resultobj;
33776 fail:
33777 {
33778 if (temp3)
33779 delete arg3;
33780 }
33781 {
33782 if (temp5)
33783 delete arg5;
33784 }
33785 return NULL;
33786 }
33787
33788
33789 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33790 PyObject *resultobj;
33791 wxMenu *arg1 = (wxMenu *) 0 ;
33792 int arg2 ;
33793 wxMenuItem *result;
33794 PyObject * obj0 = 0 ;
33795 PyObject * obj1 = 0 ;
33796 char *kwnames[] = {
33797 (char *) "self",(char *) "id", NULL
33798 };
33799
33800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33802 if (SWIG_arg_fail(1)) SWIG_fail;
33803 {
33804 arg2 = (int)(SWIG_As_int(obj1));
33805 if (SWIG_arg_fail(2)) SWIG_fail;
33806 }
33807 {
33808 PyThreadState* __tstate = wxPyBeginAllowThreads();
33809 result = (wxMenuItem *)(arg1)->Remove(arg2);
33810
33811 wxPyEndAllowThreads(__tstate);
33812 if (PyErr_Occurred()) SWIG_fail;
33813 }
33814 {
33815 resultobj = wxPyMake_wxObject(result, 0);
33816 }
33817 return resultobj;
33818 fail:
33819 return NULL;
33820 }
33821
33822
33823 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33824 PyObject *resultobj;
33825 wxMenu *arg1 = (wxMenu *) 0 ;
33826 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33827 wxMenuItem *result;
33828 PyObject * obj0 = 0 ;
33829 PyObject * obj1 = 0 ;
33830 char *kwnames[] = {
33831 (char *) "self",(char *) "item", NULL
33832 };
33833
33834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33836 if (SWIG_arg_fail(1)) SWIG_fail;
33837 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33838 if (SWIG_arg_fail(2)) SWIG_fail;
33839 {
33840 PyThreadState* __tstate = wxPyBeginAllowThreads();
33841 result = (wxMenuItem *)(arg1)->Remove(arg2);
33842
33843 wxPyEndAllowThreads(__tstate);
33844 if (PyErr_Occurred()) SWIG_fail;
33845 }
33846 {
33847 resultobj = wxPyMake_wxObject(result, 0);
33848 }
33849 return resultobj;
33850 fail:
33851 return NULL;
33852 }
33853
33854
33855 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33856 PyObject *resultobj;
33857 wxMenu *arg1 = (wxMenu *) 0 ;
33858 int arg2 ;
33859 bool result;
33860 PyObject * obj0 = 0 ;
33861 PyObject * obj1 = 0 ;
33862 char *kwnames[] = {
33863 (char *) "self",(char *) "id", NULL
33864 };
33865
33866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33868 if (SWIG_arg_fail(1)) SWIG_fail;
33869 {
33870 arg2 = (int)(SWIG_As_int(obj1));
33871 if (SWIG_arg_fail(2)) SWIG_fail;
33872 }
33873 {
33874 PyThreadState* __tstate = wxPyBeginAllowThreads();
33875 result = (bool)(arg1)->Delete(arg2);
33876
33877 wxPyEndAllowThreads(__tstate);
33878 if (PyErr_Occurred()) SWIG_fail;
33879 }
33880 {
33881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33882 }
33883 return resultobj;
33884 fail:
33885 return NULL;
33886 }
33887
33888
33889 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33890 PyObject *resultobj;
33891 wxMenu *arg1 = (wxMenu *) 0 ;
33892 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33893 bool result;
33894 PyObject * obj0 = 0 ;
33895 PyObject * obj1 = 0 ;
33896 char *kwnames[] = {
33897 (char *) "self",(char *) "item", NULL
33898 };
33899
33900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33902 if (SWIG_arg_fail(1)) SWIG_fail;
33903 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33904 if (SWIG_arg_fail(2)) SWIG_fail;
33905 {
33906 PyThreadState* __tstate = wxPyBeginAllowThreads();
33907 result = (bool)(arg1)->Delete(arg2);
33908
33909 wxPyEndAllowThreads(__tstate);
33910 if (PyErr_Occurred()) SWIG_fail;
33911 }
33912 {
33913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33914 }
33915 return resultobj;
33916 fail:
33917 return NULL;
33918 }
33919
33920
33921 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33922 PyObject *resultobj;
33923 wxMenu *arg1 = (wxMenu *) 0 ;
33924 PyObject * obj0 = 0 ;
33925 char *kwnames[] = {
33926 (char *) "self", NULL
33927 };
33928
33929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33931 if (SWIG_arg_fail(1)) SWIG_fail;
33932 {
33933 PyThreadState* __tstate = wxPyBeginAllowThreads();
33934 wxMenu_Destroy(arg1);
33935
33936 wxPyEndAllowThreads(__tstate);
33937 if (PyErr_Occurred()) SWIG_fail;
33938 }
33939 Py_INCREF(Py_None); resultobj = Py_None;
33940 return resultobj;
33941 fail:
33942 return NULL;
33943 }
33944
33945
33946 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33947 PyObject *resultobj;
33948 wxMenu *arg1 = (wxMenu *) 0 ;
33949 int arg2 ;
33950 bool result;
33951 PyObject * obj0 = 0 ;
33952 PyObject * obj1 = 0 ;
33953 char *kwnames[] = {
33954 (char *) "self",(char *) "id", NULL
33955 };
33956
33957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33959 if (SWIG_arg_fail(1)) SWIG_fail;
33960 {
33961 arg2 = (int)(SWIG_As_int(obj1));
33962 if (SWIG_arg_fail(2)) SWIG_fail;
33963 }
33964 {
33965 PyThreadState* __tstate = wxPyBeginAllowThreads();
33966 result = (bool)(arg1)->Destroy(arg2);
33967
33968 wxPyEndAllowThreads(__tstate);
33969 if (PyErr_Occurred()) SWIG_fail;
33970 }
33971 {
33972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33973 }
33974 return resultobj;
33975 fail:
33976 return NULL;
33977 }
33978
33979
33980 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33981 PyObject *resultobj;
33982 wxMenu *arg1 = (wxMenu *) 0 ;
33983 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33984 bool result;
33985 PyObject * obj0 = 0 ;
33986 PyObject * obj1 = 0 ;
33987 char *kwnames[] = {
33988 (char *) "self",(char *) "item", NULL
33989 };
33990
33991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33993 if (SWIG_arg_fail(1)) SWIG_fail;
33994 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33995 if (SWIG_arg_fail(2)) SWIG_fail;
33996 {
33997 PyThreadState* __tstate = wxPyBeginAllowThreads();
33998 result = (bool)(arg1)->Destroy(arg2);
33999
34000 wxPyEndAllowThreads(__tstate);
34001 if (PyErr_Occurred()) SWIG_fail;
34002 }
34003 {
34004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34005 }
34006 return resultobj;
34007 fail:
34008 return NULL;
34009 }
34010
34011
34012 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34013 PyObject *resultobj;
34014 wxMenu *arg1 = (wxMenu *) 0 ;
34015 size_t result;
34016 PyObject * obj0 = 0 ;
34017 char *kwnames[] = {
34018 (char *) "self", NULL
34019 };
34020
34021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34023 if (SWIG_arg_fail(1)) SWIG_fail;
34024 {
34025 PyThreadState* __tstate = wxPyBeginAllowThreads();
34026 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34027
34028 wxPyEndAllowThreads(__tstate);
34029 if (PyErr_Occurred()) SWIG_fail;
34030 }
34031 {
34032 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34033 }
34034 return resultobj;
34035 fail:
34036 return NULL;
34037 }
34038
34039
34040 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34041 PyObject *resultobj;
34042 wxMenu *arg1 = (wxMenu *) 0 ;
34043 PyObject *result;
34044 PyObject * obj0 = 0 ;
34045 char *kwnames[] = {
34046 (char *) "self", NULL
34047 };
34048
34049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34051 if (SWIG_arg_fail(1)) SWIG_fail;
34052 {
34053 PyThreadState* __tstate = wxPyBeginAllowThreads();
34054 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34055
34056 wxPyEndAllowThreads(__tstate);
34057 if (PyErr_Occurred()) SWIG_fail;
34058 }
34059 resultobj = result;
34060 return resultobj;
34061 fail:
34062 return NULL;
34063 }
34064
34065
34066 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34067 PyObject *resultobj;
34068 wxMenu *arg1 = (wxMenu *) 0 ;
34069 wxString *arg2 = 0 ;
34070 int result;
34071 bool temp2 = false ;
34072 PyObject * obj0 = 0 ;
34073 PyObject * obj1 = 0 ;
34074 char *kwnames[] = {
34075 (char *) "self",(char *) "item", NULL
34076 };
34077
34078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34080 if (SWIG_arg_fail(1)) SWIG_fail;
34081 {
34082 arg2 = wxString_in_helper(obj1);
34083 if (arg2 == NULL) SWIG_fail;
34084 temp2 = true;
34085 }
34086 {
34087 PyThreadState* __tstate = wxPyBeginAllowThreads();
34088 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34089
34090 wxPyEndAllowThreads(__tstate);
34091 if (PyErr_Occurred()) SWIG_fail;
34092 }
34093 {
34094 resultobj = SWIG_From_int((int)(result));
34095 }
34096 {
34097 if (temp2)
34098 delete arg2;
34099 }
34100 return resultobj;
34101 fail:
34102 {
34103 if (temp2)
34104 delete arg2;
34105 }
34106 return NULL;
34107 }
34108
34109
34110 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34111 PyObject *resultobj;
34112 wxMenu *arg1 = (wxMenu *) 0 ;
34113 int arg2 ;
34114 wxMenuItem *result;
34115 PyObject * obj0 = 0 ;
34116 PyObject * obj1 = 0 ;
34117 char *kwnames[] = {
34118 (char *) "self",(char *) "id", NULL
34119 };
34120
34121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34123 if (SWIG_arg_fail(1)) SWIG_fail;
34124 {
34125 arg2 = (int)(SWIG_As_int(obj1));
34126 if (SWIG_arg_fail(2)) SWIG_fail;
34127 }
34128 {
34129 PyThreadState* __tstate = wxPyBeginAllowThreads();
34130 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34131
34132 wxPyEndAllowThreads(__tstate);
34133 if (PyErr_Occurred()) SWIG_fail;
34134 }
34135 {
34136 resultobj = wxPyMake_wxObject(result, 0);
34137 }
34138 return resultobj;
34139 fail:
34140 return NULL;
34141 }
34142
34143
34144 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34145 PyObject *resultobj;
34146 wxMenu *arg1 = (wxMenu *) 0 ;
34147 size_t arg2 ;
34148 wxMenuItem *result;
34149 PyObject * obj0 = 0 ;
34150 PyObject * obj1 = 0 ;
34151 char *kwnames[] = {
34152 (char *) "self",(char *) "position", NULL
34153 };
34154
34155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) 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 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34160 if (SWIG_arg_fail(2)) SWIG_fail;
34161 }
34162 {
34163 PyThreadState* __tstate = wxPyBeginAllowThreads();
34164 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34165
34166 wxPyEndAllowThreads(__tstate);
34167 if (PyErr_Occurred()) SWIG_fail;
34168 }
34169 {
34170 resultobj = wxPyMake_wxObject(result, 0);
34171 }
34172 return resultobj;
34173 fail:
34174 return NULL;
34175 }
34176
34177
34178 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34179 PyObject *resultobj;
34180 wxMenu *arg1 = (wxMenu *) 0 ;
34181 int arg2 ;
34182 bool arg3 ;
34183 PyObject * obj0 = 0 ;
34184 PyObject * obj1 = 0 ;
34185 PyObject * obj2 = 0 ;
34186 char *kwnames[] = {
34187 (char *) "self",(char *) "id",(char *) "enable", NULL
34188 };
34189
34190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34192 if (SWIG_arg_fail(1)) SWIG_fail;
34193 {
34194 arg2 = (int)(SWIG_As_int(obj1));
34195 if (SWIG_arg_fail(2)) SWIG_fail;
34196 }
34197 {
34198 arg3 = (bool)(SWIG_As_bool(obj2));
34199 if (SWIG_arg_fail(3)) SWIG_fail;
34200 }
34201 {
34202 PyThreadState* __tstate = wxPyBeginAllowThreads();
34203 (arg1)->Enable(arg2,arg3);
34204
34205 wxPyEndAllowThreads(__tstate);
34206 if (PyErr_Occurred()) SWIG_fail;
34207 }
34208 Py_INCREF(Py_None); resultobj = Py_None;
34209 return resultobj;
34210 fail:
34211 return NULL;
34212 }
34213
34214
34215 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34216 PyObject *resultobj;
34217 wxMenu *arg1 = (wxMenu *) 0 ;
34218 int arg2 ;
34219 bool result;
34220 PyObject * obj0 = 0 ;
34221 PyObject * obj1 = 0 ;
34222 char *kwnames[] = {
34223 (char *) "self",(char *) "id", NULL
34224 };
34225
34226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34228 if (SWIG_arg_fail(1)) SWIG_fail;
34229 {
34230 arg2 = (int)(SWIG_As_int(obj1));
34231 if (SWIG_arg_fail(2)) SWIG_fail;
34232 }
34233 {
34234 PyThreadState* __tstate = wxPyBeginAllowThreads();
34235 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34236
34237 wxPyEndAllowThreads(__tstate);
34238 if (PyErr_Occurred()) SWIG_fail;
34239 }
34240 {
34241 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34242 }
34243 return resultobj;
34244 fail:
34245 return NULL;
34246 }
34247
34248
34249 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34250 PyObject *resultobj;
34251 wxMenu *arg1 = (wxMenu *) 0 ;
34252 int arg2 ;
34253 bool arg3 ;
34254 PyObject * obj0 = 0 ;
34255 PyObject * obj1 = 0 ;
34256 PyObject * obj2 = 0 ;
34257 char *kwnames[] = {
34258 (char *) "self",(char *) "id",(char *) "check", NULL
34259 };
34260
34261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34263 if (SWIG_arg_fail(1)) SWIG_fail;
34264 {
34265 arg2 = (int)(SWIG_As_int(obj1));
34266 if (SWIG_arg_fail(2)) SWIG_fail;
34267 }
34268 {
34269 arg3 = (bool)(SWIG_As_bool(obj2));
34270 if (SWIG_arg_fail(3)) SWIG_fail;
34271 }
34272 {
34273 PyThreadState* __tstate = wxPyBeginAllowThreads();
34274 (arg1)->Check(arg2,arg3);
34275
34276 wxPyEndAllowThreads(__tstate);
34277 if (PyErr_Occurred()) SWIG_fail;
34278 }
34279 Py_INCREF(Py_None); resultobj = Py_None;
34280 return resultobj;
34281 fail:
34282 return NULL;
34283 }
34284
34285
34286 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34287 PyObject *resultobj;
34288 wxMenu *arg1 = (wxMenu *) 0 ;
34289 int arg2 ;
34290 bool result;
34291 PyObject * obj0 = 0 ;
34292 PyObject * obj1 = 0 ;
34293 char *kwnames[] = {
34294 (char *) "self",(char *) "id", NULL
34295 };
34296
34297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34299 if (SWIG_arg_fail(1)) SWIG_fail;
34300 {
34301 arg2 = (int)(SWIG_As_int(obj1));
34302 if (SWIG_arg_fail(2)) SWIG_fail;
34303 }
34304 {
34305 PyThreadState* __tstate = wxPyBeginAllowThreads();
34306 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34307
34308 wxPyEndAllowThreads(__tstate);
34309 if (PyErr_Occurred()) SWIG_fail;
34310 }
34311 {
34312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34313 }
34314 return resultobj;
34315 fail:
34316 return NULL;
34317 }
34318
34319
34320 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34321 PyObject *resultobj;
34322 wxMenu *arg1 = (wxMenu *) 0 ;
34323 int arg2 ;
34324 wxString *arg3 = 0 ;
34325 bool temp3 = false ;
34326 PyObject * obj0 = 0 ;
34327 PyObject * obj1 = 0 ;
34328 PyObject * obj2 = 0 ;
34329 char *kwnames[] = {
34330 (char *) "self",(char *) "id",(char *) "label", NULL
34331 };
34332
34333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34335 if (SWIG_arg_fail(1)) SWIG_fail;
34336 {
34337 arg2 = (int)(SWIG_As_int(obj1));
34338 if (SWIG_arg_fail(2)) SWIG_fail;
34339 }
34340 {
34341 arg3 = wxString_in_helper(obj2);
34342 if (arg3 == NULL) SWIG_fail;
34343 temp3 = true;
34344 }
34345 {
34346 PyThreadState* __tstate = wxPyBeginAllowThreads();
34347 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34348
34349 wxPyEndAllowThreads(__tstate);
34350 if (PyErr_Occurred()) SWIG_fail;
34351 }
34352 Py_INCREF(Py_None); resultobj = Py_None;
34353 {
34354 if (temp3)
34355 delete arg3;
34356 }
34357 return resultobj;
34358 fail:
34359 {
34360 if (temp3)
34361 delete arg3;
34362 }
34363 return NULL;
34364 }
34365
34366
34367 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34368 PyObject *resultobj;
34369 wxMenu *arg1 = (wxMenu *) 0 ;
34370 int arg2 ;
34371 wxString result;
34372 PyObject * obj0 = 0 ;
34373 PyObject * obj1 = 0 ;
34374 char *kwnames[] = {
34375 (char *) "self",(char *) "id", NULL
34376 };
34377
34378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34380 if (SWIG_arg_fail(1)) SWIG_fail;
34381 {
34382 arg2 = (int)(SWIG_As_int(obj1));
34383 if (SWIG_arg_fail(2)) SWIG_fail;
34384 }
34385 {
34386 PyThreadState* __tstate = wxPyBeginAllowThreads();
34387 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34388
34389 wxPyEndAllowThreads(__tstate);
34390 if (PyErr_Occurred()) SWIG_fail;
34391 }
34392 {
34393 #if wxUSE_UNICODE
34394 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34395 #else
34396 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34397 #endif
34398 }
34399 return resultobj;
34400 fail:
34401 return NULL;
34402 }
34403
34404
34405 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34406 PyObject *resultobj;
34407 wxMenu *arg1 = (wxMenu *) 0 ;
34408 int arg2 ;
34409 wxString *arg3 = 0 ;
34410 bool temp3 = false ;
34411 PyObject * obj0 = 0 ;
34412 PyObject * obj1 = 0 ;
34413 PyObject * obj2 = 0 ;
34414 char *kwnames[] = {
34415 (char *) "self",(char *) "id",(char *) "helpString", NULL
34416 };
34417
34418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34420 if (SWIG_arg_fail(1)) SWIG_fail;
34421 {
34422 arg2 = (int)(SWIG_As_int(obj1));
34423 if (SWIG_arg_fail(2)) SWIG_fail;
34424 }
34425 {
34426 arg3 = wxString_in_helper(obj2);
34427 if (arg3 == NULL) SWIG_fail;
34428 temp3 = true;
34429 }
34430 {
34431 PyThreadState* __tstate = wxPyBeginAllowThreads();
34432 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34433
34434 wxPyEndAllowThreads(__tstate);
34435 if (PyErr_Occurred()) SWIG_fail;
34436 }
34437 Py_INCREF(Py_None); resultobj = Py_None;
34438 {
34439 if (temp3)
34440 delete arg3;
34441 }
34442 return resultobj;
34443 fail:
34444 {
34445 if (temp3)
34446 delete arg3;
34447 }
34448 return NULL;
34449 }
34450
34451
34452 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34453 PyObject *resultobj;
34454 wxMenu *arg1 = (wxMenu *) 0 ;
34455 int arg2 ;
34456 wxString result;
34457 PyObject * obj0 = 0 ;
34458 PyObject * obj1 = 0 ;
34459 char *kwnames[] = {
34460 (char *) "self",(char *) "id", NULL
34461 };
34462
34463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34465 if (SWIG_arg_fail(1)) SWIG_fail;
34466 {
34467 arg2 = (int)(SWIG_As_int(obj1));
34468 if (SWIG_arg_fail(2)) SWIG_fail;
34469 }
34470 {
34471 PyThreadState* __tstate = wxPyBeginAllowThreads();
34472 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34473
34474 wxPyEndAllowThreads(__tstate);
34475 if (PyErr_Occurred()) SWIG_fail;
34476 }
34477 {
34478 #if wxUSE_UNICODE
34479 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34480 #else
34481 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34482 #endif
34483 }
34484 return resultobj;
34485 fail:
34486 return NULL;
34487 }
34488
34489
34490 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34491 PyObject *resultobj;
34492 wxMenu *arg1 = (wxMenu *) 0 ;
34493 wxString *arg2 = 0 ;
34494 bool temp2 = false ;
34495 PyObject * obj0 = 0 ;
34496 PyObject * obj1 = 0 ;
34497 char *kwnames[] = {
34498 (char *) "self",(char *) "title", NULL
34499 };
34500
34501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34503 if (SWIG_arg_fail(1)) SWIG_fail;
34504 {
34505 arg2 = wxString_in_helper(obj1);
34506 if (arg2 == NULL) SWIG_fail;
34507 temp2 = true;
34508 }
34509 {
34510 PyThreadState* __tstate = wxPyBeginAllowThreads();
34511 (arg1)->SetTitle((wxString const &)*arg2);
34512
34513 wxPyEndAllowThreads(__tstate);
34514 if (PyErr_Occurred()) SWIG_fail;
34515 }
34516 Py_INCREF(Py_None); resultobj = Py_None;
34517 {
34518 if (temp2)
34519 delete arg2;
34520 }
34521 return resultobj;
34522 fail:
34523 {
34524 if (temp2)
34525 delete arg2;
34526 }
34527 return NULL;
34528 }
34529
34530
34531 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34532 PyObject *resultobj;
34533 wxMenu *arg1 = (wxMenu *) 0 ;
34534 wxString result;
34535 PyObject * obj0 = 0 ;
34536 char *kwnames[] = {
34537 (char *) "self", NULL
34538 };
34539
34540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34542 if (SWIG_arg_fail(1)) SWIG_fail;
34543 {
34544 PyThreadState* __tstate = wxPyBeginAllowThreads();
34545 result = ((wxMenu const *)arg1)->GetTitle();
34546
34547 wxPyEndAllowThreads(__tstate);
34548 if (PyErr_Occurred()) SWIG_fail;
34549 }
34550 {
34551 #if wxUSE_UNICODE
34552 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34553 #else
34554 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34555 #endif
34556 }
34557 return resultobj;
34558 fail:
34559 return NULL;
34560 }
34561
34562
34563 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34564 PyObject *resultobj;
34565 wxMenu *arg1 = (wxMenu *) 0 ;
34566 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34567 PyObject * obj0 = 0 ;
34568 PyObject * obj1 = 0 ;
34569 char *kwnames[] = {
34570 (char *) "self",(char *) "handler", NULL
34571 };
34572
34573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34575 if (SWIG_arg_fail(1)) SWIG_fail;
34576 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34577 if (SWIG_arg_fail(2)) SWIG_fail;
34578 {
34579 PyThreadState* __tstate = wxPyBeginAllowThreads();
34580 (arg1)->SetEventHandler(arg2);
34581
34582 wxPyEndAllowThreads(__tstate);
34583 if (PyErr_Occurred()) SWIG_fail;
34584 }
34585 Py_INCREF(Py_None); resultobj = Py_None;
34586 return resultobj;
34587 fail:
34588 return NULL;
34589 }
34590
34591
34592 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34593 PyObject *resultobj;
34594 wxMenu *arg1 = (wxMenu *) 0 ;
34595 wxEvtHandler *result;
34596 PyObject * obj0 = 0 ;
34597 char *kwnames[] = {
34598 (char *) "self", NULL
34599 };
34600
34601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34603 if (SWIG_arg_fail(1)) SWIG_fail;
34604 {
34605 PyThreadState* __tstate = wxPyBeginAllowThreads();
34606 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34607
34608 wxPyEndAllowThreads(__tstate);
34609 if (PyErr_Occurred()) SWIG_fail;
34610 }
34611 {
34612 resultobj = wxPyMake_wxObject(result, 0);
34613 }
34614 return resultobj;
34615 fail:
34616 return NULL;
34617 }
34618
34619
34620 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34621 PyObject *resultobj;
34622 wxMenu *arg1 = (wxMenu *) 0 ;
34623 wxWindow *arg2 = (wxWindow *) 0 ;
34624 PyObject * obj0 = 0 ;
34625 PyObject * obj1 = 0 ;
34626 char *kwnames[] = {
34627 (char *) "self",(char *) "win", NULL
34628 };
34629
34630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34632 if (SWIG_arg_fail(1)) SWIG_fail;
34633 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34634 if (SWIG_arg_fail(2)) SWIG_fail;
34635 {
34636 PyThreadState* __tstate = wxPyBeginAllowThreads();
34637 (arg1)->SetInvokingWindow(arg2);
34638
34639 wxPyEndAllowThreads(__tstate);
34640 if (PyErr_Occurred()) SWIG_fail;
34641 }
34642 Py_INCREF(Py_None); resultobj = Py_None;
34643 return resultobj;
34644 fail:
34645 return NULL;
34646 }
34647
34648
34649 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34650 PyObject *resultobj;
34651 wxMenu *arg1 = (wxMenu *) 0 ;
34652 wxWindow *result;
34653 PyObject * obj0 = 0 ;
34654 char *kwnames[] = {
34655 (char *) "self", NULL
34656 };
34657
34658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34660 if (SWIG_arg_fail(1)) SWIG_fail;
34661 {
34662 PyThreadState* __tstate = wxPyBeginAllowThreads();
34663 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34664
34665 wxPyEndAllowThreads(__tstate);
34666 if (PyErr_Occurred()) SWIG_fail;
34667 }
34668 {
34669 resultobj = wxPyMake_wxObject(result, 0);
34670 }
34671 return resultobj;
34672 fail:
34673 return NULL;
34674 }
34675
34676
34677 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34678 PyObject *resultobj;
34679 wxMenu *arg1 = (wxMenu *) 0 ;
34680 long result;
34681 PyObject * obj0 = 0 ;
34682 char *kwnames[] = {
34683 (char *) "self", NULL
34684 };
34685
34686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34688 if (SWIG_arg_fail(1)) SWIG_fail;
34689 {
34690 PyThreadState* __tstate = wxPyBeginAllowThreads();
34691 result = (long)((wxMenu const *)arg1)->GetStyle();
34692
34693 wxPyEndAllowThreads(__tstate);
34694 if (PyErr_Occurred()) SWIG_fail;
34695 }
34696 {
34697 resultobj = SWIG_From_long((long)(result));
34698 }
34699 return resultobj;
34700 fail:
34701 return NULL;
34702 }
34703
34704
34705 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34706 PyObject *resultobj;
34707 wxMenu *arg1 = (wxMenu *) 0 ;
34708 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34709 PyObject * obj0 = 0 ;
34710 PyObject * obj1 = 0 ;
34711 char *kwnames[] = {
34712 (char *) "self",(char *) "source", NULL
34713 };
34714
34715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34717 if (SWIG_arg_fail(1)) SWIG_fail;
34718 if (obj1) {
34719 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34720 if (SWIG_arg_fail(2)) SWIG_fail;
34721 }
34722 {
34723 PyThreadState* __tstate = wxPyBeginAllowThreads();
34724 (arg1)->UpdateUI(arg2);
34725
34726 wxPyEndAllowThreads(__tstate);
34727 if (PyErr_Occurred()) SWIG_fail;
34728 }
34729 Py_INCREF(Py_None); resultobj = Py_None;
34730 return resultobj;
34731 fail:
34732 return NULL;
34733 }
34734
34735
34736 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34737 PyObject *resultobj;
34738 wxMenu *arg1 = (wxMenu *) 0 ;
34739 wxMenuBar *result;
34740 PyObject * obj0 = 0 ;
34741 char *kwnames[] = {
34742 (char *) "self", NULL
34743 };
34744
34745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34747 if (SWIG_arg_fail(1)) SWIG_fail;
34748 {
34749 PyThreadState* __tstate = wxPyBeginAllowThreads();
34750 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34751
34752 wxPyEndAllowThreads(__tstate);
34753 if (PyErr_Occurred()) SWIG_fail;
34754 }
34755 {
34756 resultobj = wxPyMake_wxObject(result, 0);
34757 }
34758 return resultobj;
34759 fail:
34760 return NULL;
34761 }
34762
34763
34764 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34765 PyObject *resultobj;
34766 wxMenu *arg1 = (wxMenu *) 0 ;
34767 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34768 PyObject * obj0 = 0 ;
34769 PyObject * obj1 = 0 ;
34770 char *kwnames[] = {
34771 (char *) "self",(char *) "menubar", NULL
34772 };
34773
34774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34776 if (SWIG_arg_fail(1)) SWIG_fail;
34777 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34778 if (SWIG_arg_fail(2)) SWIG_fail;
34779 {
34780 PyThreadState* __tstate = wxPyBeginAllowThreads();
34781 (arg1)->Attach(arg2);
34782
34783 wxPyEndAllowThreads(__tstate);
34784 if (PyErr_Occurred()) SWIG_fail;
34785 }
34786 Py_INCREF(Py_None); resultobj = Py_None;
34787 return resultobj;
34788 fail:
34789 return NULL;
34790 }
34791
34792
34793 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34794 PyObject *resultobj;
34795 wxMenu *arg1 = (wxMenu *) 0 ;
34796 PyObject * obj0 = 0 ;
34797 char *kwnames[] = {
34798 (char *) "self", NULL
34799 };
34800
34801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34803 if (SWIG_arg_fail(1)) SWIG_fail;
34804 {
34805 PyThreadState* __tstate = wxPyBeginAllowThreads();
34806 (arg1)->Detach();
34807
34808 wxPyEndAllowThreads(__tstate);
34809 if (PyErr_Occurred()) SWIG_fail;
34810 }
34811 Py_INCREF(Py_None); resultobj = Py_None;
34812 return resultobj;
34813 fail:
34814 return NULL;
34815 }
34816
34817
34818 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34819 PyObject *resultobj;
34820 wxMenu *arg1 = (wxMenu *) 0 ;
34821 bool result;
34822 PyObject * obj0 = 0 ;
34823 char *kwnames[] = {
34824 (char *) "self", NULL
34825 };
34826
34827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34829 if (SWIG_arg_fail(1)) SWIG_fail;
34830 {
34831 PyThreadState* __tstate = wxPyBeginAllowThreads();
34832 result = (bool)((wxMenu const *)arg1)->IsAttached();
34833
34834 wxPyEndAllowThreads(__tstate);
34835 if (PyErr_Occurred()) SWIG_fail;
34836 }
34837 {
34838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34839 }
34840 return resultobj;
34841 fail:
34842 return NULL;
34843 }
34844
34845
34846 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34847 PyObject *resultobj;
34848 wxMenu *arg1 = (wxMenu *) 0 ;
34849 wxMenu *arg2 = (wxMenu *) 0 ;
34850 PyObject * obj0 = 0 ;
34851 PyObject * obj1 = 0 ;
34852 char *kwnames[] = {
34853 (char *) "self",(char *) "parent", NULL
34854 };
34855
34856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34858 if (SWIG_arg_fail(1)) SWIG_fail;
34859 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34860 if (SWIG_arg_fail(2)) SWIG_fail;
34861 {
34862 PyThreadState* __tstate = wxPyBeginAllowThreads();
34863 (arg1)->SetParent(arg2);
34864
34865 wxPyEndAllowThreads(__tstate);
34866 if (PyErr_Occurred()) SWIG_fail;
34867 }
34868 Py_INCREF(Py_None); resultobj = Py_None;
34869 return resultobj;
34870 fail:
34871 return NULL;
34872 }
34873
34874
34875 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34876 PyObject *resultobj;
34877 wxMenu *arg1 = (wxMenu *) 0 ;
34878 wxMenu *result;
34879 PyObject * obj0 = 0 ;
34880 char *kwnames[] = {
34881 (char *) "self", NULL
34882 };
34883
34884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34886 if (SWIG_arg_fail(1)) SWIG_fail;
34887 {
34888 PyThreadState* __tstate = wxPyBeginAllowThreads();
34889 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34890
34891 wxPyEndAllowThreads(__tstate);
34892 if (PyErr_Occurred()) SWIG_fail;
34893 }
34894 {
34895 resultobj = wxPyMake_wxObject(result, 0);
34896 }
34897 return resultobj;
34898 fail:
34899 return NULL;
34900 }
34901
34902
34903 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34904 PyObject *obj;
34905 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34906 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34907 Py_INCREF(obj);
34908 return Py_BuildValue((char *)"");
34909 }
34910 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34911 PyObject *resultobj;
34912 long arg1 = (long) 0 ;
34913 wxMenuBar *result;
34914 PyObject * obj0 = 0 ;
34915 char *kwnames[] = {
34916 (char *) "style", NULL
34917 };
34918
34919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34920 if (obj0) {
34921 {
34922 arg1 = (long)(SWIG_As_long(obj0));
34923 if (SWIG_arg_fail(1)) SWIG_fail;
34924 }
34925 }
34926 {
34927 if (!wxPyCheckForApp()) SWIG_fail;
34928 PyThreadState* __tstate = wxPyBeginAllowThreads();
34929 result = (wxMenuBar *)new wxMenuBar(arg1);
34930
34931 wxPyEndAllowThreads(__tstate);
34932 if (PyErr_Occurred()) SWIG_fail;
34933 }
34934 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34935 return resultobj;
34936 fail:
34937 return NULL;
34938 }
34939
34940
34941 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34942 PyObject *resultobj;
34943 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34944 wxMenu *arg2 = (wxMenu *) 0 ;
34945 wxString *arg3 = 0 ;
34946 bool result;
34947 bool temp3 = false ;
34948 PyObject * obj0 = 0 ;
34949 PyObject * obj1 = 0 ;
34950 PyObject * obj2 = 0 ;
34951 char *kwnames[] = {
34952 (char *) "self",(char *) "menu",(char *) "title", NULL
34953 };
34954
34955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34957 if (SWIG_arg_fail(1)) SWIG_fail;
34958 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34959 if (SWIG_arg_fail(2)) SWIG_fail;
34960 {
34961 arg3 = wxString_in_helper(obj2);
34962 if (arg3 == NULL) SWIG_fail;
34963 temp3 = true;
34964 }
34965 {
34966 PyThreadState* __tstate = wxPyBeginAllowThreads();
34967 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34968
34969 wxPyEndAllowThreads(__tstate);
34970 if (PyErr_Occurred()) SWIG_fail;
34971 }
34972 {
34973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34974 }
34975 {
34976 if (temp3)
34977 delete arg3;
34978 }
34979 return resultobj;
34980 fail:
34981 {
34982 if (temp3)
34983 delete arg3;
34984 }
34985 return NULL;
34986 }
34987
34988
34989 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34990 PyObject *resultobj;
34991 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34992 size_t arg2 ;
34993 wxMenu *arg3 = (wxMenu *) 0 ;
34994 wxString *arg4 = 0 ;
34995 bool result;
34996 bool temp4 = false ;
34997 PyObject * obj0 = 0 ;
34998 PyObject * obj1 = 0 ;
34999 PyObject * obj2 = 0 ;
35000 PyObject * obj3 = 0 ;
35001 char *kwnames[] = {
35002 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35003 };
35004
35005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35007 if (SWIG_arg_fail(1)) SWIG_fail;
35008 {
35009 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35010 if (SWIG_arg_fail(2)) SWIG_fail;
35011 }
35012 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35013 if (SWIG_arg_fail(3)) SWIG_fail;
35014 {
35015 arg4 = wxString_in_helper(obj3);
35016 if (arg4 == NULL) SWIG_fail;
35017 temp4 = true;
35018 }
35019 {
35020 PyThreadState* __tstate = wxPyBeginAllowThreads();
35021 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35022
35023 wxPyEndAllowThreads(__tstate);
35024 if (PyErr_Occurred()) SWIG_fail;
35025 }
35026 {
35027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35028 }
35029 {
35030 if (temp4)
35031 delete arg4;
35032 }
35033 return resultobj;
35034 fail:
35035 {
35036 if (temp4)
35037 delete arg4;
35038 }
35039 return NULL;
35040 }
35041
35042
35043 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35044 PyObject *resultobj;
35045 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35046 size_t result;
35047 PyObject * obj0 = 0 ;
35048 char *kwnames[] = {
35049 (char *) "self", NULL
35050 };
35051
35052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35054 if (SWIG_arg_fail(1)) SWIG_fail;
35055 {
35056 PyThreadState* __tstate = wxPyBeginAllowThreads();
35057 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35058
35059 wxPyEndAllowThreads(__tstate);
35060 if (PyErr_Occurred()) SWIG_fail;
35061 }
35062 {
35063 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35064 }
35065 return resultobj;
35066 fail:
35067 return NULL;
35068 }
35069
35070
35071 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35072 PyObject *resultobj;
35073 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35074 size_t arg2 ;
35075 wxMenu *result;
35076 PyObject * obj0 = 0 ;
35077 PyObject * obj1 = 0 ;
35078 char *kwnames[] = {
35079 (char *) "self",(char *) "pos", NULL
35080 };
35081
35082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35084 if (SWIG_arg_fail(1)) SWIG_fail;
35085 {
35086 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35087 if (SWIG_arg_fail(2)) SWIG_fail;
35088 }
35089 {
35090 PyThreadState* __tstate = wxPyBeginAllowThreads();
35091 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35092
35093 wxPyEndAllowThreads(__tstate);
35094 if (PyErr_Occurred()) SWIG_fail;
35095 }
35096 {
35097 resultobj = wxPyMake_wxObject(result, 0);
35098 }
35099 return resultobj;
35100 fail:
35101 return NULL;
35102 }
35103
35104
35105 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35106 PyObject *resultobj;
35107 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35108 size_t arg2 ;
35109 wxMenu *arg3 = (wxMenu *) 0 ;
35110 wxString *arg4 = 0 ;
35111 wxMenu *result;
35112 bool temp4 = false ;
35113 PyObject * obj0 = 0 ;
35114 PyObject * obj1 = 0 ;
35115 PyObject * obj2 = 0 ;
35116 PyObject * obj3 = 0 ;
35117 char *kwnames[] = {
35118 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35119 };
35120
35121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35123 if (SWIG_arg_fail(1)) SWIG_fail;
35124 {
35125 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35126 if (SWIG_arg_fail(2)) SWIG_fail;
35127 }
35128 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35129 if (SWIG_arg_fail(3)) SWIG_fail;
35130 {
35131 arg4 = wxString_in_helper(obj3);
35132 if (arg4 == NULL) SWIG_fail;
35133 temp4 = true;
35134 }
35135 {
35136 PyThreadState* __tstate = wxPyBeginAllowThreads();
35137 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35138
35139 wxPyEndAllowThreads(__tstate);
35140 if (PyErr_Occurred()) SWIG_fail;
35141 }
35142 {
35143 resultobj = wxPyMake_wxObject(result, 0);
35144 }
35145 {
35146 if (temp4)
35147 delete arg4;
35148 }
35149 return resultobj;
35150 fail:
35151 {
35152 if (temp4)
35153 delete arg4;
35154 }
35155 return NULL;
35156 }
35157
35158
35159 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35160 PyObject *resultobj;
35161 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35162 size_t arg2 ;
35163 wxMenu *result;
35164 PyObject * obj0 = 0 ;
35165 PyObject * obj1 = 0 ;
35166 char *kwnames[] = {
35167 (char *) "self",(char *) "pos", NULL
35168 };
35169
35170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35172 if (SWIG_arg_fail(1)) SWIG_fail;
35173 {
35174 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35175 if (SWIG_arg_fail(2)) SWIG_fail;
35176 }
35177 {
35178 PyThreadState* __tstate = wxPyBeginAllowThreads();
35179 result = (wxMenu *)(arg1)->Remove(arg2);
35180
35181 wxPyEndAllowThreads(__tstate);
35182 if (PyErr_Occurred()) SWIG_fail;
35183 }
35184 {
35185 resultobj = wxPyMake_wxObject(result, 0);
35186 }
35187 return resultobj;
35188 fail:
35189 return NULL;
35190 }
35191
35192
35193 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35194 PyObject *resultobj;
35195 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35196 size_t arg2 ;
35197 bool arg3 ;
35198 PyObject * obj0 = 0 ;
35199 PyObject * obj1 = 0 ;
35200 PyObject * obj2 = 0 ;
35201 char *kwnames[] = {
35202 (char *) "self",(char *) "pos",(char *) "enable", NULL
35203 };
35204
35205 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35206 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35207 if (SWIG_arg_fail(1)) SWIG_fail;
35208 {
35209 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35210 if (SWIG_arg_fail(2)) SWIG_fail;
35211 }
35212 {
35213 arg3 = (bool)(SWIG_As_bool(obj2));
35214 if (SWIG_arg_fail(3)) SWIG_fail;
35215 }
35216 {
35217 PyThreadState* __tstate = wxPyBeginAllowThreads();
35218 (arg1)->EnableTop(arg2,arg3);
35219
35220 wxPyEndAllowThreads(__tstate);
35221 if (PyErr_Occurred()) SWIG_fail;
35222 }
35223 Py_INCREF(Py_None); resultobj = Py_None;
35224 return resultobj;
35225 fail:
35226 return NULL;
35227 }
35228
35229
35230 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35231 PyObject *resultobj;
35232 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35233 size_t arg2 ;
35234 bool result;
35235 PyObject * obj0 = 0 ;
35236 PyObject * obj1 = 0 ;
35237 char *kwnames[] = {
35238 (char *) "self",(char *) "pos", NULL
35239 };
35240
35241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35243 if (SWIG_arg_fail(1)) SWIG_fail;
35244 {
35245 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35246 if (SWIG_arg_fail(2)) SWIG_fail;
35247 }
35248 {
35249 PyThreadState* __tstate = wxPyBeginAllowThreads();
35250 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35251
35252 wxPyEndAllowThreads(__tstate);
35253 if (PyErr_Occurred()) SWIG_fail;
35254 }
35255 {
35256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35257 }
35258 return resultobj;
35259 fail:
35260 return NULL;
35261 }
35262
35263
35264 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35265 PyObject *resultobj;
35266 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35267 size_t arg2 ;
35268 wxString *arg3 = 0 ;
35269 bool temp3 = false ;
35270 PyObject * obj0 = 0 ;
35271 PyObject * obj1 = 0 ;
35272 PyObject * obj2 = 0 ;
35273 char *kwnames[] = {
35274 (char *) "self",(char *) "pos",(char *) "label", NULL
35275 };
35276
35277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35279 if (SWIG_arg_fail(1)) SWIG_fail;
35280 {
35281 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35282 if (SWIG_arg_fail(2)) SWIG_fail;
35283 }
35284 {
35285 arg3 = wxString_in_helper(obj2);
35286 if (arg3 == NULL) SWIG_fail;
35287 temp3 = true;
35288 }
35289 {
35290 PyThreadState* __tstate = wxPyBeginAllowThreads();
35291 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35292
35293 wxPyEndAllowThreads(__tstate);
35294 if (PyErr_Occurred()) SWIG_fail;
35295 }
35296 Py_INCREF(Py_None); resultobj = Py_None;
35297 {
35298 if (temp3)
35299 delete arg3;
35300 }
35301 return resultobj;
35302 fail:
35303 {
35304 if (temp3)
35305 delete arg3;
35306 }
35307 return NULL;
35308 }
35309
35310
35311 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35312 PyObject *resultobj;
35313 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35314 size_t arg2 ;
35315 wxString result;
35316 PyObject * obj0 = 0 ;
35317 PyObject * obj1 = 0 ;
35318 char *kwnames[] = {
35319 (char *) "self",(char *) "pos", NULL
35320 };
35321
35322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35324 if (SWIG_arg_fail(1)) SWIG_fail;
35325 {
35326 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35327 if (SWIG_arg_fail(2)) SWIG_fail;
35328 }
35329 {
35330 PyThreadState* __tstate = wxPyBeginAllowThreads();
35331 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35332
35333 wxPyEndAllowThreads(__tstate);
35334 if (PyErr_Occurred()) SWIG_fail;
35335 }
35336 {
35337 #if wxUSE_UNICODE
35338 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35339 #else
35340 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35341 #endif
35342 }
35343 return resultobj;
35344 fail:
35345 return NULL;
35346 }
35347
35348
35349 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35350 PyObject *resultobj;
35351 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35352 wxString *arg2 = 0 ;
35353 wxString *arg3 = 0 ;
35354 int result;
35355 bool temp2 = false ;
35356 bool temp3 = false ;
35357 PyObject * obj0 = 0 ;
35358 PyObject * obj1 = 0 ;
35359 PyObject * obj2 = 0 ;
35360 char *kwnames[] = {
35361 (char *) "self",(char *) "menu",(char *) "item", NULL
35362 };
35363
35364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35366 if (SWIG_arg_fail(1)) SWIG_fail;
35367 {
35368 arg2 = wxString_in_helper(obj1);
35369 if (arg2 == NULL) SWIG_fail;
35370 temp2 = true;
35371 }
35372 {
35373 arg3 = wxString_in_helper(obj2);
35374 if (arg3 == NULL) SWIG_fail;
35375 temp3 = true;
35376 }
35377 {
35378 PyThreadState* __tstate = wxPyBeginAllowThreads();
35379 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35380
35381 wxPyEndAllowThreads(__tstate);
35382 if (PyErr_Occurred()) SWIG_fail;
35383 }
35384 {
35385 resultobj = SWIG_From_int((int)(result));
35386 }
35387 {
35388 if (temp2)
35389 delete arg2;
35390 }
35391 {
35392 if (temp3)
35393 delete arg3;
35394 }
35395 return resultobj;
35396 fail:
35397 {
35398 if (temp2)
35399 delete arg2;
35400 }
35401 {
35402 if (temp3)
35403 delete arg3;
35404 }
35405 return NULL;
35406 }
35407
35408
35409 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35410 PyObject *resultobj;
35411 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35412 int arg2 ;
35413 wxMenuItem *result;
35414 PyObject * obj0 = 0 ;
35415 PyObject * obj1 = 0 ;
35416 char *kwnames[] = {
35417 (char *) "self",(char *) "id", NULL
35418 };
35419
35420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35422 if (SWIG_arg_fail(1)) SWIG_fail;
35423 {
35424 arg2 = (int)(SWIG_As_int(obj1));
35425 if (SWIG_arg_fail(2)) SWIG_fail;
35426 }
35427 {
35428 PyThreadState* __tstate = wxPyBeginAllowThreads();
35429 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35430
35431 wxPyEndAllowThreads(__tstate);
35432 if (PyErr_Occurred()) SWIG_fail;
35433 }
35434 {
35435 resultobj = wxPyMake_wxObject(result, 0);
35436 }
35437 return resultobj;
35438 fail:
35439 return NULL;
35440 }
35441
35442
35443 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35444 PyObject *resultobj;
35445 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35446 wxString *arg2 = 0 ;
35447 int result;
35448 bool temp2 = false ;
35449 PyObject * obj0 = 0 ;
35450 PyObject * obj1 = 0 ;
35451 char *kwnames[] = {
35452 (char *) "self",(char *) "title", NULL
35453 };
35454
35455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35457 if (SWIG_arg_fail(1)) SWIG_fail;
35458 {
35459 arg2 = wxString_in_helper(obj1);
35460 if (arg2 == NULL) SWIG_fail;
35461 temp2 = true;
35462 }
35463 {
35464 PyThreadState* __tstate = wxPyBeginAllowThreads();
35465 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
35466
35467 wxPyEndAllowThreads(__tstate);
35468 if (PyErr_Occurred()) SWIG_fail;
35469 }
35470 {
35471 resultobj = SWIG_From_int((int)(result));
35472 }
35473 {
35474 if (temp2)
35475 delete arg2;
35476 }
35477 return resultobj;
35478 fail:
35479 {
35480 if (temp2)
35481 delete arg2;
35482 }
35483 return NULL;
35484 }
35485
35486
35487 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35488 PyObject *resultobj;
35489 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35490 int arg2 ;
35491 bool arg3 ;
35492 PyObject * obj0 = 0 ;
35493 PyObject * obj1 = 0 ;
35494 PyObject * obj2 = 0 ;
35495 char *kwnames[] = {
35496 (char *) "self",(char *) "id",(char *) "enable", NULL
35497 };
35498
35499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35501 if (SWIG_arg_fail(1)) SWIG_fail;
35502 {
35503 arg2 = (int)(SWIG_As_int(obj1));
35504 if (SWIG_arg_fail(2)) SWIG_fail;
35505 }
35506 {
35507 arg3 = (bool)(SWIG_As_bool(obj2));
35508 if (SWIG_arg_fail(3)) SWIG_fail;
35509 }
35510 {
35511 PyThreadState* __tstate = wxPyBeginAllowThreads();
35512 (arg1)->Enable(arg2,arg3);
35513
35514 wxPyEndAllowThreads(__tstate);
35515 if (PyErr_Occurred()) SWIG_fail;
35516 }
35517 Py_INCREF(Py_None); resultobj = Py_None;
35518 return resultobj;
35519 fail:
35520 return NULL;
35521 }
35522
35523
35524 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35525 PyObject *resultobj;
35526 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35527 int arg2 ;
35528 bool arg3 ;
35529 PyObject * obj0 = 0 ;
35530 PyObject * obj1 = 0 ;
35531 PyObject * obj2 = 0 ;
35532 char *kwnames[] = {
35533 (char *) "self",(char *) "id",(char *) "check", NULL
35534 };
35535
35536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35538 if (SWIG_arg_fail(1)) SWIG_fail;
35539 {
35540 arg2 = (int)(SWIG_As_int(obj1));
35541 if (SWIG_arg_fail(2)) SWIG_fail;
35542 }
35543 {
35544 arg3 = (bool)(SWIG_As_bool(obj2));
35545 if (SWIG_arg_fail(3)) SWIG_fail;
35546 }
35547 {
35548 PyThreadState* __tstate = wxPyBeginAllowThreads();
35549 (arg1)->Check(arg2,arg3);
35550
35551 wxPyEndAllowThreads(__tstate);
35552 if (PyErr_Occurred()) SWIG_fail;
35553 }
35554 Py_INCREF(Py_None); resultobj = Py_None;
35555 return resultobj;
35556 fail:
35557 return NULL;
35558 }
35559
35560
35561 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35562 PyObject *resultobj;
35563 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35564 int arg2 ;
35565 bool result;
35566 PyObject * obj0 = 0 ;
35567 PyObject * obj1 = 0 ;
35568 char *kwnames[] = {
35569 (char *) "self",(char *) "id", NULL
35570 };
35571
35572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35574 if (SWIG_arg_fail(1)) SWIG_fail;
35575 {
35576 arg2 = (int)(SWIG_As_int(obj1));
35577 if (SWIG_arg_fail(2)) SWIG_fail;
35578 }
35579 {
35580 PyThreadState* __tstate = wxPyBeginAllowThreads();
35581 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35582
35583 wxPyEndAllowThreads(__tstate);
35584 if (PyErr_Occurred()) SWIG_fail;
35585 }
35586 {
35587 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35588 }
35589 return resultobj;
35590 fail:
35591 return NULL;
35592 }
35593
35594
35595 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35596 PyObject *resultobj;
35597 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35598 int arg2 ;
35599 bool result;
35600 PyObject * obj0 = 0 ;
35601 PyObject * obj1 = 0 ;
35602 char *kwnames[] = {
35603 (char *) "self",(char *) "id", NULL
35604 };
35605
35606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35608 if (SWIG_arg_fail(1)) SWIG_fail;
35609 {
35610 arg2 = (int)(SWIG_As_int(obj1));
35611 if (SWIG_arg_fail(2)) SWIG_fail;
35612 }
35613 {
35614 PyThreadState* __tstate = wxPyBeginAllowThreads();
35615 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35616
35617 wxPyEndAllowThreads(__tstate);
35618 if (PyErr_Occurred()) SWIG_fail;
35619 }
35620 {
35621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35622 }
35623 return resultobj;
35624 fail:
35625 return NULL;
35626 }
35627
35628
35629 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35630 PyObject *resultobj;
35631 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35632 int arg2 ;
35633 wxString *arg3 = 0 ;
35634 bool temp3 = false ;
35635 PyObject * obj0 = 0 ;
35636 PyObject * obj1 = 0 ;
35637 PyObject * obj2 = 0 ;
35638 char *kwnames[] = {
35639 (char *) "self",(char *) "id",(char *) "label", NULL
35640 };
35641
35642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35644 if (SWIG_arg_fail(1)) SWIG_fail;
35645 {
35646 arg2 = (int)(SWIG_As_int(obj1));
35647 if (SWIG_arg_fail(2)) SWIG_fail;
35648 }
35649 {
35650 arg3 = wxString_in_helper(obj2);
35651 if (arg3 == NULL) SWIG_fail;
35652 temp3 = true;
35653 }
35654 {
35655 PyThreadState* __tstate = wxPyBeginAllowThreads();
35656 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35657
35658 wxPyEndAllowThreads(__tstate);
35659 if (PyErr_Occurred()) SWIG_fail;
35660 }
35661 Py_INCREF(Py_None); resultobj = Py_None;
35662 {
35663 if (temp3)
35664 delete arg3;
35665 }
35666 return resultobj;
35667 fail:
35668 {
35669 if (temp3)
35670 delete arg3;
35671 }
35672 return NULL;
35673 }
35674
35675
35676 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35677 PyObject *resultobj;
35678 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35679 int arg2 ;
35680 wxString result;
35681 PyObject * obj0 = 0 ;
35682 PyObject * obj1 = 0 ;
35683 char *kwnames[] = {
35684 (char *) "self",(char *) "id", NULL
35685 };
35686
35687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35689 if (SWIG_arg_fail(1)) SWIG_fail;
35690 {
35691 arg2 = (int)(SWIG_As_int(obj1));
35692 if (SWIG_arg_fail(2)) SWIG_fail;
35693 }
35694 {
35695 PyThreadState* __tstate = wxPyBeginAllowThreads();
35696 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35697
35698 wxPyEndAllowThreads(__tstate);
35699 if (PyErr_Occurred()) SWIG_fail;
35700 }
35701 {
35702 #if wxUSE_UNICODE
35703 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35704 #else
35705 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35706 #endif
35707 }
35708 return resultobj;
35709 fail:
35710 return NULL;
35711 }
35712
35713
35714 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35715 PyObject *resultobj;
35716 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35717 int arg2 ;
35718 wxString *arg3 = 0 ;
35719 bool temp3 = false ;
35720 PyObject * obj0 = 0 ;
35721 PyObject * obj1 = 0 ;
35722 PyObject * obj2 = 0 ;
35723 char *kwnames[] = {
35724 (char *) "self",(char *) "id",(char *) "helpString", NULL
35725 };
35726
35727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35729 if (SWIG_arg_fail(1)) SWIG_fail;
35730 {
35731 arg2 = (int)(SWIG_As_int(obj1));
35732 if (SWIG_arg_fail(2)) SWIG_fail;
35733 }
35734 {
35735 arg3 = wxString_in_helper(obj2);
35736 if (arg3 == NULL) SWIG_fail;
35737 temp3 = true;
35738 }
35739 {
35740 PyThreadState* __tstate = wxPyBeginAllowThreads();
35741 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35742
35743 wxPyEndAllowThreads(__tstate);
35744 if (PyErr_Occurred()) SWIG_fail;
35745 }
35746 Py_INCREF(Py_None); resultobj = Py_None;
35747 {
35748 if (temp3)
35749 delete arg3;
35750 }
35751 return resultobj;
35752 fail:
35753 {
35754 if (temp3)
35755 delete arg3;
35756 }
35757 return NULL;
35758 }
35759
35760
35761 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35762 PyObject *resultobj;
35763 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35764 int arg2 ;
35765 wxString result;
35766 PyObject * obj0 = 0 ;
35767 PyObject * obj1 = 0 ;
35768 char *kwnames[] = {
35769 (char *) "self",(char *) "id", NULL
35770 };
35771
35772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35774 if (SWIG_arg_fail(1)) SWIG_fail;
35775 {
35776 arg2 = (int)(SWIG_As_int(obj1));
35777 if (SWIG_arg_fail(2)) SWIG_fail;
35778 }
35779 {
35780 PyThreadState* __tstate = wxPyBeginAllowThreads();
35781 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35782
35783 wxPyEndAllowThreads(__tstate);
35784 if (PyErr_Occurred()) SWIG_fail;
35785 }
35786 {
35787 #if wxUSE_UNICODE
35788 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35789 #else
35790 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35791 #endif
35792 }
35793 return resultobj;
35794 fail:
35795 return NULL;
35796 }
35797
35798
35799 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35800 PyObject *resultobj;
35801 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35802 wxFrame *result;
35803 PyObject * obj0 = 0 ;
35804 char *kwnames[] = {
35805 (char *) "self", NULL
35806 };
35807
35808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35810 if (SWIG_arg_fail(1)) SWIG_fail;
35811 {
35812 PyThreadState* __tstate = wxPyBeginAllowThreads();
35813 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35814
35815 wxPyEndAllowThreads(__tstate);
35816 if (PyErr_Occurred()) SWIG_fail;
35817 }
35818 {
35819 resultobj = wxPyMake_wxObject(result, 0);
35820 }
35821 return resultobj;
35822 fail:
35823 return NULL;
35824 }
35825
35826
35827 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35828 PyObject *resultobj;
35829 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35830 bool result;
35831 PyObject * obj0 = 0 ;
35832 char *kwnames[] = {
35833 (char *) "self", NULL
35834 };
35835
35836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35838 if (SWIG_arg_fail(1)) SWIG_fail;
35839 {
35840 PyThreadState* __tstate = wxPyBeginAllowThreads();
35841 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35842
35843 wxPyEndAllowThreads(__tstate);
35844 if (PyErr_Occurred()) SWIG_fail;
35845 }
35846 {
35847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35848 }
35849 return resultobj;
35850 fail:
35851 return NULL;
35852 }
35853
35854
35855 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35856 PyObject *resultobj;
35857 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35858 wxFrame *arg2 = (wxFrame *) 0 ;
35859 PyObject * obj0 = 0 ;
35860 PyObject * obj1 = 0 ;
35861 char *kwnames[] = {
35862 (char *) "self",(char *) "frame", NULL
35863 };
35864
35865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35867 if (SWIG_arg_fail(1)) SWIG_fail;
35868 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35869 if (SWIG_arg_fail(2)) SWIG_fail;
35870 {
35871 PyThreadState* __tstate = wxPyBeginAllowThreads();
35872 (arg1)->Attach(arg2);
35873
35874 wxPyEndAllowThreads(__tstate);
35875 if (PyErr_Occurred()) SWIG_fail;
35876 }
35877 Py_INCREF(Py_None); resultobj = Py_None;
35878 return resultobj;
35879 fail:
35880 return NULL;
35881 }
35882
35883
35884 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35885 PyObject *resultobj;
35886 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35887 PyObject * obj0 = 0 ;
35888 char *kwnames[] = {
35889 (char *) "self", NULL
35890 };
35891
35892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35894 if (SWIG_arg_fail(1)) SWIG_fail;
35895 {
35896 PyThreadState* __tstate = wxPyBeginAllowThreads();
35897 (arg1)->Detach();
35898
35899 wxPyEndAllowThreads(__tstate);
35900 if (PyErr_Occurred()) SWIG_fail;
35901 }
35902 Py_INCREF(Py_None); resultobj = Py_None;
35903 return resultobj;
35904 fail:
35905 return NULL;
35906 }
35907
35908
35909 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35910 PyObject *obj;
35911 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35912 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35913 Py_INCREF(obj);
35914 return Py_BuildValue((char *)"");
35915 }
35916 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35917 PyObject *resultobj;
35918 wxMenu *arg1 = (wxMenu *) NULL ;
35919 int arg2 = (int) wxID_ANY ;
35920 wxString const &arg3_defvalue = wxPyEmptyString ;
35921 wxString *arg3 = (wxString *) &arg3_defvalue ;
35922 wxString const &arg4_defvalue = wxPyEmptyString ;
35923 wxString *arg4 = (wxString *) &arg4_defvalue ;
35924 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35925 wxMenu *arg6 = (wxMenu *) NULL ;
35926 wxMenuItem *result;
35927 bool temp3 = false ;
35928 bool temp4 = false ;
35929 PyObject * obj0 = 0 ;
35930 PyObject * obj1 = 0 ;
35931 PyObject * obj2 = 0 ;
35932 PyObject * obj3 = 0 ;
35933 PyObject * obj4 = 0 ;
35934 PyObject * obj5 = 0 ;
35935 char *kwnames[] = {
35936 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35937 };
35938
35939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35940 if (obj0) {
35941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35942 if (SWIG_arg_fail(1)) SWIG_fail;
35943 }
35944 if (obj1) {
35945 {
35946 arg2 = (int)(SWIG_As_int(obj1));
35947 if (SWIG_arg_fail(2)) SWIG_fail;
35948 }
35949 }
35950 if (obj2) {
35951 {
35952 arg3 = wxString_in_helper(obj2);
35953 if (arg3 == NULL) SWIG_fail;
35954 temp3 = true;
35955 }
35956 }
35957 if (obj3) {
35958 {
35959 arg4 = wxString_in_helper(obj3);
35960 if (arg4 == NULL) SWIG_fail;
35961 temp4 = true;
35962 }
35963 }
35964 if (obj4) {
35965 {
35966 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35967 if (SWIG_arg_fail(5)) SWIG_fail;
35968 }
35969 }
35970 if (obj5) {
35971 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35972 if (SWIG_arg_fail(6)) SWIG_fail;
35973 }
35974 {
35975 PyThreadState* __tstate = wxPyBeginAllowThreads();
35976 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35977
35978 wxPyEndAllowThreads(__tstate);
35979 if (PyErr_Occurred()) SWIG_fail;
35980 }
35981 {
35982 resultobj = wxPyMake_wxObject(result, 1);
35983 }
35984 {
35985 if (temp3)
35986 delete arg3;
35987 }
35988 {
35989 if (temp4)
35990 delete arg4;
35991 }
35992 return resultobj;
35993 fail:
35994 {
35995 if (temp3)
35996 delete arg3;
35997 }
35998 {
35999 if (temp4)
36000 delete arg4;
36001 }
36002 return NULL;
36003 }
36004
36005
36006 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36007 PyObject *resultobj;
36008 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36009 wxMenu *result;
36010 PyObject * obj0 = 0 ;
36011 char *kwnames[] = {
36012 (char *) "self", NULL
36013 };
36014
36015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36017 if (SWIG_arg_fail(1)) SWIG_fail;
36018 {
36019 PyThreadState* __tstate = wxPyBeginAllowThreads();
36020 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36021
36022 wxPyEndAllowThreads(__tstate);
36023 if (PyErr_Occurred()) SWIG_fail;
36024 }
36025 {
36026 resultobj = wxPyMake_wxObject(result, 0);
36027 }
36028 return resultobj;
36029 fail:
36030 return NULL;
36031 }
36032
36033
36034 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36035 PyObject *resultobj;
36036 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36037 wxMenu *arg2 = (wxMenu *) 0 ;
36038 PyObject * obj0 = 0 ;
36039 PyObject * obj1 = 0 ;
36040 char *kwnames[] = {
36041 (char *) "self",(char *) "menu", NULL
36042 };
36043
36044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36046 if (SWIG_arg_fail(1)) SWIG_fail;
36047 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36048 if (SWIG_arg_fail(2)) SWIG_fail;
36049 {
36050 PyThreadState* __tstate = wxPyBeginAllowThreads();
36051 (arg1)->SetMenu(arg2);
36052
36053 wxPyEndAllowThreads(__tstate);
36054 if (PyErr_Occurred()) SWIG_fail;
36055 }
36056 Py_INCREF(Py_None); resultobj = Py_None;
36057 return resultobj;
36058 fail:
36059 return NULL;
36060 }
36061
36062
36063 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36064 PyObject *resultobj;
36065 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36066 int arg2 ;
36067 PyObject * obj0 = 0 ;
36068 PyObject * obj1 = 0 ;
36069 char *kwnames[] = {
36070 (char *) "self",(char *) "id", NULL
36071 };
36072
36073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36075 if (SWIG_arg_fail(1)) SWIG_fail;
36076 {
36077 arg2 = (int)(SWIG_As_int(obj1));
36078 if (SWIG_arg_fail(2)) SWIG_fail;
36079 }
36080 {
36081 PyThreadState* __tstate = wxPyBeginAllowThreads();
36082 (arg1)->SetId(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_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36095 PyObject *resultobj;
36096 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36097 int result;
36098 PyObject * obj0 = 0 ;
36099 char *kwnames[] = {
36100 (char *) "self", NULL
36101 };
36102
36103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",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 = (int)((wxMenuItem const *)arg1)->GetId();
36109
36110 wxPyEndAllowThreads(__tstate);
36111 if (PyErr_Occurred()) SWIG_fail;
36112 }
36113 {
36114 resultobj = SWIG_From_int((int)(result));
36115 }
36116 return resultobj;
36117 fail:
36118 return NULL;
36119 }
36120
36121
36122 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36123 PyObject *resultobj;
36124 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36125 bool result;
36126 PyObject * obj0 = 0 ;
36127 char *kwnames[] = {
36128 (char *) "self", NULL
36129 };
36130
36131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36132 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36133 if (SWIG_arg_fail(1)) SWIG_fail;
36134 {
36135 PyThreadState* __tstate = wxPyBeginAllowThreads();
36136 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36137
36138 wxPyEndAllowThreads(__tstate);
36139 if (PyErr_Occurred()) SWIG_fail;
36140 }
36141 {
36142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36143 }
36144 return resultobj;
36145 fail:
36146 return NULL;
36147 }
36148
36149
36150 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36151 PyObject *resultobj;
36152 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36153 wxString *arg2 = 0 ;
36154 bool temp2 = false ;
36155 PyObject * obj0 = 0 ;
36156 PyObject * obj1 = 0 ;
36157 char *kwnames[] = {
36158 (char *) "self",(char *) "str", NULL
36159 };
36160
36161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
36162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36163 if (SWIG_arg_fail(1)) SWIG_fail;
36164 {
36165 arg2 = wxString_in_helper(obj1);
36166 if (arg2 == NULL) SWIG_fail;
36167 temp2 = true;
36168 }
36169 {
36170 PyThreadState* __tstate = wxPyBeginAllowThreads();
36171 (arg1)->SetText((wxString const &)*arg2);
36172
36173 wxPyEndAllowThreads(__tstate);
36174 if (PyErr_Occurred()) SWIG_fail;
36175 }
36176 Py_INCREF(Py_None); resultobj = Py_None;
36177 {
36178 if (temp2)
36179 delete arg2;
36180 }
36181 return resultobj;
36182 fail:
36183 {
36184 if (temp2)
36185 delete arg2;
36186 }
36187 return NULL;
36188 }
36189
36190
36191 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36192 PyObject *resultobj;
36193 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36194 wxString result;
36195 PyObject * obj0 = 0 ;
36196 char *kwnames[] = {
36197 (char *) "self", NULL
36198 };
36199
36200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36202 if (SWIG_arg_fail(1)) SWIG_fail;
36203 {
36204 PyThreadState* __tstate = wxPyBeginAllowThreads();
36205 result = ((wxMenuItem const *)arg1)->GetLabel();
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_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36224 PyObject *resultobj;
36225 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36226 wxString *result;
36227 PyObject * obj0 = 0 ;
36228 char *kwnames[] = {
36229 (char *) "self", NULL
36230 };
36231
36232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",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 {
36238 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36239 result = (wxString *) &_result_ref;
36240 }
36241
36242 wxPyEndAllowThreads(__tstate);
36243 if (PyErr_Occurred()) SWIG_fail;
36244 }
36245 {
36246 #if wxUSE_UNICODE
36247 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36248 #else
36249 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36250 #endif
36251 }
36252 return resultobj;
36253 fail:
36254 return NULL;
36255 }
36256
36257
36258 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36259 PyObject *resultobj;
36260 wxString *arg1 = 0 ;
36261 wxString result;
36262 bool temp1 = false ;
36263 PyObject * obj0 = 0 ;
36264 char *kwnames[] = {
36265 (char *) "text", NULL
36266 };
36267
36268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36269 {
36270 arg1 = wxString_in_helper(obj0);
36271 if (arg1 == NULL) SWIG_fail;
36272 temp1 = true;
36273 }
36274 {
36275 PyThreadState* __tstate = wxPyBeginAllowThreads();
36276 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36277
36278 wxPyEndAllowThreads(__tstate);
36279 if (PyErr_Occurred()) SWIG_fail;
36280 }
36281 {
36282 #if wxUSE_UNICODE
36283 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36284 #else
36285 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36286 #endif
36287 }
36288 {
36289 if (temp1)
36290 delete arg1;
36291 }
36292 return resultobj;
36293 fail:
36294 {
36295 if (temp1)
36296 delete arg1;
36297 }
36298 return NULL;
36299 }
36300
36301
36302 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36303 PyObject *resultobj;
36304 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36305 wxItemKind result;
36306 PyObject * obj0 = 0 ;
36307 char *kwnames[] = {
36308 (char *) "self", NULL
36309 };
36310
36311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36313 if (SWIG_arg_fail(1)) SWIG_fail;
36314 {
36315 PyThreadState* __tstate = wxPyBeginAllowThreads();
36316 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36317
36318 wxPyEndAllowThreads(__tstate);
36319 if (PyErr_Occurred()) SWIG_fail;
36320 }
36321 resultobj = SWIG_From_int((result));
36322 return resultobj;
36323 fail:
36324 return NULL;
36325 }
36326
36327
36328 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36329 PyObject *resultobj;
36330 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36331 wxItemKind arg2 ;
36332 PyObject * obj0 = 0 ;
36333 PyObject * obj1 = 0 ;
36334 char *kwnames[] = {
36335 (char *) "self",(char *) "kind", NULL
36336 };
36337
36338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36340 if (SWIG_arg_fail(1)) SWIG_fail;
36341 {
36342 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36343 if (SWIG_arg_fail(2)) SWIG_fail;
36344 }
36345 {
36346 PyThreadState* __tstate = wxPyBeginAllowThreads();
36347 (arg1)->SetKind((wxItemKind )arg2);
36348
36349 wxPyEndAllowThreads(__tstate);
36350 if (PyErr_Occurred()) SWIG_fail;
36351 }
36352 Py_INCREF(Py_None); resultobj = Py_None;
36353 return resultobj;
36354 fail:
36355 return NULL;
36356 }
36357
36358
36359 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36360 PyObject *resultobj;
36361 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36362 bool arg2 ;
36363 PyObject * obj0 = 0 ;
36364 PyObject * obj1 = 0 ;
36365 char *kwnames[] = {
36366 (char *) "self",(char *) "checkable", NULL
36367 };
36368
36369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36371 if (SWIG_arg_fail(1)) SWIG_fail;
36372 {
36373 arg2 = (bool)(SWIG_As_bool(obj1));
36374 if (SWIG_arg_fail(2)) SWIG_fail;
36375 }
36376 {
36377 PyThreadState* __tstate = wxPyBeginAllowThreads();
36378 (arg1)->SetCheckable(arg2);
36379
36380 wxPyEndAllowThreads(__tstate);
36381 if (PyErr_Occurred()) SWIG_fail;
36382 }
36383 Py_INCREF(Py_None); resultobj = Py_None;
36384 return resultobj;
36385 fail:
36386 return NULL;
36387 }
36388
36389
36390 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36391 PyObject *resultobj;
36392 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36393 bool result;
36394 PyObject * obj0 = 0 ;
36395 char *kwnames[] = {
36396 (char *) "self", NULL
36397 };
36398
36399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36401 if (SWIG_arg_fail(1)) SWIG_fail;
36402 {
36403 PyThreadState* __tstate = wxPyBeginAllowThreads();
36404 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36405
36406 wxPyEndAllowThreads(__tstate);
36407 if (PyErr_Occurred()) SWIG_fail;
36408 }
36409 {
36410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36411 }
36412 return resultobj;
36413 fail:
36414 return NULL;
36415 }
36416
36417
36418 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36419 PyObject *resultobj;
36420 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36421 bool result;
36422 PyObject * obj0 = 0 ;
36423 char *kwnames[] = {
36424 (char *) "self", NULL
36425 };
36426
36427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36429 if (SWIG_arg_fail(1)) SWIG_fail;
36430 {
36431 PyThreadState* __tstate = wxPyBeginAllowThreads();
36432 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36433
36434 wxPyEndAllowThreads(__tstate);
36435 if (PyErr_Occurred()) SWIG_fail;
36436 }
36437 {
36438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36439 }
36440 return resultobj;
36441 fail:
36442 return NULL;
36443 }
36444
36445
36446 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36447 PyObject *resultobj;
36448 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36449 wxMenu *arg2 = (wxMenu *) 0 ;
36450 PyObject * obj0 = 0 ;
36451 PyObject * obj1 = 0 ;
36452 char *kwnames[] = {
36453 (char *) "self",(char *) "menu", NULL
36454 };
36455
36456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36458 if (SWIG_arg_fail(1)) SWIG_fail;
36459 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36460 if (SWIG_arg_fail(2)) SWIG_fail;
36461 {
36462 PyThreadState* __tstate = wxPyBeginAllowThreads();
36463 (arg1)->SetSubMenu(arg2);
36464
36465 wxPyEndAllowThreads(__tstate);
36466 if (PyErr_Occurred()) SWIG_fail;
36467 }
36468 Py_INCREF(Py_None); resultobj = Py_None;
36469 return resultobj;
36470 fail:
36471 return NULL;
36472 }
36473
36474
36475 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36476 PyObject *resultobj;
36477 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36478 wxMenu *result;
36479 PyObject * obj0 = 0 ;
36480 char *kwnames[] = {
36481 (char *) "self", NULL
36482 };
36483
36484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36485 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36486 if (SWIG_arg_fail(1)) SWIG_fail;
36487 {
36488 PyThreadState* __tstate = wxPyBeginAllowThreads();
36489 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36490
36491 wxPyEndAllowThreads(__tstate);
36492 if (PyErr_Occurred()) SWIG_fail;
36493 }
36494 {
36495 resultobj = wxPyMake_wxObject(result, 0);
36496 }
36497 return resultobj;
36498 fail:
36499 return NULL;
36500 }
36501
36502
36503 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36504 PyObject *resultobj;
36505 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36506 bool arg2 = (bool) true ;
36507 PyObject * obj0 = 0 ;
36508 PyObject * obj1 = 0 ;
36509 char *kwnames[] = {
36510 (char *) "self",(char *) "enable", NULL
36511 };
36512
36513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36515 if (SWIG_arg_fail(1)) SWIG_fail;
36516 if (obj1) {
36517 {
36518 arg2 = (bool)(SWIG_As_bool(obj1));
36519 if (SWIG_arg_fail(2)) SWIG_fail;
36520 }
36521 }
36522 {
36523 PyThreadState* __tstate = wxPyBeginAllowThreads();
36524 (arg1)->Enable(arg2);
36525
36526 wxPyEndAllowThreads(__tstate);
36527 if (PyErr_Occurred()) SWIG_fail;
36528 }
36529 Py_INCREF(Py_None); resultobj = Py_None;
36530 return resultobj;
36531 fail:
36532 return NULL;
36533 }
36534
36535
36536 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36537 PyObject *resultobj;
36538 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36539 bool result;
36540 PyObject * obj0 = 0 ;
36541 char *kwnames[] = {
36542 (char *) "self", NULL
36543 };
36544
36545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36547 if (SWIG_arg_fail(1)) SWIG_fail;
36548 {
36549 PyThreadState* __tstate = wxPyBeginAllowThreads();
36550 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36551
36552 wxPyEndAllowThreads(__tstate);
36553 if (PyErr_Occurred()) SWIG_fail;
36554 }
36555 {
36556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36557 }
36558 return resultobj;
36559 fail:
36560 return NULL;
36561 }
36562
36563
36564 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36565 PyObject *resultobj;
36566 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36567 bool arg2 = (bool) true ;
36568 PyObject * obj0 = 0 ;
36569 PyObject * obj1 = 0 ;
36570 char *kwnames[] = {
36571 (char *) "self",(char *) "check", NULL
36572 };
36573
36574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36576 if (SWIG_arg_fail(1)) SWIG_fail;
36577 if (obj1) {
36578 {
36579 arg2 = (bool)(SWIG_As_bool(obj1));
36580 if (SWIG_arg_fail(2)) SWIG_fail;
36581 }
36582 }
36583 {
36584 PyThreadState* __tstate = wxPyBeginAllowThreads();
36585 (arg1)->Check(arg2);
36586
36587 wxPyEndAllowThreads(__tstate);
36588 if (PyErr_Occurred()) SWIG_fail;
36589 }
36590 Py_INCREF(Py_None); resultobj = Py_None;
36591 return resultobj;
36592 fail:
36593 return NULL;
36594 }
36595
36596
36597 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36598 PyObject *resultobj;
36599 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36600 bool result;
36601 PyObject * obj0 = 0 ;
36602 char *kwnames[] = {
36603 (char *) "self", NULL
36604 };
36605
36606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36608 if (SWIG_arg_fail(1)) SWIG_fail;
36609 {
36610 PyThreadState* __tstate = wxPyBeginAllowThreads();
36611 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36612
36613 wxPyEndAllowThreads(__tstate);
36614 if (PyErr_Occurred()) SWIG_fail;
36615 }
36616 {
36617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36618 }
36619 return resultobj;
36620 fail:
36621 return NULL;
36622 }
36623
36624
36625 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36626 PyObject *resultobj;
36627 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36628 PyObject * obj0 = 0 ;
36629 char *kwnames[] = {
36630 (char *) "self", NULL
36631 };
36632
36633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36635 if (SWIG_arg_fail(1)) SWIG_fail;
36636 {
36637 PyThreadState* __tstate = wxPyBeginAllowThreads();
36638 (arg1)->Toggle();
36639
36640 wxPyEndAllowThreads(__tstate);
36641 if (PyErr_Occurred()) SWIG_fail;
36642 }
36643 Py_INCREF(Py_None); resultobj = Py_None;
36644 return resultobj;
36645 fail:
36646 return NULL;
36647 }
36648
36649
36650 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36651 PyObject *resultobj;
36652 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36653 wxString *arg2 = 0 ;
36654 bool temp2 = false ;
36655 PyObject * obj0 = 0 ;
36656 PyObject * obj1 = 0 ;
36657 char *kwnames[] = {
36658 (char *) "self",(char *) "str", NULL
36659 };
36660
36661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36663 if (SWIG_arg_fail(1)) SWIG_fail;
36664 {
36665 arg2 = wxString_in_helper(obj1);
36666 if (arg2 == NULL) SWIG_fail;
36667 temp2 = true;
36668 }
36669 {
36670 PyThreadState* __tstate = wxPyBeginAllowThreads();
36671 (arg1)->SetHelp((wxString const &)*arg2);
36672
36673 wxPyEndAllowThreads(__tstate);
36674 if (PyErr_Occurred()) SWIG_fail;
36675 }
36676 Py_INCREF(Py_None); resultobj = Py_None;
36677 {
36678 if (temp2)
36679 delete arg2;
36680 }
36681 return resultobj;
36682 fail:
36683 {
36684 if (temp2)
36685 delete arg2;
36686 }
36687 return NULL;
36688 }
36689
36690
36691 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36692 PyObject *resultobj;
36693 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36694 wxString *result;
36695 PyObject * obj0 = 0 ;
36696 char *kwnames[] = {
36697 (char *) "self", NULL
36698 };
36699
36700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36702 if (SWIG_arg_fail(1)) SWIG_fail;
36703 {
36704 PyThreadState* __tstate = wxPyBeginAllowThreads();
36705 {
36706 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36707 result = (wxString *) &_result_ref;
36708 }
36709
36710 wxPyEndAllowThreads(__tstate);
36711 if (PyErr_Occurred()) SWIG_fail;
36712 }
36713 {
36714 #if wxUSE_UNICODE
36715 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36716 #else
36717 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36718 #endif
36719 }
36720 return resultobj;
36721 fail:
36722 return NULL;
36723 }
36724
36725
36726 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36727 PyObject *resultobj;
36728 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36729 wxAcceleratorEntry *result;
36730 PyObject * obj0 = 0 ;
36731 char *kwnames[] = {
36732 (char *) "self", NULL
36733 };
36734
36735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36737 if (SWIG_arg_fail(1)) SWIG_fail;
36738 {
36739 PyThreadState* __tstate = wxPyBeginAllowThreads();
36740 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36741
36742 wxPyEndAllowThreads(__tstate);
36743 if (PyErr_Occurred()) SWIG_fail;
36744 }
36745 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36746 return resultobj;
36747 fail:
36748 return NULL;
36749 }
36750
36751
36752 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36753 PyObject *resultobj;
36754 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36755 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36756 PyObject * obj0 = 0 ;
36757 PyObject * obj1 = 0 ;
36758 char *kwnames[] = {
36759 (char *) "self",(char *) "accel", NULL
36760 };
36761
36762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36764 if (SWIG_arg_fail(1)) SWIG_fail;
36765 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36766 if (SWIG_arg_fail(2)) SWIG_fail;
36767 {
36768 PyThreadState* __tstate = wxPyBeginAllowThreads();
36769 (arg1)->SetAccel(arg2);
36770
36771 wxPyEndAllowThreads(__tstate);
36772 if (PyErr_Occurred()) SWIG_fail;
36773 }
36774 Py_INCREF(Py_None); resultobj = Py_None;
36775 return resultobj;
36776 fail:
36777 return NULL;
36778 }
36779
36780
36781 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36782 PyObject *resultobj;
36783 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36784 wxFont *arg2 = 0 ;
36785 PyObject * obj0 = 0 ;
36786 PyObject * obj1 = 0 ;
36787 char *kwnames[] = {
36788 (char *) "self",(char *) "font", NULL
36789 };
36790
36791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36793 if (SWIG_arg_fail(1)) SWIG_fail;
36794 {
36795 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36796 if (SWIG_arg_fail(2)) SWIG_fail;
36797 if (arg2 == NULL) {
36798 SWIG_null_ref("wxFont");
36799 }
36800 if (SWIG_arg_fail(2)) SWIG_fail;
36801 }
36802 {
36803 PyThreadState* __tstate = wxPyBeginAllowThreads();
36804 (arg1)->SetFont((wxFont const &)*arg2);
36805
36806 wxPyEndAllowThreads(__tstate);
36807 if (PyErr_Occurred()) SWIG_fail;
36808 }
36809 Py_INCREF(Py_None); resultobj = Py_None;
36810 return resultobj;
36811 fail:
36812 return NULL;
36813 }
36814
36815
36816 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36817 PyObject *resultobj;
36818 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36819 wxFont result;
36820 PyObject * obj0 = 0 ;
36821 char *kwnames[] = {
36822 (char *) "self", NULL
36823 };
36824
36825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36827 if (SWIG_arg_fail(1)) SWIG_fail;
36828 {
36829 PyThreadState* __tstate = wxPyBeginAllowThreads();
36830 result = (arg1)->GetFont();
36831
36832 wxPyEndAllowThreads(__tstate);
36833 if (PyErr_Occurred()) SWIG_fail;
36834 }
36835 {
36836 wxFont * resultptr;
36837 resultptr = new wxFont((wxFont &)(result));
36838 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36839 }
36840 return resultobj;
36841 fail:
36842 return NULL;
36843 }
36844
36845
36846 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36847 PyObject *resultobj;
36848 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36849 wxColour *arg2 = 0 ;
36850 wxColour temp2 ;
36851 PyObject * obj0 = 0 ;
36852 PyObject * obj1 = 0 ;
36853 char *kwnames[] = {
36854 (char *) "self",(char *) "colText", NULL
36855 };
36856
36857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36859 if (SWIG_arg_fail(1)) SWIG_fail;
36860 {
36861 arg2 = &temp2;
36862 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36863 }
36864 {
36865 PyThreadState* __tstate = wxPyBeginAllowThreads();
36866 (arg1)->SetTextColour((wxColour const &)*arg2);
36867
36868 wxPyEndAllowThreads(__tstate);
36869 if (PyErr_Occurred()) SWIG_fail;
36870 }
36871 Py_INCREF(Py_None); resultobj = Py_None;
36872 return resultobj;
36873 fail:
36874 return NULL;
36875 }
36876
36877
36878 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36879 PyObject *resultobj;
36880 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36881 wxColour result;
36882 PyObject * obj0 = 0 ;
36883 char *kwnames[] = {
36884 (char *) "self", NULL
36885 };
36886
36887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36889 if (SWIG_arg_fail(1)) SWIG_fail;
36890 {
36891 PyThreadState* __tstate = wxPyBeginAllowThreads();
36892 result = (arg1)->GetTextColour();
36893
36894 wxPyEndAllowThreads(__tstate);
36895 if (PyErr_Occurred()) SWIG_fail;
36896 }
36897 {
36898 wxColour * resultptr;
36899 resultptr = new wxColour((wxColour &)(result));
36900 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36901 }
36902 return resultobj;
36903 fail:
36904 return NULL;
36905 }
36906
36907
36908 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36909 PyObject *resultobj;
36910 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36911 wxColour *arg2 = 0 ;
36912 wxColour temp2 ;
36913 PyObject * obj0 = 0 ;
36914 PyObject * obj1 = 0 ;
36915 char *kwnames[] = {
36916 (char *) "self",(char *) "colBack", NULL
36917 };
36918
36919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36921 if (SWIG_arg_fail(1)) SWIG_fail;
36922 {
36923 arg2 = &temp2;
36924 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36925 }
36926 {
36927 PyThreadState* __tstate = wxPyBeginAllowThreads();
36928 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
36929
36930 wxPyEndAllowThreads(__tstate);
36931 if (PyErr_Occurred()) SWIG_fail;
36932 }
36933 Py_INCREF(Py_None); resultobj = Py_None;
36934 return resultobj;
36935 fail:
36936 return NULL;
36937 }
36938
36939
36940 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36941 PyObject *resultobj;
36942 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36943 wxColour result;
36944 PyObject * obj0 = 0 ;
36945 char *kwnames[] = {
36946 (char *) "self", NULL
36947 };
36948
36949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36951 if (SWIG_arg_fail(1)) SWIG_fail;
36952 {
36953 PyThreadState* __tstate = wxPyBeginAllowThreads();
36954 result = (arg1)->GetBackgroundColour();
36955
36956 wxPyEndAllowThreads(__tstate);
36957 if (PyErr_Occurred()) SWIG_fail;
36958 }
36959 {
36960 wxColour * resultptr;
36961 resultptr = new wxColour((wxColour &)(result));
36962 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36963 }
36964 return resultobj;
36965 fail:
36966 return NULL;
36967 }
36968
36969
36970 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36971 PyObject *resultobj;
36972 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36973 wxBitmap *arg2 = 0 ;
36974 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36975 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36976 PyObject * obj0 = 0 ;
36977 PyObject * obj1 = 0 ;
36978 PyObject * obj2 = 0 ;
36979 char *kwnames[] = {
36980 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36981 };
36982
36983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36985 if (SWIG_arg_fail(1)) SWIG_fail;
36986 {
36987 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36988 if (SWIG_arg_fail(2)) SWIG_fail;
36989 if (arg2 == NULL) {
36990 SWIG_null_ref("wxBitmap");
36991 }
36992 if (SWIG_arg_fail(2)) SWIG_fail;
36993 }
36994 if (obj2) {
36995 {
36996 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36997 if (SWIG_arg_fail(3)) SWIG_fail;
36998 if (arg3 == NULL) {
36999 SWIG_null_ref("wxBitmap");
37000 }
37001 if (SWIG_arg_fail(3)) SWIG_fail;
37002 }
37003 }
37004 {
37005 PyThreadState* __tstate = wxPyBeginAllowThreads();
37006 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
37007
37008 wxPyEndAllowThreads(__tstate);
37009 if (PyErr_Occurred()) SWIG_fail;
37010 }
37011 Py_INCREF(Py_None); resultobj = Py_None;
37012 return resultobj;
37013 fail:
37014 return NULL;
37015 }
37016
37017
37018 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37019 PyObject *resultobj;
37020 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37021 wxBitmap *arg2 = 0 ;
37022 PyObject * obj0 = 0 ;
37023 PyObject * obj1 = 0 ;
37024 char *kwnames[] = {
37025 (char *) "self",(char *) "bmpDisabled", NULL
37026 };
37027
37028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37030 if (SWIG_arg_fail(1)) SWIG_fail;
37031 {
37032 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37033 if (SWIG_arg_fail(2)) SWIG_fail;
37034 if (arg2 == NULL) {
37035 SWIG_null_ref("wxBitmap");
37036 }
37037 if (SWIG_arg_fail(2)) SWIG_fail;
37038 }
37039 {
37040 PyThreadState* __tstate = wxPyBeginAllowThreads();
37041 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
37042
37043 wxPyEndAllowThreads(__tstate);
37044 if (PyErr_Occurred()) SWIG_fail;
37045 }
37046 Py_INCREF(Py_None); resultobj = Py_None;
37047 return resultobj;
37048 fail:
37049 return NULL;
37050 }
37051
37052
37053 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37054 PyObject *resultobj;
37055 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37056 wxBitmap *result;
37057 PyObject * obj0 = 0 ;
37058 char *kwnames[] = {
37059 (char *) "self", NULL
37060 };
37061
37062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37064 if (SWIG_arg_fail(1)) SWIG_fail;
37065 {
37066 PyThreadState* __tstate = wxPyBeginAllowThreads();
37067 {
37068 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
37069 result = (wxBitmap *) &_result_ref;
37070 }
37071
37072 wxPyEndAllowThreads(__tstate);
37073 if (PyErr_Occurred()) SWIG_fail;
37074 }
37075 {
37076 wxBitmap* resultptr = new wxBitmap(*result);
37077 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37078 }
37079 return resultobj;
37080 fail:
37081 return NULL;
37082 }
37083
37084
37085 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37086 PyObject *resultobj;
37087 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37088 int arg2 ;
37089 PyObject * obj0 = 0 ;
37090 PyObject * obj1 = 0 ;
37091 char *kwnames[] = {
37092 (char *) "self",(char *) "nWidth", NULL
37093 };
37094
37095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
37096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37097 if (SWIG_arg_fail(1)) SWIG_fail;
37098 {
37099 arg2 = (int)(SWIG_As_int(obj1));
37100 if (SWIG_arg_fail(2)) SWIG_fail;
37101 }
37102 {
37103 PyThreadState* __tstate = wxPyBeginAllowThreads();
37104 (arg1)->SetMarginWidth(arg2);
37105
37106 wxPyEndAllowThreads(__tstate);
37107 if (PyErr_Occurred()) SWIG_fail;
37108 }
37109 Py_INCREF(Py_None); resultobj = Py_None;
37110 return resultobj;
37111 fail:
37112 return NULL;
37113 }
37114
37115
37116 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37117 PyObject *resultobj;
37118 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37119 int result;
37120 PyObject * obj0 = 0 ;
37121 char *kwnames[] = {
37122 (char *) "self", NULL
37123 };
37124
37125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37127 if (SWIG_arg_fail(1)) SWIG_fail;
37128 {
37129 PyThreadState* __tstate = wxPyBeginAllowThreads();
37130 result = (int)(arg1)->GetMarginWidth();
37131
37132 wxPyEndAllowThreads(__tstate);
37133 if (PyErr_Occurred()) SWIG_fail;
37134 }
37135 {
37136 resultobj = SWIG_From_int((int)(result));
37137 }
37138 return resultobj;
37139 fail:
37140 return NULL;
37141 }
37142
37143
37144 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37145 PyObject *resultobj;
37146 int result;
37147 char *kwnames[] = {
37148 NULL
37149 };
37150
37151 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37152 {
37153 PyThreadState* __tstate = wxPyBeginAllowThreads();
37154 result = (int)wxMenuItem::GetDefaultMarginWidth();
37155
37156 wxPyEndAllowThreads(__tstate);
37157 if (PyErr_Occurred()) SWIG_fail;
37158 }
37159 {
37160 resultobj = SWIG_From_int((int)(result));
37161 }
37162 return resultobj;
37163 fail:
37164 return NULL;
37165 }
37166
37167
37168 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37169 PyObject *resultobj;
37170 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37171 bool result;
37172 PyObject * obj0 = 0 ;
37173 char *kwnames[] = {
37174 (char *) "self", NULL
37175 };
37176
37177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37179 if (SWIG_arg_fail(1)) SWIG_fail;
37180 {
37181 PyThreadState* __tstate = wxPyBeginAllowThreads();
37182 result = (bool)(arg1)->IsOwnerDrawn();
37183
37184 wxPyEndAllowThreads(__tstate);
37185 if (PyErr_Occurred()) SWIG_fail;
37186 }
37187 {
37188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37189 }
37190 return resultobj;
37191 fail:
37192 return NULL;
37193 }
37194
37195
37196 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37197 PyObject *resultobj;
37198 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37199 bool arg2 = (bool) true ;
37200 PyObject * obj0 = 0 ;
37201 PyObject * obj1 = 0 ;
37202 char *kwnames[] = {
37203 (char *) "self",(char *) "ownerDrawn", NULL
37204 };
37205
37206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37208 if (SWIG_arg_fail(1)) SWIG_fail;
37209 if (obj1) {
37210 {
37211 arg2 = (bool)(SWIG_As_bool(obj1));
37212 if (SWIG_arg_fail(2)) SWIG_fail;
37213 }
37214 }
37215 {
37216 PyThreadState* __tstate = wxPyBeginAllowThreads();
37217 (arg1)->SetOwnerDrawn(arg2);
37218
37219 wxPyEndAllowThreads(__tstate);
37220 if (PyErr_Occurred()) SWIG_fail;
37221 }
37222 Py_INCREF(Py_None); resultobj = Py_None;
37223 return resultobj;
37224 fail:
37225 return NULL;
37226 }
37227
37228
37229 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37230 PyObject *resultobj;
37231 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37232 PyObject * obj0 = 0 ;
37233 char *kwnames[] = {
37234 (char *) "self", NULL
37235 };
37236
37237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37239 if (SWIG_arg_fail(1)) SWIG_fail;
37240 {
37241 PyThreadState* __tstate = wxPyBeginAllowThreads();
37242 (arg1)->ResetOwnerDrawn();
37243
37244 wxPyEndAllowThreads(__tstate);
37245 if (PyErr_Occurred()) SWIG_fail;
37246 }
37247 Py_INCREF(Py_None); resultobj = Py_None;
37248 return resultobj;
37249 fail:
37250 return NULL;
37251 }
37252
37253
37254 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37255 PyObject *resultobj;
37256 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37257 wxBitmap *arg2 = 0 ;
37258 PyObject * obj0 = 0 ;
37259 PyObject * obj1 = 0 ;
37260 char *kwnames[] = {
37261 (char *) "self",(char *) "bitmap", NULL
37262 };
37263
37264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37266 if (SWIG_arg_fail(1)) SWIG_fail;
37267 {
37268 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37269 if (SWIG_arg_fail(2)) SWIG_fail;
37270 if (arg2 == NULL) {
37271 SWIG_null_ref("wxBitmap");
37272 }
37273 if (SWIG_arg_fail(2)) SWIG_fail;
37274 }
37275 {
37276 PyThreadState* __tstate = wxPyBeginAllowThreads();
37277 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37278
37279 wxPyEndAllowThreads(__tstate);
37280 if (PyErr_Occurred()) SWIG_fail;
37281 }
37282 Py_INCREF(Py_None); resultobj = Py_None;
37283 return resultobj;
37284 fail:
37285 return NULL;
37286 }
37287
37288
37289 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37290 PyObject *resultobj;
37291 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37292 wxBitmap *result;
37293 PyObject * obj0 = 0 ;
37294 char *kwnames[] = {
37295 (char *) "self", NULL
37296 };
37297
37298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37300 if (SWIG_arg_fail(1)) SWIG_fail;
37301 {
37302 PyThreadState* __tstate = wxPyBeginAllowThreads();
37303 {
37304 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37305 result = (wxBitmap *) &_result_ref;
37306 }
37307
37308 wxPyEndAllowThreads(__tstate);
37309 if (PyErr_Occurred()) SWIG_fail;
37310 }
37311 {
37312 wxBitmap* resultptr = new wxBitmap(*result);
37313 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37314 }
37315 return resultobj;
37316 fail:
37317 return NULL;
37318 }
37319
37320
37321 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37322 PyObject *obj;
37323 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37324 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37325 Py_INCREF(obj);
37326 return Py_BuildValue((char *)"");
37327 }
37328 static int _wrap_ControlNameStr_set(PyObject *) {
37329 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37330 return 1;
37331 }
37332
37333
37334 static PyObject *_wrap_ControlNameStr_get(void) {
37335 PyObject *pyobj;
37336
37337 {
37338 #if wxUSE_UNICODE
37339 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37340 #else
37341 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37342 #endif
37343 }
37344 return pyobj;
37345 }
37346
37347
37348 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37349 PyObject *resultobj;
37350 wxWindow *arg1 = (wxWindow *) 0 ;
37351 int arg2 = (int) -1 ;
37352 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37353 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37354 wxSize const &arg4_defvalue = wxDefaultSize ;
37355 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37356 long arg5 = (long) 0 ;
37357 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37358 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37359 wxString const &arg7_defvalue = wxPyControlNameStr ;
37360 wxString *arg7 = (wxString *) &arg7_defvalue ;
37361 wxControl *result;
37362 wxPoint temp3 ;
37363 wxSize temp4 ;
37364 bool temp7 = false ;
37365 PyObject * obj0 = 0 ;
37366 PyObject * obj1 = 0 ;
37367 PyObject * obj2 = 0 ;
37368 PyObject * obj3 = 0 ;
37369 PyObject * obj4 = 0 ;
37370 PyObject * obj5 = 0 ;
37371 PyObject * obj6 = 0 ;
37372 char *kwnames[] = {
37373 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37374 };
37375
37376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37378 if (SWIG_arg_fail(1)) SWIG_fail;
37379 if (obj1) {
37380 {
37381 arg2 = (int)(SWIG_As_int(obj1));
37382 if (SWIG_arg_fail(2)) SWIG_fail;
37383 }
37384 }
37385 if (obj2) {
37386 {
37387 arg3 = &temp3;
37388 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37389 }
37390 }
37391 if (obj3) {
37392 {
37393 arg4 = &temp4;
37394 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37395 }
37396 }
37397 if (obj4) {
37398 {
37399 arg5 = (long)(SWIG_As_long(obj4));
37400 if (SWIG_arg_fail(5)) SWIG_fail;
37401 }
37402 }
37403 if (obj5) {
37404 {
37405 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37406 if (SWIG_arg_fail(6)) SWIG_fail;
37407 if (arg6 == NULL) {
37408 SWIG_null_ref("wxValidator");
37409 }
37410 if (SWIG_arg_fail(6)) SWIG_fail;
37411 }
37412 }
37413 if (obj6) {
37414 {
37415 arg7 = wxString_in_helper(obj6);
37416 if (arg7 == NULL) SWIG_fail;
37417 temp7 = true;
37418 }
37419 }
37420 {
37421 if (!wxPyCheckForApp()) SWIG_fail;
37422 PyThreadState* __tstate = wxPyBeginAllowThreads();
37423 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37424
37425 wxPyEndAllowThreads(__tstate);
37426 if (PyErr_Occurred()) SWIG_fail;
37427 }
37428 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37429 {
37430 if (temp7)
37431 delete arg7;
37432 }
37433 return resultobj;
37434 fail:
37435 {
37436 if (temp7)
37437 delete arg7;
37438 }
37439 return NULL;
37440 }
37441
37442
37443 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37444 PyObject *resultobj;
37445 wxControl *result;
37446 char *kwnames[] = {
37447 NULL
37448 };
37449
37450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37451 {
37452 if (!wxPyCheckForApp()) SWIG_fail;
37453 PyThreadState* __tstate = wxPyBeginAllowThreads();
37454 result = (wxControl *)new wxControl();
37455
37456 wxPyEndAllowThreads(__tstate);
37457 if (PyErr_Occurred()) SWIG_fail;
37458 }
37459 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37460 return resultobj;
37461 fail:
37462 return NULL;
37463 }
37464
37465
37466 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37467 PyObject *resultobj;
37468 wxControl *arg1 = (wxControl *) 0 ;
37469 wxWindow *arg2 = (wxWindow *) 0 ;
37470 int arg3 = (int) -1 ;
37471 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37472 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37473 wxSize const &arg5_defvalue = wxDefaultSize ;
37474 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37475 long arg6 = (long) 0 ;
37476 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37477 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37478 wxString const &arg8_defvalue = wxPyControlNameStr ;
37479 wxString *arg8 = (wxString *) &arg8_defvalue ;
37480 bool result;
37481 wxPoint temp4 ;
37482 wxSize temp5 ;
37483 bool temp8 = false ;
37484 PyObject * obj0 = 0 ;
37485 PyObject * obj1 = 0 ;
37486 PyObject * obj2 = 0 ;
37487 PyObject * obj3 = 0 ;
37488 PyObject * obj4 = 0 ;
37489 PyObject * obj5 = 0 ;
37490 PyObject * obj6 = 0 ;
37491 PyObject * obj7 = 0 ;
37492 char *kwnames[] = {
37493 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37494 };
37495
37496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37498 if (SWIG_arg_fail(1)) SWIG_fail;
37499 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37500 if (SWIG_arg_fail(2)) SWIG_fail;
37501 if (obj2) {
37502 {
37503 arg3 = (int)(SWIG_As_int(obj2));
37504 if (SWIG_arg_fail(3)) SWIG_fail;
37505 }
37506 }
37507 if (obj3) {
37508 {
37509 arg4 = &temp4;
37510 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37511 }
37512 }
37513 if (obj4) {
37514 {
37515 arg5 = &temp5;
37516 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37517 }
37518 }
37519 if (obj5) {
37520 {
37521 arg6 = (long)(SWIG_As_long(obj5));
37522 if (SWIG_arg_fail(6)) SWIG_fail;
37523 }
37524 }
37525 if (obj6) {
37526 {
37527 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37528 if (SWIG_arg_fail(7)) SWIG_fail;
37529 if (arg7 == NULL) {
37530 SWIG_null_ref("wxValidator");
37531 }
37532 if (SWIG_arg_fail(7)) SWIG_fail;
37533 }
37534 }
37535 if (obj7) {
37536 {
37537 arg8 = wxString_in_helper(obj7);
37538 if (arg8 == NULL) SWIG_fail;
37539 temp8 = true;
37540 }
37541 }
37542 {
37543 PyThreadState* __tstate = wxPyBeginAllowThreads();
37544 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37545
37546 wxPyEndAllowThreads(__tstate);
37547 if (PyErr_Occurred()) SWIG_fail;
37548 }
37549 {
37550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37551 }
37552 {
37553 if (temp8)
37554 delete arg8;
37555 }
37556 return resultobj;
37557 fail:
37558 {
37559 if (temp8)
37560 delete arg8;
37561 }
37562 return NULL;
37563 }
37564
37565
37566 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37567 PyObject *resultobj;
37568 wxControl *arg1 = (wxControl *) 0 ;
37569 wxCommandEvent *arg2 = 0 ;
37570 PyObject * obj0 = 0 ;
37571 PyObject * obj1 = 0 ;
37572 char *kwnames[] = {
37573 (char *) "self",(char *) "event", NULL
37574 };
37575
37576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37578 if (SWIG_arg_fail(1)) SWIG_fail;
37579 {
37580 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37581 if (SWIG_arg_fail(2)) SWIG_fail;
37582 if (arg2 == NULL) {
37583 SWIG_null_ref("wxCommandEvent");
37584 }
37585 if (SWIG_arg_fail(2)) SWIG_fail;
37586 }
37587 {
37588 PyThreadState* __tstate = wxPyBeginAllowThreads();
37589 (arg1)->Command(*arg2);
37590
37591 wxPyEndAllowThreads(__tstate);
37592 if (PyErr_Occurred()) SWIG_fail;
37593 }
37594 Py_INCREF(Py_None); resultobj = Py_None;
37595 return resultobj;
37596 fail:
37597 return NULL;
37598 }
37599
37600
37601 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37602 PyObject *resultobj;
37603 wxControl *arg1 = (wxControl *) 0 ;
37604 wxString result;
37605 PyObject * obj0 = 0 ;
37606 char *kwnames[] = {
37607 (char *) "self", NULL
37608 };
37609
37610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37612 if (SWIG_arg_fail(1)) SWIG_fail;
37613 {
37614 PyThreadState* __tstate = wxPyBeginAllowThreads();
37615 result = (arg1)->GetLabel();
37616
37617 wxPyEndAllowThreads(__tstate);
37618 if (PyErr_Occurred()) SWIG_fail;
37619 }
37620 {
37621 #if wxUSE_UNICODE
37622 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37623 #else
37624 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37625 #endif
37626 }
37627 return resultobj;
37628 fail:
37629 return NULL;
37630 }
37631
37632
37633 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37634 PyObject *resultobj;
37635 wxControl *arg1 = (wxControl *) 0 ;
37636 wxString *arg2 = 0 ;
37637 bool temp2 = false ;
37638 PyObject * obj0 = 0 ;
37639 PyObject * obj1 = 0 ;
37640 char *kwnames[] = {
37641 (char *) "self",(char *) "label", NULL
37642 };
37643
37644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37646 if (SWIG_arg_fail(1)) SWIG_fail;
37647 {
37648 arg2 = wxString_in_helper(obj1);
37649 if (arg2 == NULL) SWIG_fail;
37650 temp2 = true;
37651 }
37652 {
37653 PyThreadState* __tstate = wxPyBeginAllowThreads();
37654 (arg1)->SetLabel((wxString const &)*arg2);
37655
37656 wxPyEndAllowThreads(__tstate);
37657 if (PyErr_Occurred()) SWIG_fail;
37658 }
37659 Py_INCREF(Py_None); resultobj = Py_None;
37660 {
37661 if (temp2)
37662 delete arg2;
37663 }
37664 return resultobj;
37665 fail:
37666 {
37667 if (temp2)
37668 delete arg2;
37669 }
37670 return NULL;
37671 }
37672
37673
37674 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37675 PyObject *resultobj;
37676 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37677 wxVisualAttributes result;
37678 PyObject * obj0 = 0 ;
37679 char *kwnames[] = {
37680 (char *) "variant", NULL
37681 };
37682
37683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37684 if (obj0) {
37685 {
37686 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37687 if (SWIG_arg_fail(1)) SWIG_fail;
37688 }
37689 }
37690 {
37691 if (!wxPyCheckForApp()) SWIG_fail;
37692 PyThreadState* __tstate = wxPyBeginAllowThreads();
37693 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37694
37695 wxPyEndAllowThreads(__tstate);
37696 if (PyErr_Occurred()) SWIG_fail;
37697 }
37698 {
37699 wxVisualAttributes * resultptr;
37700 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37701 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37702 }
37703 return resultobj;
37704 fail:
37705 return NULL;
37706 }
37707
37708
37709 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37710 PyObject *obj;
37711 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37712 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37713 Py_INCREF(obj);
37714 return Py_BuildValue((char *)"");
37715 }
37716 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37717 PyObject *resultobj;
37718 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37719 wxString *arg2 = 0 ;
37720 PyObject *arg3 = (PyObject *) NULL ;
37721 int result;
37722 bool temp2 = false ;
37723 PyObject * obj0 = 0 ;
37724 PyObject * obj1 = 0 ;
37725 PyObject * obj2 = 0 ;
37726 char *kwnames[] = {
37727 (char *) "self",(char *) "item",(char *) "clientData", NULL
37728 };
37729
37730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37732 if (SWIG_arg_fail(1)) SWIG_fail;
37733 {
37734 arg2 = wxString_in_helper(obj1);
37735 if (arg2 == NULL) SWIG_fail;
37736 temp2 = true;
37737 }
37738 if (obj2) {
37739 arg3 = obj2;
37740 }
37741 {
37742 PyThreadState* __tstate = wxPyBeginAllowThreads();
37743 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37744
37745 wxPyEndAllowThreads(__tstate);
37746 if (PyErr_Occurred()) SWIG_fail;
37747 }
37748 {
37749 resultobj = SWIG_From_int((int)(result));
37750 }
37751 {
37752 if (temp2)
37753 delete arg2;
37754 }
37755 return resultobj;
37756 fail:
37757 {
37758 if (temp2)
37759 delete arg2;
37760 }
37761 return NULL;
37762 }
37763
37764
37765 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37766 PyObject *resultobj;
37767 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37768 wxArrayString *arg2 = 0 ;
37769 bool temp2 = false ;
37770 PyObject * obj0 = 0 ;
37771 PyObject * obj1 = 0 ;
37772 char *kwnames[] = {
37773 (char *) "self",(char *) "strings", NULL
37774 };
37775
37776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37778 if (SWIG_arg_fail(1)) SWIG_fail;
37779 {
37780 if (! PySequence_Check(obj1)) {
37781 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37782 SWIG_fail;
37783 }
37784 arg2 = new wxArrayString;
37785 temp2 = true;
37786 int i, len=PySequence_Length(obj1);
37787 for (i=0; i<len; i++) {
37788 PyObject* item = PySequence_GetItem(obj1, i);
37789 #if wxUSE_UNICODE
37790 PyObject* str = PyObject_Unicode(item);
37791 #else
37792 PyObject* str = PyObject_Str(item);
37793 #endif
37794 if (PyErr_Occurred()) SWIG_fail;
37795 arg2->Add(Py2wxString(str));
37796 Py_DECREF(item);
37797 Py_DECREF(str);
37798 }
37799 }
37800 {
37801 PyThreadState* __tstate = wxPyBeginAllowThreads();
37802 (arg1)->Append((wxArrayString const &)*arg2);
37803
37804 wxPyEndAllowThreads(__tstate);
37805 if (PyErr_Occurred()) SWIG_fail;
37806 }
37807 Py_INCREF(Py_None); resultobj = Py_None;
37808 {
37809 if (temp2) delete arg2;
37810 }
37811 return resultobj;
37812 fail:
37813 {
37814 if (temp2) delete arg2;
37815 }
37816 return NULL;
37817 }
37818
37819
37820 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37821 PyObject *resultobj;
37822 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37823 wxString *arg2 = 0 ;
37824 int arg3 ;
37825 PyObject *arg4 = (PyObject *) NULL ;
37826 int result;
37827 bool temp2 = false ;
37828 PyObject * obj0 = 0 ;
37829 PyObject * obj1 = 0 ;
37830 PyObject * obj2 = 0 ;
37831 PyObject * obj3 = 0 ;
37832 char *kwnames[] = {
37833 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37834 };
37835
37836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37838 if (SWIG_arg_fail(1)) SWIG_fail;
37839 {
37840 arg2 = wxString_in_helper(obj1);
37841 if (arg2 == NULL) SWIG_fail;
37842 temp2 = true;
37843 }
37844 {
37845 arg3 = (int)(SWIG_As_int(obj2));
37846 if (SWIG_arg_fail(3)) SWIG_fail;
37847 }
37848 if (obj3) {
37849 arg4 = obj3;
37850 }
37851 {
37852 PyThreadState* __tstate = wxPyBeginAllowThreads();
37853 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37854
37855 wxPyEndAllowThreads(__tstate);
37856 if (PyErr_Occurred()) SWIG_fail;
37857 }
37858 {
37859 resultobj = SWIG_From_int((int)(result));
37860 }
37861 {
37862 if (temp2)
37863 delete arg2;
37864 }
37865 return resultobj;
37866 fail:
37867 {
37868 if (temp2)
37869 delete arg2;
37870 }
37871 return NULL;
37872 }
37873
37874
37875 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37876 PyObject *resultobj;
37877 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37878 PyObject * obj0 = 0 ;
37879 char *kwnames[] = {
37880 (char *) "self", NULL
37881 };
37882
37883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37885 if (SWIG_arg_fail(1)) SWIG_fail;
37886 {
37887 PyThreadState* __tstate = wxPyBeginAllowThreads();
37888 (arg1)->Clear();
37889
37890 wxPyEndAllowThreads(__tstate);
37891 if (PyErr_Occurred()) SWIG_fail;
37892 }
37893 Py_INCREF(Py_None); resultobj = Py_None;
37894 return resultobj;
37895 fail:
37896 return NULL;
37897 }
37898
37899
37900 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37901 PyObject *resultobj;
37902 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37903 int arg2 ;
37904 PyObject * obj0 = 0 ;
37905 PyObject * obj1 = 0 ;
37906 char *kwnames[] = {
37907 (char *) "self",(char *) "n", NULL
37908 };
37909
37910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37912 if (SWIG_arg_fail(1)) SWIG_fail;
37913 {
37914 arg2 = (int)(SWIG_As_int(obj1));
37915 if (SWIG_arg_fail(2)) SWIG_fail;
37916 }
37917 {
37918 PyThreadState* __tstate = wxPyBeginAllowThreads();
37919 (arg1)->Delete(arg2);
37920
37921 wxPyEndAllowThreads(__tstate);
37922 if (PyErr_Occurred()) SWIG_fail;
37923 }
37924 Py_INCREF(Py_None); resultobj = Py_None;
37925 return resultobj;
37926 fail:
37927 return NULL;
37928 }
37929
37930
37931 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37932 PyObject *resultobj;
37933 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37934 int arg2 ;
37935 PyObject *result;
37936 PyObject * obj0 = 0 ;
37937 PyObject * obj1 = 0 ;
37938 char *kwnames[] = {
37939 (char *) "self",(char *) "n", NULL
37940 };
37941
37942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37944 if (SWIG_arg_fail(1)) SWIG_fail;
37945 {
37946 arg2 = (int)(SWIG_As_int(obj1));
37947 if (SWIG_arg_fail(2)) SWIG_fail;
37948 }
37949 {
37950 PyThreadState* __tstate = wxPyBeginAllowThreads();
37951 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37952
37953 wxPyEndAllowThreads(__tstate);
37954 if (PyErr_Occurred()) SWIG_fail;
37955 }
37956 resultobj = result;
37957 return resultobj;
37958 fail:
37959 return NULL;
37960 }
37961
37962
37963 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37964 PyObject *resultobj;
37965 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37966 int arg2 ;
37967 PyObject *arg3 = (PyObject *) 0 ;
37968 PyObject * obj0 = 0 ;
37969 PyObject * obj1 = 0 ;
37970 PyObject * obj2 = 0 ;
37971 char *kwnames[] = {
37972 (char *) "self",(char *) "n",(char *) "clientData", NULL
37973 };
37974
37975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37977 if (SWIG_arg_fail(1)) SWIG_fail;
37978 {
37979 arg2 = (int)(SWIG_As_int(obj1));
37980 if (SWIG_arg_fail(2)) SWIG_fail;
37981 }
37982 arg3 = obj2;
37983 {
37984 PyThreadState* __tstate = wxPyBeginAllowThreads();
37985 wxItemContainer_SetClientData(arg1,arg2,arg3);
37986
37987 wxPyEndAllowThreads(__tstate);
37988 if (PyErr_Occurred()) SWIG_fail;
37989 }
37990 Py_INCREF(Py_None); resultobj = Py_None;
37991 return resultobj;
37992 fail:
37993 return NULL;
37994 }
37995
37996
37997 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37998 PyObject *resultobj;
37999 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38000 int result;
38001 PyObject * obj0 = 0 ;
38002 char *kwnames[] = {
38003 (char *) "self", NULL
38004 };
38005
38006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38008 if (SWIG_arg_fail(1)) SWIG_fail;
38009 {
38010 PyThreadState* __tstate = wxPyBeginAllowThreads();
38011 result = (int)((wxItemContainer const *)arg1)->GetCount();
38012
38013 wxPyEndAllowThreads(__tstate);
38014 if (PyErr_Occurred()) SWIG_fail;
38015 }
38016 {
38017 resultobj = SWIG_From_int((int)(result));
38018 }
38019 return resultobj;
38020 fail:
38021 return NULL;
38022 }
38023
38024
38025 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38026 PyObject *resultobj;
38027 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38028 bool result;
38029 PyObject * obj0 = 0 ;
38030 char *kwnames[] = {
38031 (char *) "self", NULL
38032 };
38033
38034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38036 if (SWIG_arg_fail(1)) SWIG_fail;
38037 {
38038 PyThreadState* __tstate = wxPyBeginAllowThreads();
38039 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38040
38041 wxPyEndAllowThreads(__tstate);
38042 if (PyErr_Occurred()) SWIG_fail;
38043 }
38044 {
38045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38046 }
38047 return resultobj;
38048 fail:
38049 return NULL;
38050 }
38051
38052
38053 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38054 PyObject *resultobj;
38055 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38056 int arg2 ;
38057 wxString result;
38058 PyObject * obj0 = 0 ;
38059 PyObject * obj1 = 0 ;
38060 char *kwnames[] = {
38061 (char *) "self",(char *) "n", NULL
38062 };
38063
38064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38066 if (SWIG_arg_fail(1)) SWIG_fail;
38067 {
38068 arg2 = (int)(SWIG_As_int(obj1));
38069 if (SWIG_arg_fail(2)) SWIG_fail;
38070 }
38071 {
38072 PyThreadState* __tstate = wxPyBeginAllowThreads();
38073 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38074
38075 wxPyEndAllowThreads(__tstate);
38076 if (PyErr_Occurred()) SWIG_fail;
38077 }
38078 {
38079 #if wxUSE_UNICODE
38080 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38081 #else
38082 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38083 #endif
38084 }
38085 return resultobj;
38086 fail:
38087 return NULL;
38088 }
38089
38090
38091 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38092 PyObject *resultobj;
38093 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38094 wxArrayString result;
38095 PyObject * obj0 = 0 ;
38096 char *kwnames[] = {
38097 (char *) "self", NULL
38098 };
38099
38100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38102 if (SWIG_arg_fail(1)) SWIG_fail;
38103 {
38104 PyThreadState* __tstate = wxPyBeginAllowThreads();
38105 result = ((wxItemContainer const *)arg1)->GetStrings();
38106
38107 wxPyEndAllowThreads(__tstate);
38108 if (PyErr_Occurred()) SWIG_fail;
38109 }
38110 {
38111 resultobj = wxArrayString2PyList_helper(result);
38112 }
38113 return resultobj;
38114 fail:
38115 return NULL;
38116 }
38117
38118
38119 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38120 PyObject *resultobj;
38121 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38122 int arg2 ;
38123 wxString *arg3 = 0 ;
38124 bool temp3 = false ;
38125 PyObject * obj0 = 0 ;
38126 PyObject * obj1 = 0 ;
38127 PyObject * obj2 = 0 ;
38128 char *kwnames[] = {
38129 (char *) "self",(char *) "n",(char *) "s", NULL
38130 };
38131
38132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38134 if (SWIG_arg_fail(1)) SWIG_fail;
38135 {
38136 arg2 = (int)(SWIG_As_int(obj1));
38137 if (SWIG_arg_fail(2)) SWIG_fail;
38138 }
38139 {
38140 arg3 = wxString_in_helper(obj2);
38141 if (arg3 == NULL) SWIG_fail;
38142 temp3 = true;
38143 }
38144 {
38145 PyThreadState* __tstate = wxPyBeginAllowThreads();
38146 (arg1)->SetString(arg2,(wxString const &)*arg3);
38147
38148 wxPyEndAllowThreads(__tstate);
38149 if (PyErr_Occurred()) SWIG_fail;
38150 }
38151 Py_INCREF(Py_None); resultobj = Py_None;
38152 {
38153 if (temp3)
38154 delete arg3;
38155 }
38156 return resultobj;
38157 fail:
38158 {
38159 if (temp3)
38160 delete arg3;
38161 }
38162 return NULL;
38163 }
38164
38165
38166 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38167 PyObject *resultobj;
38168 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38169 wxString *arg2 = 0 ;
38170 int result;
38171 bool temp2 = false ;
38172 PyObject * obj0 = 0 ;
38173 PyObject * obj1 = 0 ;
38174 char *kwnames[] = {
38175 (char *) "self",(char *) "s", NULL
38176 };
38177
38178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38180 if (SWIG_arg_fail(1)) SWIG_fail;
38181 {
38182 arg2 = wxString_in_helper(obj1);
38183 if (arg2 == NULL) SWIG_fail;
38184 temp2 = true;
38185 }
38186 {
38187 PyThreadState* __tstate = wxPyBeginAllowThreads();
38188 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38189
38190 wxPyEndAllowThreads(__tstate);
38191 if (PyErr_Occurred()) SWIG_fail;
38192 }
38193 {
38194 resultobj = SWIG_From_int((int)(result));
38195 }
38196 {
38197 if (temp2)
38198 delete arg2;
38199 }
38200 return resultobj;
38201 fail:
38202 {
38203 if (temp2)
38204 delete arg2;
38205 }
38206 return NULL;
38207 }
38208
38209
38210 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38211 PyObject *resultobj;
38212 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38213 int arg2 ;
38214 PyObject * obj0 = 0 ;
38215 PyObject * obj1 = 0 ;
38216 char *kwnames[] = {
38217 (char *) "self",(char *) "n", NULL
38218 };
38219
38220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38222 if (SWIG_arg_fail(1)) SWIG_fail;
38223 {
38224 arg2 = (int)(SWIG_As_int(obj1));
38225 if (SWIG_arg_fail(2)) SWIG_fail;
38226 }
38227 {
38228 PyThreadState* __tstate = wxPyBeginAllowThreads();
38229 (arg1)->SetSelection(arg2);
38230
38231 wxPyEndAllowThreads(__tstate);
38232 if (PyErr_Occurred()) SWIG_fail;
38233 }
38234 Py_INCREF(Py_None); resultobj = Py_None;
38235 return resultobj;
38236 fail:
38237 return NULL;
38238 }
38239
38240
38241 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38242 PyObject *resultobj;
38243 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38244 int result;
38245 PyObject * obj0 = 0 ;
38246 char *kwnames[] = {
38247 (char *) "self", NULL
38248 };
38249
38250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38252 if (SWIG_arg_fail(1)) SWIG_fail;
38253 {
38254 PyThreadState* __tstate = wxPyBeginAllowThreads();
38255 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38256
38257 wxPyEndAllowThreads(__tstate);
38258 if (PyErr_Occurred()) SWIG_fail;
38259 }
38260 {
38261 resultobj = SWIG_From_int((int)(result));
38262 }
38263 return resultobj;
38264 fail:
38265 return NULL;
38266 }
38267
38268
38269 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38270 PyObject *resultobj;
38271 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38272 wxString *arg2 = 0 ;
38273 bool result;
38274 bool temp2 = false ;
38275 PyObject * obj0 = 0 ;
38276 PyObject * obj1 = 0 ;
38277 char *kwnames[] = {
38278 (char *) "self",(char *) "s", NULL
38279 };
38280
38281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38283 if (SWIG_arg_fail(1)) SWIG_fail;
38284 {
38285 arg2 = wxString_in_helper(obj1);
38286 if (arg2 == NULL) SWIG_fail;
38287 temp2 = true;
38288 }
38289 {
38290 PyThreadState* __tstate = wxPyBeginAllowThreads();
38291 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38292
38293 wxPyEndAllowThreads(__tstate);
38294 if (PyErr_Occurred()) SWIG_fail;
38295 }
38296 {
38297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38298 }
38299 {
38300 if (temp2)
38301 delete arg2;
38302 }
38303 return resultobj;
38304 fail:
38305 {
38306 if (temp2)
38307 delete arg2;
38308 }
38309 return NULL;
38310 }
38311
38312
38313 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38314 PyObject *resultobj;
38315 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38316 wxString result;
38317 PyObject * obj0 = 0 ;
38318 char *kwnames[] = {
38319 (char *) "self", NULL
38320 };
38321
38322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38324 if (SWIG_arg_fail(1)) SWIG_fail;
38325 {
38326 PyThreadState* __tstate = wxPyBeginAllowThreads();
38327 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38328
38329 wxPyEndAllowThreads(__tstate);
38330 if (PyErr_Occurred()) SWIG_fail;
38331 }
38332 {
38333 #if wxUSE_UNICODE
38334 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38335 #else
38336 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38337 #endif
38338 }
38339 return resultobj;
38340 fail:
38341 return NULL;
38342 }
38343
38344
38345 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38346 PyObject *resultobj;
38347 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38348 int arg2 ;
38349 PyObject * obj0 = 0 ;
38350 PyObject * obj1 = 0 ;
38351 char *kwnames[] = {
38352 (char *) "self",(char *) "n", NULL
38353 };
38354
38355 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38356 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38357 if (SWIG_arg_fail(1)) SWIG_fail;
38358 {
38359 arg2 = (int)(SWIG_As_int(obj1));
38360 if (SWIG_arg_fail(2)) SWIG_fail;
38361 }
38362 {
38363 PyThreadState* __tstate = wxPyBeginAllowThreads();
38364 (arg1)->Select(arg2);
38365
38366 wxPyEndAllowThreads(__tstate);
38367 if (PyErr_Occurred()) SWIG_fail;
38368 }
38369 Py_INCREF(Py_None); resultobj = Py_None;
38370 return resultobj;
38371 fail:
38372 return NULL;
38373 }
38374
38375
38376 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
38377 PyObject *obj;
38378 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38379 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38380 Py_INCREF(obj);
38381 return Py_BuildValue((char *)"");
38382 }
38383 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
38384 PyObject *obj;
38385 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38386 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38387 Py_INCREF(obj);
38388 return Py_BuildValue((char *)"");
38389 }
38390 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38391 PyObject *resultobj;
38392 wxSizerItem *result;
38393 char *kwnames[] = {
38394 NULL
38395 };
38396
38397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
38398 {
38399 PyThreadState* __tstate = wxPyBeginAllowThreads();
38400 result = (wxSizerItem *)new wxSizerItem();
38401
38402 wxPyEndAllowThreads(__tstate);
38403 if (PyErr_Occurred()) SWIG_fail;
38404 }
38405 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38406 return resultobj;
38407 fail:
38408 return NULL;
38409 }
38410
38411
38412 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38413 PyObject *resultobj;
38414 wxWindow *arg1 = (wxWindow *) 0 ;
38415 int arg2 ;
38416 int arg3 ;
38417 int arg4 ;
38418 PyObject *arg5 = (PyObject *) NULL ;
38419 wxSizerItem *result;
38420 PyObject * obj0 = 0 ;
38421 PyObject * obj1 = 0 ;
38422 PyObject * obj2 = 0 ;
38423 PyObject * obj3 = 0 ;
38424 PyObject * obj4 = 0 ;
38425 char *kwnames[] = {
38426 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38427 };
38428
38429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38431 if (SWIG_arg_fail(1)) SWIG_fail;
38432 {
38433 arg2 = (int)(SWIG_As_int(obj1));
38434 if (SWIG_arg_fail(2)) SWIG_fail;
38435 }
38436 {
38437 arg3 = (int)(SWIG_As_int(obj2));
38438 if (SWIG_arg_fail(3)) SWIG_fail;
38439 }
38440 {
38441 arg4 = (int)(SWIG_As_int(obj3));
38442 if (SWIG_arg_fail(4)) SWIG_fail;
38443 }
38444 if (obj4) {
38445 arg5 = obj4;
38446 }
38447 {
38448 PyThreadState* __tstate = wxPyBeginAllowThreads();
38449 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38450
38451 wxPyEndAllowThreads(__tstate);
38452 if (PyErr_Occurred()) SWIG_fail;
38453 }
38454 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38455 return resultobj;
38456 fail:
38457 return NULL;
38458 }
38459
38460
38461 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38462 PyObject *resultobj;
38463 int arg1 ;
38464 int arg2 ;
38465 int arg3 ;
38466 int arg4 ;
38467 int arg5 ;
38468 PyObject *arg6 = (PyObject *) NULL ;
38469 wxSizerItem *result;
38470 PyObject * obj0 = 0 ;
38471 PyObject * obj1 = 0 ;
38472 PyObject * obj2 = 0 ;
38473 PyObject * obj3 = 0 ;
38474 PyObject * obj4 = 0 ;
38475 PyObject * obj5 = 0 ;
38476 char *kwnames[] = {
38477 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38478 };
38479
38480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38481 {
38482 arg1 = (int)(SWIG_As_int(obj0));
38483 if (SWIG_arg_fail(1)) SWIG_fail;
38484 }
38485 {
38486 arg2 = (int)(SWIG_As_int(obj1));
38487 if (SWIG_arg_fail(2)) SWIG_fail;
38488 }
38489 {
38490 arg3 = (int)(SWIG_As_int(obj2));
38491 if (SWIG_arg_fail(3)) SWIG_fail;
38492 }
38493 {
38494 arg4 = (int)(SWIG_As_int(obj3));
38495 if (SWIG_arg_fail(4)) SWIG_fail;
38496 }
38497 {
38498 arg5 = (int)(SWIG_As_int(obj4));
38499 if (SWIG_arg_fail(5)) SWIG_fail;
38500 }
38501 if (obj5) {
38502 arg6 = obj5;
38503 }
38504 {
38505 PyThreadState* __tstate = wxPyBeginAllowThreads();
38506 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38507
38508 wxPyEndAllowThreads(__tstate);
38509 if (PyErr_Occurred()) SWIG_fail;
38510 }
38511 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38512 return resultobj;
38513 fail:
38514 return NULL;
38515 }
38516
38517
38518 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38519 PyObject *resultobj;
38520 wxSizer *arg1 = (wxSizer *) 0 ;
38521 int arg2 ;
38522 int arg3 ;
38523 int arg4 ;
38524 PyObject *arg5 = (PyObject *) NULL ;
38525 wxSizerItem *result;
38526 PyObject * obj0 = 0 ;
38527 PyObject * obj1 = 0 ;
38528 PyObject * obj2 = 0 ;
38529 PyObject * obj3 = 0 ;
38530 PyObject * obj4 = 0 ;
38531 char *kwnames[] = {
38532 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38533 };
38534
38535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38537 if (SWIG_arg_fail(1)) SWIG_fail;
38538 {
38539 arg2 = (int)(SWIG_As_int(obj1));
38540 if (SWIG_arg_fail(2)) SWIG_fail;
38541 }
38542 {
38543 arg3 = (int)(SWIG_As_int(obj2));
38544 if (SWIG_arg_fail(3)) SWIG_fail;
38545 }
38546 {
38547 arg4 = (int)(SWIG_As_int(obj3));
38548 if (SWIG_arg_fail(4)) SWIG_fail;
38549 }
38550 if (obj4) {
38551 arg5 = obj4;
38552 }
38553 {
38554 PyThreadState* __tstate = wxPyBeginAllowThreads();
38555 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38556
38557 wxPyEndAllowThreads(__tstate);
38558 if (PyErr_Occurred()) SWIG_fail;
38559 }
38560 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38561 return resultobj;
38562 fail:
38563 return NULL;
38564 }
38565
38566
38567 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38568 PyObject *resultobj;
38569 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38570 PyObject * obj0 = 0 ;
38571 char *kwnames[] = {
38572 (char *) "self", NULL
38573 };
38574
38575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38577 if (SWIG_arg_fail(1)) SWIG_fail;
38578 {
38579 PyThreadState* __tstate = wxPyBeginAllowThreads();
38580 (arg1)->DeleteWindows();
38581
38582 wxPyEndAllowThreads(__tstate);
38583 if (PyErr_Occurred()) SWIG_fail;
38584 }
38585 Py_INCREF(Py_None); resultobj = Py_None;
38586 return resultobj;
38587 fail:
38588 return NULL;
38589 }
38590
38591
38592 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38593 PyObject *resultobj;
38594 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38595 PyObject * obj0 = 0 ;
38596 char *kwnames[] = {
38597 (char *) "self", NULL
38598 };
38599
38600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38602 if (SWIG_arg_fail(1)) SWIG_fail;
38603 {
38604 PyThreadState* __tstate = wxPyBeginAllowThreads();
38605 (arg1)->DetachSizer();
38606
38607 wxPyEndAllowThreads(__tstate);
38608 if (PyErr_Occurred()) SWIG_fail;
38609 }
38610 Py_INCREF(Py_None); resultobj = Py_None;
38611 return resultobj;
38612 fail:
38613 return NULL;
38614 }
38615
38616
38617 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38618 PyObject *resultobj;
38619 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38620 wxSize result;
38621 PyObject * obj0 = 0 ;
38622 char *kwnames[] = {
38623 (char *) "self", NULL
38624 };
38625
38626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38628 if (SWIG_arg_fail(1)) SWIG_fail;
38629 {
38630 PyThreadState* __tstate = wxPyBeginAllowThreads();
38631 result = (arg1)->GetSize();
38632
38633 wxPyEndAllowThreads(__tstate);
38634 if (PyErr_Occurred()) SWIG_fail;
38635 }
38636 {
38637 wxSize * resultptr;
38638 resultptr = new wxSize((wxSize &)(result));
38639 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38640 }
38641 return resultobj;
38642 fail:
38643 return NULL;
38644 }
38645
38646
38647 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38648 PyObject *resultobj;
38649 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38650 wxSize result;
38651 PyObject * obj0 = 0 ;
38652 char *kwnames[] = {
38653 (char *) "self", NULL
38654 };
38655
38656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38658 if (SWIG_arg_fail(1)) SWIG_fail;
38659 {
38660 PyThreadState* __tstate = wxPyBeginAllowThreads();
38661 result = (arg1)->CalcMin();
38662
38663 wxPyEndAllowThreads(__tstate);
38664 if (PyErr_Occurred()) SWIG_fail;
38665 }
38666 {
38667 wxSize * resultptr;
38668 resultptr = new wxSize((wxSize &)(result));
38669 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38670 }
38671 return resultobj;
38672 fail:
38673 return NULL;
38674 }
38675
38676
38677 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38678 PyObject *resultobj;
38679 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38680 wxPoint arg2 ;
38681 wxSize arg3 ;
38682 PyObject * obj0 = 0 ;
38683 PyObject * obj1 = 0 ;
38684 PyObject * obj2 = 0 ;
38685 char *kwnames[] = {
38686 (char *) "self",(char *) "pos",(char *) "size", NULL
38687 };
38688
38689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38691 if (SWIG_arg_fail(1)) SWIG_fail;
38692 {
38693 wxPoint * argp;
38694 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38695 if (SWIG_arg_fail(2)) SWIG_fail;
38696 if (argp == NULL) {
38697 SWIG_null_ref("wxPoint");
38698 }
38699 if (SWIG_arg_fail(2)) SWIG_fail;
38700 arg2 = *argp;
38701 }
38702 {
38703 wxSize * argp;
38704 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38705 if (SWIG_arg_fail(3)) SWIG_fail;
38706 if (argp == NULL) {
38707 SWIG_null_ref("wxSize");
38708 }
38709 if (SWIG_arg_fail(3)) SWIG_fail;
38710 arg3 = *argp;
38711 }
38712 {
38713 PyThreadState* __tstate = wxPyBeginAllowThreads();
38714 (arg1)->SetDimension(arg2,arg3);
38715
38716 wxPyEndAllowThreads(__tstate);
38717 if (PyErr_Occurred()) SWIG_fail;
38718 }
38719 Py_INCREF(Py_None); resultobj = Py_None;
38720 return resultobj;
38721 fail:
38722 return NULL;
38723 }
38724
38725
38726 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38727 PyObject *resultobj;
38728 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38729 wxSize result;
38730 PyObject * obj0 = 0 ;
38731 char *kwnames[] = {
38732 (char *) "self", NULL
38733 };
38734
38735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38737 if (SWIG_arg_fail(1)) SWIG_fail;
38738 {
38739 PyThreadState* __tstate = wxPyBeginAllowThreads();
38740 result = (arg1)->GetMinSize();
38741
38742 wxPyEndAllowThreads(__tstate);
38743 if (PyErr_Occurred()) SWIG_fail;
38744 }
38745 {
38746 wxSize * resultptr;
38747 resultptr = new wxSize((wxSize &)(result));
38748 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38749 }
38750 return resultobj;
38751 fail:
38752 return NULL;
38753 }
38754
38755
38756 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38757 PyObject *resultobj;
38758 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38759 wxSize result;
38760 PyObject * obj0 = 0 ;
38761 char *kwnames[] = {
38762 (char *) "self", NULL
38763 };
38764
38765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38767 if (SWIG_arg_fail(1)) SWIG_fail;
38768 {
38769 PyThreadState* __tstate = wxPyBeginAllowThreads();
38770 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38771
38772 wxPyEndAllowThreads(__tstate);
38773 if (PyErr_Occurred()) SWIG_fail;
38774 }
38775 {
38776 wxSize * resultptr;
38777 resultptr = new wxSize((wxSize &)(result));
38778 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38779 }
38780 return resultobj;
38781 fail:
38782 return NULL;
38783 }
38784
38785
38786 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38787 PyObject *resultobj;
38788 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38789 int arg2 ;
38790 int arg3 ;
38791 PyObject * obj0 = 0 ;
38792 PyObject * obj1 = 0 ;
38793 PyObject * obj2 = 0 ;
38794 char *kwnames[] = {
38795 (char *) "self",(char *) "x",(char *) "y", NULL
38796 };
38797
38798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38800 if (SWIG_arg_fail(1)) SWIG_fail;
38801 {
38802 arg2 = (int)(SWIG_As_int(obj1));
38803 if (SWIG_arg_fail(2)) SWIG_fail;
38804 }
38805 {
38806 arg3 = (int)(SWIG_As_int(obj2));
38807 if (SWIG_arg_fail(3)) SWIG_fail;
38808 }
38809 {
38810 PyThreadState* __tstate = wxPyBeginAllowThreads();
38811 (arg1)->SetInitSize(arg2,arg3);
38812
38813 wxPyEndAllowThreads(__tstate);
38814 if (PyErr_Occurred()) SWIG_fail;
38815 }
38816 Py_INCREF(Py_None); resultobj = Py_None;
38817 return resultobj;
38818 fail:
38819 return NULL;
38820 }
38821
38822
38823 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38824 PyObject *resultobj;
38825 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38826 int arg2 ;
38827 int arg3 ;
38828 PyObject * obj0 = 0 ;
38829 PyObject * obj1 = 0 ;
38830 PyObject * obj2 = 0 ;
38831 char *kwnames[] = {
38832 (char *) "self",(char *) "width",(char *) "height", NULL
38833 };
38834
38835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38837 if (SWIG_arg_fail(1)) SWIG_fail;
38838 {
38839 arg2 = (int)(SWIG_As_int(obj1));
38840 if (SWIG_arg_fail(2)) SWIG_fail;
38841 }
38842 {
38843 arg3 = (int)(SWIG_As_int(obj2));
38844 if (SWIG_arg_fail(3)) SWIG_fail;
38845 }
38846 {
38847 PyThreadState* __tstate = wxPyBeginAllowThreads();
38848 (arg1)->SetRatio(arg2,arg3);
38849
38850 wxPyEndAllowThreads(__tstate);
38851 if (PyErr_Occurred()) SWIG_fail;
38852 }
38853 Py_INCREF(Py_None); resultobj = Py_None;
38854 return resultobj;
38855 fail:
38856 return NULL;
38857 }
38858
38859
38860 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38861 PyObject *resultobj;
38862 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38863 wxSize *arg2 = 0 ;
38864 wxSize temp2 ;
38865 PyObject * obj0 = 0 ;
38866 PyObject * obj1 = 0 ;
38867 char *kwnames[] = {
38868 (char *) "self",(char *) "size", NULL
38869 };
38870
38871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38873 if (SWIG_arg_fail(1)) SWIG_fail;
38874 {
38875 arg2 = &temp2;
38876 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38877 }
38878 {
38879 PyThreadState* __tstate = wxPyBeginAllowThreads();
38880 (arg1)->SetRatio((wxSize const &)*arg2);
38881
38882 wxPyEndAllowThreads(__tstate);
38883 if (PyErr_Occurred()) SWIG_fail;
38884 }
38885 Py_INCREF(Py_None); resultobj = Py_None;
38886 return resultobj;
38887 fail:
38888 return NULL;
38889 }
38890
38891
38892 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38893 PyObject *resultobj;
38894 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38895 float arg2 ;
38896 PyObject * obj0 = 0 ;
38897 PyObject * obj1 = 0 ;
38898 char *kwnames[] = {
38899 (char *) "self",(char *) "ratio", NULL
38900 };
38901
38902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38904 if (SWIG_arg_fail(1)) SWIG_fail;
38905 {
38906 arg2 = (float)(SWIG_As_float(obj1));
38907 if (SWIG_arg_fail(2)) SWIG_fail;
38908 }
38909 {
38910 PyThreadState* __tstate = wxPyBeginAllowThreads();
38911 (arg1)->SetRatio(arg2);
38912
38913 wxPyEndAllowThreads(__tstate);
38914 if (PyErr_Occurred()) SWIG_fail;
38915 }
38916 Py_INCREF(Py_None); resultobj = Py_None;
38917 return resultobj;
38918 fail:
38919 return NULL;
38920 }
38921
38922
38923 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38924 PyObject *resultobj;
38925 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38926 float result;
38927 PyObject * obj0 = 0 ;
38928 char *kwnames[] = {
38929 (char *) "self", NULL
38930 };
38931
38932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38934 if (SWIG_arg_fail(1)) SWIG_fail;
38935 {
38936 PyThreadState* __tstate = wxPyBeginAllowThreads();
38937 result = (float)(arg1)->GetRatio();
38938
38939 wxPyEndAllowThreads(__tstate);
38940 if (PyErr_Occurred()) SWIG_fail;
38941 }
38942 {
38943 resultobj = SWIG_From_float((float)(result));
38944 }
38945 return resultobj;
38946 fail:
38947 return NULL;
38948 }
38949
38950
38951 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38952 PyObject *resultobj;
38953 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38954 wxRect result;
38955 PyObject * obj0 = 0 ;
38956 char *kwnames[] = {
38957 (char *) "self", NULL
38958 };
38959
38960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38962 if (SWIG_arg_fail(1)) SWIG_fail;
38963 {
38964 PyThreadState* __tstate = wxPyBeginAllowThreads();
38965 result = (arg1)->GetRect();
38966
38967 wxPyEndAllowThreads(__tstate);
38968 if (PyErr_Occurred()) SWIG_fail;
38969 }
38970 {
38971 wxRect * resultptr;
38972 resultptr = new wxRect((wxRect &)(result));
38973 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38974 }
38975 return resultobj;
38976 fail:
38977 return NULL;
38978 }
38979
38980
38981 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38982 PyObject *resultobj;
38983 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38984 bool result;
38985 PyObject * obj0 = 0 ;
38986 char *kwnames[] = {
38987 (char *) "self", NULL
38988 };
38989
38990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38992 if (SWIG_arg_fail(1)) SWIG_fail;
38993 {
38994 PyThreadState* __tstate = wxPyBeginAllowThreads();
38995 result = (bool)(arg1)->IsWindow();
38996
38997 wxPyEndAllowThreads(__tstate);
38998 if (PyErr_Occurred()) SWIG_fail;
38999 }
39000 {
39001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39002 }
39003 return resultobj;
39004 fail:
39005 return NULL;
39006 }
39007
39008
39009 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39010 PyObject *resultobj;
39011 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39012 bool result;
39013 PyObject * obj0 = 0 ;
39014 char *kwnames[] = {
39015 (char *) "self", NULL
39016 };
39017
39018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39020 if (SWIG_arg_fail(1)) SWIG_fail;
39021 {
39022 PyThreadState* __tstate = wxPyBeginAllowThreads();
39023 result = (bool)(arg1)->IsSizer();
39024
39025 wxPyEndAllowThreads(__tstate);
39026 if (PyErr_Occurred()) SWIG_fail;
39027 }
39028 {
39029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39030 }
39031 return resultobj;
39032 fail:
39033 return NULL;
39034 }
39035
39036
39037 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39038 PyObject *resultobj;
39039 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39040 bool result;
39041 PyObject * obj0 = 0 ;
39042 char *kwnames[] = {
39043 (char *) "self", NULL
39044 };
39045
39046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39048 if (SWIG_arg_fail(1)) SWIG_fail;
39049 {
39050 PyThreadState* __tstate = wxPyBeginAllowThreads();
39051 result = (bool)(arg1)->IsSpacer();
39052
39053 wxPyEndAllowThreads(__tstate);
39054 if (PyErr_Occurred()) SWIG_fail;
39055 }
39056 {
39057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39058 }
39059 return resultobj;
39060 fail:
39061 return NULL;
39062 }
39063
39064
39065 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39066 PyObject *resultobj;
39067 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39068 int arg2 ;
39069 PyObject * obj0 = 0 ;
39070 PyObject * obj1 = 0 ;
39071 char *kwnames[] = {
39072 (char *) "self",(char *) "proportion", NULL
39073 };
39074
39075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39077 if (SWIG_arg_fail(1)) SWIG_fail;
39078 {
39079 arg2 = (int)(SWIG_As_int(obj1));
39080 if (SWIG_arg_fail(2)) SWIG_fail;
39081 }
39082 {
39083 PyThreadState* __tstate = wxPyBeginAllowThreads();
39084 (arg1)->SetProportion(arg2);
39085
39086 wxPyEndAllowThreads(__tstate);
39087 if (PyErr_Occurred()) SWIG_fail;
39088 }
39089 Py_INCREF(Py_None); resultobj = Py_None;
39090 return resultobj;
39091 fail:
39092 return NULL;
39093 }
39094
39095
39096 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39097 PyObject *resultobj;
39098 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39099 int result;
39100 PyObject * obj0 = 0 ;
39101 char *kwnames[] = {
39102 (char *) "self", NULL
39103 };
39104
39105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39107 if (SWIG_arg_fail(1)) SWIG_fail;
39108 {
39109 PyThreadState* __tstate = wxPyBeginAllowThreads();
39110 result = (int)(arg1)->GetProportion();
39111
39112 wxPyEndAllowThreads(__tstate);
39113 if (PyErr_Occurred()) SWIG_fail;
39114 }
39115 {
39116 resultobj = SWIG_From_int((int)(result));
39117 }
39118 return resultobj;
39119 fail:
39120 return NULL;
39121 }
39122
39123
39124 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39125 PyObject *resultobj;
39126 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39127 int arg2 ;
39128 PyObject * obj0 = 0 ;
39129 PyObject * obj1 = 0 ;
39130 char *kwnames[] = {
39131 (char *) "self",(char *) "flag", NULL
39132 };
39133
39134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39136 if (SWIG_arg_fail(1)) SWIG_fail;
39137 {
39138 arg2 = (int)(SWIG_As_int(obj1));
39139 if (SWIG_arg_fail(2)) SWIG_fail;
39140 }
39141 {
39142 PyThreadState* __tstate = wxPyBeginAllowThreads();
39143 (arg1)->SetFlag(arg2);
39144
39145 wxPyEndAllowThreads(__tstate);
39146 if (PyErr_Occurred()) SWIG_fail;
39147 }
39148 Py_INCREF(Py_None); resultobj = Py_None;
39149 return resultobj;
39150 fail:
39151 return NULL;
39152 }
39153
39154
39155 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39156 PyObject *resultobj;
39157 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39158 int result;
39159 PyObject * obj0 = 0 ;
39160 char *kwnames[] = {
39161 (char *) "self", NULL
39162 };
39163
39164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39166 if (SWIG_arg_fail(1)) SWIG_fail;
39167 {
39168 PyThreadState* __tstate = wxPyBeginAllowThreads();
39169 result = (int)(arg1)->GetFlag();
39170
39171 wxPyEndAllowThreads(__tstate);
39172 if (PyErr_Occurred()) SWIG_fail;
39173 }
39174 {
39175 resultobj = SWIG_From_int((int)(result));
39176 }
39177 return resultobj;
39178 fail:
39179 return NULL;
39180 }
39181
39182
39183 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39184 PyObject *resultobj;
39185 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39186 int arg2 ;
39187 PyObject * obj0 = 0 ;
39188 PyObject * obj1 = 0 ;
39189 char *kwnames[] = {
39190 (char *) "self",(char *) "border", NULL
39191 };
39192
39193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39195 if (SWIG_arg_fail(1)) SWIG_fail;
39196 {
39197 arg2 = (int)(SWIG_As_int(obj1));
39198 if (SWIG_arg_fail(2)) SWIG_fail;
39199 }
39200 {
39201 PyThreadState* __tstate = wxPyBeginAllowThreads();
39202 (arg1)->SetBorder(arg2);
39203
39204 wxPyEndAllowThreads(__tstate);
39205 if (PyErr_Occurred()) SWIG_fail;
39206 }
39207 Py_INCREF(Py_None); resultobj = Py_None;
39208 return resultobj;
39209 fail:
39210 return NULL;
39211 }
39212
39213
39214 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39215 PyObject *resultobj;
39216 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39217 int result;
39218 PyObject * obj0 = 0 ;
39219 char *kwnames[] = {
39220 (char *) "self", NULL
39221 };
39222
39223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39225 if (SWIG_arg_fail(1)) SWIG_fail;
39226 {
39227 PyThreadState* __tstate = wxPyBeginAllowThreads();
39228 result = (int)(arg1)->GetBorder();
39229
39230 wxPyEndAllowThreads(__tstate);
39231 if (PyErr_Occurred()) SWIG_fail;
39232 }
39233 {
39234 resultobj = SWIG_From_int((int)(result));
39235 }
39236 return resultobj;
39237 fail:
39238 return NULL;
39239 }
39240
39241
39242 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39243 PyObject *resultobj;
39244 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39245 wxWindow *result;
39246 PyObject * obj0 = 0 ;
39247 char *kwnames[] = {
39248 (char *) "self", NULL
39249 };
39250
39251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39253 if (SWIG_arg_fail(1)) SWIG_fail;
39254 {
39255 PyThreadState* __tstate = wxPyBeginAllowThreads();
39256 result = (wxWindow *)(arg1)->GetWindow();
39257
39258 wxPyEndAllowThreads(__tstate);
39259 if (PyErr_Occurred()) SWIG_fail;
39260 }
39261 {
39262 resultobj = wxPyMake_wxObject(result, 0);
39263 }
39264 return resultobj;
39265 fail:
39266 return NULL;
39267 }
39268
39269
39270 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39271 PyObject *resultobj;
39272 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39273 wxWindow *arg2 = (wxWindow *) 0 ;
39274 PyObject * obj0 = 0 ;
39275 PyObject * obj1 = 0 ;
39276 char *kwnames[] = {
39277 (char *) "self",(char *) "window", NULL
39278 };
39279
39280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39282 if (SWIG_arg_fail(1)) SWIG_fail;
39283 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39284 if (SWIG_arg_fail(2)) SWIG_fail;
39285 {
39286 PyThreadState* __tstate = wxPyBeginAllowThreads();
39287 (arg1)->SetWindow(arg2);
39288
39289 wxPyEndAllowThreads(__tstate);
39290 if (PyErr_Occurred()) SWIG_fail;
39291 }
39292 Py_INCREF(Py_None); resultobj = Py_None;
39293 return resultobj;
39294 fail:
39295 return NULL;
39296 }
39297
39298
39299 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39300 PyObject *resultobj;
39301 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39302 wxSizer *result;
39303 PyObject * obj0 = 0 ;
39304 char *kwnames[] = {
39305 (char *) "self", NULL
39306 };
39307
39308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39310 if (SWIG_arg_fail(1)) SWIG_fail;
39311 {
39312 PyThreadState* __tstate = wxPyBeginAllowThreads();
39313 result = (wxSizer *)(arg1)->GetSizer();
39314
39315 wxPyEndAllowThreads(__tstate);
39316 if (PyErr_Occurred()) SWIG_fail;
39317 }
39318 {
39319 resultobj = wxPyMake_wxSizer(result, 0);
39320 }
39321 return resultobj;
39322 fail:
39323 return NULL;
39324 }
39325
39326
39327 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39328 PyObject *resultobj;
39329 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39330 wxSizer *arg2 = (wxSizer *) 0 ;
39331 PyObject * obj0 = 0 ;
39332 PyObject * obj1 = 0 ;
39333 char *kwnames[] = {
39334 (char *) "self",(char *) "sizer", NULL
39335 };
39336
39337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39339 if (SWIG_arg_fail(1)) SWIG_fail;
39340 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39341 if (SWIG_arg_fail(2)) SWIG_fail;
39342 {
39343 PyThreadState* __tstate = wxPyBeginAllowThreads();
39344 (arg1)->SetSizer(arg2);
39345
39346 wxPyEndAllowThreads(__tstate);
39347 if (PyErr_Occurred()) SWIG_fail;
39348 }
39349 Py_INCREF(Py_None); resultobj = Py_None;
39350 return resultobj;
39351 fail:
39352 return NULL;
39353 }
39354
39355
39356 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39357 PyObject *resultobj;
39358 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39359 wxSize *result;
39360 PyObject * obj0 = 0 ;
39361 char *kwnames[] = {
39362 (char *) "self", NULL
39363 };
39364
39365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39367 if (SWIG_arg_fail(1)) SWIG_fail;
39368 {
39369 PyThreadState* __tstate = wxPyBeginAllowThreads();
39370 {
39371 wxSize const &_result_ref = (arg1)->GetSpacer();
39372 result = (wxSize *) &_result_ref;
39373 }
39374
39375 wxPyEndAllowThreads(__tstate);
39376 if (PyErr_Occurred()) SWIG_fail;
39377 }
39378 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39379 return resultobj;
39380 fail:
39381 return NULL;
39382 }
39383
39384
39385 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39386 PyObject *resultobj;
39387 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39388 wxSize *arg2 = 0 ;
39389 wxSize temp2 ;
39390 PyObject * obj0 = 0 ;
39391 PyObject * obj1 = 0 ;
39392 char *kwnames[] = {
39393 (char *) "self",(char *) "size", NULL
39394 };
39395
39396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39398 if (SWIG_arg_fail(1)) SWIG_fail;
39399 {
39400 arg2 = &temp2;
39401 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39402 }
39403 {
39404 PyThreadState* __tstate = wxPyBeginAllowThreads();
39405 (arg1)->SetSpacer((wxSize const &)*arg2);
39406
39407 wxPyEndAllowThreads(__tstate);
39408 if (PyErr_Occurred()) SWIG_fail;
39409 }
39410 Py_INCREF(Py_None); resultobj = Py_None;
39411 return resultobj;
39412 fail:
39413 return NULL;
39414 }
39415
39416
39417 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39418 PyObject *resultobj;
39419 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39420 bool arg2 ;
39421 PyObject * obj0 = 0 ;
39422 PyObject * obj1 = 0 ;
39423 char *kwnames[] = {
39424 (char *) "self",(char *) "show", NULL
39425 };
39426
39427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39429 if (SWIG_arg_fail(1)) SWIG_fail;
39430 {
39431 arg2 = (bool)(SWIG_As_bool(obj1));
39432 if (SWIG_arg_fail(2)) SWIG_fail;
39433 }
39434 {
39435 PyThreadState* __tstate = wxPyBeginAllowThreads();
39436 (arg1)->Show(arg2);
39437
39438 wxPyEndAllowThreads(__tstate);
39439 if (PyErr_Occurred()) SWIG_fail;
39440 }
39441 Py_INCREF(Py_None); resultobj = Py_None;
39442 return resultobj;
39443 fail:
39444 return NULL;
39445 }
39446
39447
39448 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39449 PyObject *resultobj;
39450 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39451 bool result;
39452 PyObject * obj0 = 0 ;
39453 char *kwnames[] = {
39454 (char *) "self", NULL
39455 };
39456
39457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39459 if (SWIG_arg_fail(1)) SWIG_fail;
39460 {
39461 PyThreadState* __tstate = wxPyBeginAllowThreads();
39462 result = (bool)(arg1)->IsShown();
39463
39464 wxPyEndAllowThreads(__tstate);
39465 if (PyErr_Occurred()) SWIG_fail;
39466 }
39467 {
39468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39469 }
39470 return resultobj;
39471 fail:
39472 return NULL;
39473 }
39474
39475
39476 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39477 PyObject *resultobj;
39478 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39479 wxPoint result;
39480 PyObject * obj0 = 0 ;
39481 char *kwnames[] = {
39482 (char *) "self", NULL
39483 };
39484
39485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39487 if (SWIG_arg_fail(1)) SWIG_fail;
39488 {
39489 PyThreadState* __tstate = wxPyBeginAllowThreads();
39490 result = (arg1)->GetPosition();
39491
39492 wxPyEndAllowThreads(__tstate);
39493 if (PyErr_Occurred()) SWIG_fail;
39494 }
39495 {
39496 wxPoint * resultptr;
39497 resultptr = new wxPoint((wxPoint &)(result));
39498 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39499 }
39500 return resultobj;
39501 fail:
39502 return NULL;
39503 }
39504
39505
39506 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39507 PyObject *resultobj;
39508 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39509 PyObject *result;
39510 PyObject * obj0 = 0 ;
39511 char *kwnames[] = {
39512 (char *) "self", NULL
39513 };
39514
39515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39517 if (SWIG_arg_fail(1)) SWIG_fail;
39518 {
39519 PyThreadState* __tstate = wxPyBeginAllowThreads();
39520 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39521
39522 wxPyEndAllowThreads(__tstate);
39523 if (PyErr_Occurred()) SWIG_fail;
39524 }
39525 resultobj = result;
39526 return resultobj;
39527 fail:
39528 return NULL;
39529 }
39530
39531
39532 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39533 PyObject *obj;
39534 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39535 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39536 Py_INCREF(obj);
39537 return Py_BuildValue((char *)"");
39538 }
39539 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39540 PyObject *resultobj;
39541 wxSizer *arg1 = (wxSizer *) 0 ;
39542 PyObject *arg2 = (PyObject *) 0 ;
39543 PyObject * obj0 = 0 ;
39544 PyObject * obj1 = 0 ;
39545 char *kwnames[] = {
39546 (char *) "self",(char *) "_self", NULL
39547 };
39548
39549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39551 if (SWIG_arg_fail(1)) SWIG_fail;
39552 arg2 = obj1;
39553 {
39554 PyThreadState* __tstate = wxPyBeginAllowThreads();
39555 wxSizer__setOORInfo(arg1,arg2);
39556
39557 wxPyEndAllowThreads(__tstate);
39558 if (PyErr_Occurred()) SWIG_fail;
39559 }
39560 Py_INCREF(Py_None); resultobj = Py_None;
39561 return resultobj;
39562 fail:
39563 return NULL;
39564 }
39565
39566
39567 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39568 PyObject *resultobj;
39569 wxSizer *arg1 = (wxSizer *) 0 ;
39570 PyObject *arg2 = (PyObject *) 0 ;
39571 int arg3 = (int) 0 ;
39572 int arg4 = (int) 0 ;
39573 int arg5 = (int) 0 ;
39574 PyObject *arg6 = (PyObject *) NULL ;
39575 wxSizerItem *result;
39576 PyObject * obj0 = 0 ;
39577 PyObject * obj1 = 0 ;
39578 PyObject * obj2 = 0 ;
39579 PyObject * obj3 = 0 ;
39580 PyObject * obj4 = 0 ;
39581 PyObject * obj5 = 0 ;
39582 char *kwnames[] = {
39583 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39584 };
39585
39586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39588 if (SWIG_arg_fail(1)) SWIG_fail;
39589 arg2 = obj1;
39590 if (obj2) {
39591 {
39592 arg3 = (int)(SWIG_As_int(obj2));
39593 if (SWIG_arg_fail(3)) SWIG_fail;
39594 }
39595 }
39596 if (obj3) {
39597 {
39598 arg4 = (int)(SWIG_As_int(obj3));
39599 if (SWIG_arg_fail(4)) SWIG_fail;
39600 }
39601 }
39602 if (obj4) {
39603 {
39604 arg5 = (int)(SWIG_As_int(obj4));
39605 if (SWIG_arg_fail(5)) SWIG_fail;
39606 }
39607 }
39608 if (obj5) {
39609 arg6 = obj5;
39610 }
39611 {
39612 PyThreadState* __tstate = wxPyBeginAllowThreads();
39613 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39614
39615 wxPyEndAllowThreads(__tstate);
39616 if (PyErr_Occurred()) SWIG_fail;
39617 }
39618 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39619 return resultobj;
39620 fail:
39621 return NULL;
39622 }
39623
39624
39625 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39626 PyObject *resultobj;
39627 wxSizer *arg1 = (wxSizer *) 0 ;
39628 int arg2 ;
39629 PyObject *arg3 = (PyObject *) 0 ;
39630 int arg4 = (int) 0 ;
39631 int arg5 = (int) 0 ;
39632 int arg6 = (int) 0 ;
39633 PyObject *arg7 = (PyObject *) NULL ;
39634 wxSizerItem *result;
39635 PyObject * obj0 = 0 ;
39636 PyObject * obj1 = 0 ;
39637 PyObject * obj2 = 0 ;
39638 PyObject * obj3 = 0 ;
39639 PyObject * obj4 = 0 ;
39640 PyObject * obj5 = 0 ;
39641 PyObject * obj6 = 0 ;
39642 char *kwnames[] = {
39643 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39644 };
39645
39646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39648 if (SWIG_arg_fail(1)) SWIG_fail;
39649 {
39650 arg2 = (int)(SWIG_As_int(obj1));
39651 if (SWIG_arg_fail(2)) SWIG_fail;
39652 }
39653 arg3 = obj2;
39654 if (obj3) {
39655 {
39656 arg4 = (int)(SWIG_As_int(obj3));
39657 if (SWIG_arg_fail(4)) SWIG_fail;
39658 }
39659 }
39660 if (obj4) {
39661 {
39662 arg5 = (int)(SWIG_As_int(obj4));
39663 if (SWIG_arg_fail(5)) SWIG_fail;
39664 }
39665 }
39666 if (obj5) {
39667 {
39668 arg6 = (int)(SWIG_As_int(obj5));
39669 if (SWIG_arg_fail(6)) SWIG_fail;
39670 }
39671 }
39672 if (obj6) {
39673 arg7 = obj6;
39674 }
39675 {
39676 PyThreadState* __tstate = wxPyBeginAllowThreads();
39677 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39678
39679 wxPyEndAllowThreads(__tstate);
39680 if (PyErr_Occurred()) SWIG_fail;
39681 }
39682 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39683 return resultobj;
39684 fail:
39685 return NULL;
39686 }
39687
39688
39689 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39690 PyObject *resultobj;
39691 wxSizer *arg1 = (wxSizer *) 0 ;
39692 PyObject *arg2 = (PyObject *) 0 ;
39693 int arg3 = (int) 0 ;
39694 int arg4 = (int) 0 ;
39695 int arg5 = (int) 0 ;
39696 PyObject *arg6 = (PyObject *) NULL ;
39697 wxSizerItem *result;
39698 PyObject * obj0 = 0 ;
39699 PyObject * obj1 = 0 ;
39700 PyObject * obj2 = 0 ;
39701 PyObject * obj3 = 0 ;
39702 PyObject * obj4 = 0 ;
39703 PyObject * obj5 = 0 ;
39704 char *kwnames[] = {
39705 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39706 };
39707
39708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39710 if (SWIG_arg_fail(1)) SWIG_fail;
39711 arg2 = obj1;
39712 if (obj2) {
39713 {
39714 arg3 = (int)(SWIG_As_int(obj2));
39715 if (SWIG_arg_fail(3)) SWIG_fail;
39716 }
39717 }
39718 if (obj3) {
39719 {
39720 arg4 = (int)(SWIG_As_int(obj3));
39721 if (SWIG_arg_fail(4)) SWIG_fail;
39722 }
39723 }
39724 if (obj4) {
39725 {
39726 arg5 = (int)(SWIG_As_int(obj4));
39727 if (SWIG_arg_fail(5)) SWIG_fail;
39728 }
39729 }
39730 if (obj5) {
39731 arg6 = obj5;
39732 }
39733 {
39734 PyThreadState* __tstate = wxPyBeginAllowThreads();
39735 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39736
39737 wxPyEndAllowThreads(__tstate);
39738 if (PyErr_Occurred()) SWIG_fail;
39739 }
39740 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39741 return resultobj;
39742 fail:
39743 return NULL;
39744 }
39745
39746
39747 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39748 PyObject *resultobj;
39749 wxSizer *arg1 = (wxSizer *) 0 ;
39750 PyObject *arg2 = (PyObject *) 0 ;
39751 bool result;
39752 PyObject * obj0 = 0 ;
39753 PyObject * obj1 = 0 ;
39754 char *kwnames[] = {
39755 (char *) "self",(char *) "item", NULL
39756 };
39757
39758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39760 if (SWIG_arg_fail(1)) SWIG_fail;
39761 arg2 = obj1;
39762 {
39763 PyThreadState* __tstate = wxPyBeginAllowThreads();
39764 result = (bool)wxSizer_Remove(arg1,arg2);
39765
39766 wxPyEndAllowThreads(__tstate);
39767 if (PyErr_Occurred()) SWIG_fail;
39768 }
39769 {
39770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39771 }
39772 return resultobj;
39773 fail:
39774 return NULL;
39775 }
39776
39777
39778 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39779 PyObject *resultobj;
39780 wxSizer *arg1 = (wxSizer *) 0 ;
39781 PyObject *arg2 = (PyObject *) 0 ;
39782 bool result;
39783 PyObject * obj0 = 0 ;
39784 PyObject * obj1 = 0 ;
39785 char *kwnames[] = {
39786 (char *) "self",(char *) "item", NULL
39787 };
39788
39789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39791 if (SWIG_arg_fail(1)) SWIG_fail;
39792 arg2 = obj1;
39793 {
39794 PyThreadState* __tstate = wxPyBeginAllowThreads();
39795 result = (bool)wxSizer_Detach(arg1,arg2);
39796
39797 wxPyEndAllowThreads(__tstate);
39798 if (PyErr_Occurred()) SWIG_fail;
39799 }
39800 {
39801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39802 }
39803 return resultobj;
39804 fail:
39805 return NULL;
39806 }
39807
39808
39809 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39810 PyObject *resultobj;
39811 wxSizer *arg1 = (wxSizer *) 0 ;
39812 PyObject *arg2 = (PyObject *) 0 ;
39813 wxSizerItem *result;
39814 PyObject * obj0 = 0 ;
39815 PyObject * obj1 = 0 ;
39816 char *kwnames[] = {
39817 (char *) "self",(char *) "item", NULL
39818 };
39819
39820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39822 if (SWIG_arg_fail(1)) SWIG_fail;
39823 arg2 = obj1;
39824 {
39825 PyThreadState* __tstate = wxPyBeginAllowThreads();
39826 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39827
39828 wxPyEndAllowThreads(__tstate);
39829 if (PyErr_Occurred()) SWIG_fail;
39830 }
39831 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39832 return resultobj;
39833 fail:
39834 return NULL;
39835 }
39836
39837
39838 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39839 PyObject *resultobj;
39840 wxSizer *arg1 = (wxSizer *) 0 ;
39841 PyObject *arg2 = (PyObject *) 0 ;
39842 wxSize *arg3 = 0 ;
39843 wxSize temp3 ;
39844 PyObject * obj0 = 0 ;
39845 PyObject * obj1 = 0 ;
39846 PyObject * obj2 = 0 ;
39847 char *kwnames[] = {
39848 (char *) "self",(char *) "item",(char *) "size", NULL
39849 };
39850
39851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39853 if (SWIG_arg_fail(1)) SWIG_fail;
39854 arg2 = obj1;
39855 {
39856 arg3 = &temp3;
39857 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39858 }
39859 {
39860 PyThreadState* __tstate = wxPyBeginAllowThreads();
39861 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39862
39863 wxPyEndAllowThreads(__tstate);
39864 if (PyErr_Occurred()) SWIG_fail;
39865 }
39866 Py_INCREF(Py_None); resultobj = Py_None;
39867 return resultobj;
39868 fail:
39869 return NULL;
39870 }
39871
39872
39873 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39874 PyObject *resultobj;
39875 wxSizer *arg1 = (wxSizer *) 0 ;
39876 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39877 wxSizerItem *result;
39878 PyObject * obj0 = 0 ;
39879 PyObject * obj1 = 0 ;
39880 char *kwnames[] = {
39881 (char *) "self",(char *) "item", NULL
39882 };
39883
39884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39888 if (SWIG_arg_fail(2)) SWIG_fail;
39889 {
39890 PyThreadState* __tstate = wxPyBeginAllowThreads();
39891 result = (wxSizerItem *)(arg1)->Add(arg2);
39892
39893 wxPyEndAllowThreads(__tstate);
39894 if (PyErr_Occurred()) SWIG_fail;
39895 }
39896 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39897 return resultobj;
39898 fail:
39899 return NULL;
39900 }
39901
39902
39903 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39904 PyObject *resultobj;
39905 wxSizer *arg1 = (wxSizer *) 0 ;
39906 size_t arg2 ;
39907 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39908 wxSizerItem *result;
39909 PyObject * obj0 = 0 ;
39910 PyObject * obj1 = 0 ;
39911 PyObject * obj2 = 0 ;
39912 char *kwnames[] = {
39913 (char *) "self",(char *) "index",(char *) "item", NULL
39914 };
39915
39916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39918 if (SWIG_arg_fail(1)) SWIG_fail;
39919 {
39920 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39921 if (SWIG_arg_fail(2)) SWIG_fail;
39922 }
39923 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39924 if (SWIG_arg_fail(3)) SWIG_fail;
39925 {
39926 PyThreadState* __tstate = wxPyBeginAllowThreads();
39927 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39928
39929 wxPyEndAllowThreads(__tstate);
39930 if (PyErr_Occurred()) SWIG_fail;
39931 }
39932 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39933 return resultobj;
39934 fail:
39935 return NULL;
39936 }
39937
39938
39939 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39940 PyObject *resultobj;
39941 wxSizer *arg1 = (wxSizer *) 0 ;
39942 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39943 wxSizerItem *result;
39944 PyObject * obj0 = 0 ;
39945 PyObject * obj1 = 0 ;
39946 char *kwnames[] = {
39947 (char *) "self",(char *) "item", NULL
39948 };
39949
39950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39952 if (SWIG_arg_fail(1)) SWIG_fail;
39953 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39954 if (SWIG_arg_fail(2)) SWIG_fail;
39955 {
39956 PyThreadState* __tstate = wxPyBeginAllowThreads();
39957 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39958
39959 wxPyEndAllowThreads(__tstate);
39960 if (PyErr_Occurred()) SWIG_fail;
39961 }
39962 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39963 return resultobj;
39964 fail:
39965 return NULL;
39966 }
39967
39968
39969 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39970 PyObject *resultobj;
39971 wxSizer *arg1 = (wxSizer *) 0 ;
39972 int arg2 ;
39973 int arg3 ;
39974 int arg4 ;
39975 int arg5 ;
39976 PyObject * obj0 = 0 ;
39977 PyObject * obj1 = 0 ;
39978 PyObject * obj2 = 0 ;
39979 PyObject * obj3 = 0 ;
39980 PyObject * obj4 = 0 ;
39981 char *kwnames[] = {
39982 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39983 };
39984
39985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) 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 {
39989 arg2 = (int)(SWIG_As_int(obj1));
39990 if (SWIG_arg_fail(2)) SWIG_fail;
39991 }
39992 {
39993 arg3 = (int)(SWIG_As_int(obj2));
39994 if (SWIG_arg_fail(3)) SWIG_fail;
39995 }
39996 {
39997 arg4 = (int)(SWIG_As_int(obj3));
39998 if (SWIG_arg_fail(4)) SWIG_fail;
39999 }
40000 {
40001 arg5 = (int)(SWIG_As_int(obj4));
40002 if (SWIG_arg_fail(5)) SWIG_fail;
40003 }
40004 {
40005 PyThreadState* __tstate = wxPyBeginAllowThreads();
40006 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
40007
40008 wxPyEndAllowThreads(__tstate);
40009 if (PyErr_Occurred()) SWIG_fail;
40010 }
40011 Py_INCREF(Py_None); resultobj = Py_None;
40012 return resultobj;
40013 fail:
40014 return NULL;
40015 }
40016
40017
40018 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40019 PyObject *resultobj;
40020 wxSizer *arg1 = (wxSizer *) 0 ;
40021 wxSize *arg2 = 0 ;
40022 wxSize temp2 ;
40023 PyObject * obj0 = 0 ;
40024 PyObject * obj1 = 0 ;
40025 char *kwnames[] = {
40026 (char *) "self",(char *) "size", NULL
40027 };
40028
40029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40031 if (SWIG_arg_fail(1)) SWIG_fail;
40032 {
40033 arg2 = &temp2;
40034 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40035 }
40036 {
40037 PyThreadState* __tstate = wxPyBeginAllowThreads();
40038 (arg1)->SetMinSize((wxSize const &)*arg2);
40039
40040 wxPyEndAllowThreads(__tstate);
40041 if (PyErr_Occurred()) SWIG_fail;
40042 }
40043 Py_INCREF(Py_None); resultobj = Py_None;
40044 return resultobj;
40045 fail:
40046 return NULL;
40047 }
40048
40049
40050 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40051 PyObject *resultobj;
40052 wxSizer *arg1 = (wxSizer *) 0 ;
40053 wxSize result;
40054 PyObject * obj0 = 0 ;
40055 char *kwnames[] = {
40056 (char *) "self", NULL
40057 };
40058
40059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40061 if (SWIG_arg_fail(1)) SWIG_fail;
40062 {
40063 PyThreadState* __tstate = wxPyBeginAllowThreads();
40064 result = (arg1)->GetSize();
40065
40066 wxPyEndAllowThreads(__tstate);
40067 if (PyErr_Occurred()) SWIG_fail;
40068 }
40069 {
40070 wxSize * resultptr;
40071 resultptr = new wxSize((wxSize &)(result));
40072 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40073 }
40074 return resultobj;
40075 fail:
40076 return NULL;
40077 }
40078
40079
40080 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40081 PyObject *resultobj;
40082 wxSizer *arg1 = (wxSizer *) 0 ;
40083 wxPoint result;
40084 PyObject * obj0 = 0 ;
40085 char *kwnames[] = {
40086 (char *) "self", NULL
40087 };
40088
40089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40091 if (SWIG_arg_fail(1)) SWIG_fail;
40092 {
40093 PyThreadState* __tstate = wxPyBeginAllowThreads();
40094 result = (arg1)->GetPosition();
40095
40096 wxPyEndAllowThreads(__tstate);
40097 if (PyErr_Occurred()) SWIG_fail;
40098 }
40099 {
40100 wxPoint * resultptr;
40101 resultptr = new wxPoint((wxPoint &)(result));
40102 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40103 }
40104 return resultobj;
40105 fail:
40106 return NULL;
40107 }
40108
40109
40110 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40111 PyObject *resultobj;
40112 wxSizer *arg1 = (wxSizer *) 0 ;
40113 wxSize result;
40114 PyObject * obj0 = 0 ;
40115 char *kwnames[] = {
40116 (char *) "self", NULL
40117 };
40118
40119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40121 if (SWIG_arg_fail(1)) SWIG_fail;
40122 {
40123 PyThreadState* __tstate = wxPyBeginAllowThreads();
40124 result = (arg1)->GetMinSize();
40125
40126 wxPyEndAllowThreads(__tstate);
40127 if (PyErr_Occurred()) SWIG_fail;
40128 }
40129 {
40130 wxSize * resultptr;
40131 resultptr = new wxSize((wxSize &)(result));
40132 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40133 }
40134 return resultobj;
40135 fail:
40136 return NULL;
40137 }
40138
40139
40140 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40141 PyObject *resultobj;
40142 wxSizer *arg1 = (wxSizer *) 0 ;
40143 PyObject * obj0 = 0 ;
40144 char *kwnames[] = {
40145 (char *) "self", NULL
40146 };
40147
40148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40150 if (SWIG_arg_fail(1)) SWIG_fail;
40151 {
40152 PyThreadState* __tstate = wxPyBeginAllowThreads();
40153 (arg1)->RecalcSizes();
40154
40155 wxPyEndAllowThreads(__tstate);
40156 if (PyErr_Occurred()) SWIG_fail;
40157 }
40158 Py_INCREF(Py_None); resultobj = Py_None;
40159 return resultobj;
40160 fail:
40161 return NULL;
40162 }
40163
40164
40165 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40166 PyObject *resultobj;
40167 wxSizer *arg1 = (wxSizer *) 0 ;
40168 wxSize result;
40169 PyObject * obj0 = 0 ;
40170 char *kwnames[] = {
40171 (char *) "self", NULL
40172 };
40173
40174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40176 if (SWIG_arg_fail(1)) SWIG_fail;
40177 {
40178 PyThreadState* __tstate = wxPyBeginAllowThreads();
40179 result = (arg1)->CalcMin();
40180
40181 wxPyEndAllowThreads(__tstate);
40182 if (PyErr_Occurred()) SWIG_fail;
40183 }
40184 {
40185 wxSize * resultptr;
40186 resultptr = new wxSize((wxSize &)(result));
40187 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40188 }
40189 return resultobj;
40190 fail:
40191 return NULL;
40192 }
40193
40194
40195 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40196 PyObject *resultobj;
40197 wxSizer *arg1 = (wxSizer *) 0 ;
40198 PyObject * obj0 = 0 ;
40199 char *kwnames[] = {
40200 (char *) "self", NULL
40201 };
40202
40203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40205 if (SWIG_arg_fail(1)) SWIG_fail;
40206 {
40207 PyThreadState* __tstate = wxPyBeginAllowThreads();
40208 (arg1)->Layout();
40209
40210 wxPyEndAllowThreads(__tstate);
40211 if (PyErr_Occurred()) SWIG_fail;
40212 }
40213 Py_INCREF(Py_None); resultobj = Py_None;
40214 return resultobj;
40215 fail:
40216 return NULL;
40217 }
40218
40219
40220 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40221 PyObject *resultobj;
40222 wxSizer *arg1 = (wxSizer *) 0 ;
40223 wxWindow *arg2 = (wxWindow *) 0 ;
40224 wxSize result;
40225 PyObject * obj0 = 0 ;
40226 PyObject * obj1 = 0 ;
40227 char *kwnames[] = {
40228 (char *) "self",(char *) "window", NULL
40229 };
40230
40231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40233 if (SWIG_arg_fail(1)) SWIG_fail;
40234 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40235 if (SWIG_arg_fail(2)) SWIG_fail;
40236 {
40237 PyThreadState* __tstate = wxPyBeginAllowThreads();
40238 result = (arg1)->Fit(arg2);
40239
40240 wxPyEndAllowThreads(__tstate);
40241 if (PyErr_Occurred()) SWIG_fail;
40242 }
40243 {
40244 wxSize * resultptr;
40245 resultptr = new wxSize((wxSize &)(result));
40246 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40247 }
40248 return resultobj;
40249 fail:
40250 return NULL;
40251 }
40252
40253
40254 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40255 PyObject *resultobj;
40256 wxSizer *arg1 = (wxSizer *) 0 ;
40257 wxWindow *arg2 = (wxWindow *) 0 ;
40258 PyObject * obj0 = 0 ;
40259 PyObject * obj1 = 0 ;
40260 char *kwnames[] = {
40261 (char *) "self",(char *) "window", NULL
40262 };
40263
40264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40266 if (SWIG_arg_fail(1)) SWIG_fail;
40267 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40268 if (SWIG_arg_fail(2)) SWIG_fail;
40269 {
40270 PyThreadState* __tstate = wxPyBeginAllowThreads();
40271 (arg1)->FitInside(arg2);
40272
40273 wxPyEndAllowThreads(__tstate);
40274 if (PyErr_Occurred()) SWIG_fail;
40275 }
40276 Py_INCREF(Py_None); resultobj = Py_None;
40277 return resultobj;
40278 fail:
40279 return NULL;
40280 }
40281
40282
40283 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40284 PyObject *resultobj;
40285 wxSizer *arg1 = (wxSizer *) 0 ;
40286 wxWindow *arg2 = (wxWindow *) 0 ;
40287 PyObject * obj0 = 0 ;
40288 PyObject * obj1 = 0 ;
40289 char *kwnames[] = {
40290 (char *) "self",(char *) "window", NULL
40291 };
40292
40293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40295 if (SWIG_arg_fail(1)) SWIG_fail;
40296 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40297 if (SWIG_arg_fail(2)) SWIG_fail;
40298 {
40299 PyThreadState* __tstate = wxPyBeginAllowThreads();
40300 (arg1)->SetSizeHints(arg2);
40301
40302 wxPyEndAllowThreads(__tstate);
40303 if (PyErr_Occurred()) SWIG_fail;
40304 }
40305 Py_INCREF(Py_None); resultobj = Py_None;
40306 return resultobj;
40307 fail:
40308 return NULL;
40309 }
40310
40311
40312 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40313 PyObject *resultobj;
40314 wxSizer *arg1 = (wxSizer *) 0 ;
40315 wxWindow *arg2 = (wxWindow *) 0 ;
40316 PyObject * obj0 = 0 ;
40317 PyObject * obj1 = 0 ;
40318 char *kwnames[] = {
40319 (char *) "self",(char *) "window", NULL
40320 };
40321
40322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40324 if (SWIG_arg_fail(1)) SWIG_fail;
40325 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40326 if (SWIG_arg_fail(2)) SWIG_fail;
40327 {
40328 PyThreadState* __tstate = wxPyBeginAllowThreads();
40329 (arg1)->SetVirtualSizeHints(arg2);
40330
40331 wxPyEndAllowThreads(__tstate);
40332 if (PyErr_Occurred()) SWIG_fail;
40333 }
40334 Py_INCREF(Py_None); resultobj = Py_None;
40335 return resultobj;
40336 fail:
40337 return NULL;
40338 }
40339
40340
40341 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40342 PyObject *resultobj;
40343 wxSizer *arg1 = (wxSizer *) 0 ;
40344 bool arg2 = (bool) false ;
40345 PyObject * obj0 = 0 ;
40346 PyObject * obj1 = 0 ;
40347 char *kwnames[] = {
40348 (char *) "self",(char *) "deleteWindows", NULL
40349 };
40350
40351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40353 if (SWIG_arg_fail(1)) SWIG_fail;
40354 if (obj1) {
40355 {
40356 arg2 = (bool)(SWIG_As_bool(obj1));
40357 if (SWIG_arg_fail(2)) SWIG_fail;
40358 }
40359 }
40360 {
40361 PyThreadState* __tstate = wxPyBeginAllowThreads();
40362 (arg1)->Clear(arg2);
40363
40364 wxPyEndAllowThreads(__tstate);
40365 if (PyErr_Occurred()) SWIG_fail;
40366 }
40367 Py_INCREF(Py_None); resultobj = Py_None;
40368 return resultobj;
40369 fail:
40370 return NULL;
40371 }
40372
40373
40374 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40375 PyObject *resultobj;
40376 wxSizer *arg1 = (wxSizer *) 0 ;
40377 PyObject * obj0 = 0 ;
40378 char *kwnames[] = {
40379 (char *) "self", NULL
40380 };
40381
40382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
40383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40384 if (SWIG_arg_fail(1)) SWIG_fail;
40385 {
40386 PyThreadState* __tstate = wxPyBeginAllowThreads();
40387 (arg1)->DeleteWindows();
40388
40389 wxPyEndAllowThreads(__tstate);
40390 if (PyErr_Occurred()) SWIG_fail;
40391 }
40392 Py_INCREF(Py_None); resultobj = Py_None;
40393 return resultobj;
40394 fail:
40395 return NULL;
40396 }
40397
40398
40399 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40400 PyObject *resultobj;
40401 wxSizer *arg1 = (wxSizer *) 0 ;
40402 PyObject *result;
40403 PyObject * obj0 = 0 ;
40404 char *kwnames[] = {
40405 (char *) "self", NULL
40406 };
40407
40408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40410 if (SWIG_arg_fail(1)) SWIG_fail;
40411 {
40412 PyThreadState* __tstate = wxPyBeginAllowThreads();
40413 result = (PyObject *)wxSizer_GetChildren(arg1);
40414
40415 wxPyEndAllowThreads(__tstate);
40416 if (PyErr_Occurred()) SWIG_fail;
40417 }
40418 resultobj = result;
40419 return resultobj;
40420 fail:
40421 return NULL;
40422 }
40423
40424
40425 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40426 PyObject *resultobj;
40427 wxSizer *arg1 = (wxSizer *) 0 ;
40428 PyObject *arg2 = (PyObject *) 0 ;
40429 bool arg3 = (bool) true ;
40430 bool arg4 = (bool) false ;
40431 bool result;
40432 PyObject * obj0 = 0 ;
40433 PyObject * obj1 = 0 ;
40434 PyObject * obj2 = 0 ;
40435 PyObject * obj3 = 0 ;
40436 char *kwnames[] = {
40437 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40438 };
40439
40440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40442 if (SWIG_arg_fail(1)) SWIG_fail;
40443 arg2 = obj1;
40444 if (obj2) {
40445 {
40446 arg3 = (bool)(SWIG_As_bool(obj2));
40447 if (SWIG_arg_fail(3)) SWIG_fail;
40448 }
40449 }
40450 if (obj3) {
40451 {
40452 arg4 = (bool)(SWIG_As_bool(obj3));
40453 if (SWIG_arg_fail(4)) SWIG_fail;
40454 }
40455 }
40456 {
40457 PyThreadState* __tstate = wxPyBeginAllowThreads();
40458 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40459
40460 wxPyEndAllowThreads(__tstate);
40461 if (PyErr_Occurred()) SWIG_fail;
40462 }
40463 {
40464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40465 }
40466 return resultobj;
40467 fail:
40468 return NULL;
40469 }
40470
40471
40472 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40473 PyObject *resultobj;
40474 wxSizer *arg1 = (wxSizer *) 0 ;
40475 PyObject *arg2 = (PyObject *) 0 ;
40476 bool result;
40477 PyObject * obj0 = 0 ;
40478 PyObject * obj1 = 0 ;
40479 char *kwnames[] = {
40480 (char *) "self",(char *) "item", NULL
40481 };
40482
40483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40485 if (SWIG_arg_fail(1)) SWIG_fail;
40486 arg2 = obj1;
40487 {
40488 PyThreadState* __tstate = wxPyBeginAllowThreads();
40489 result = (bool)wxSizer_IsShown(arg1,arg2);
40490
40491 wxPyEndAllowThreads(__tstate);
40492 if (PyErr_Occurred()) SWIG_fail;
40493 }
40494 {
40495 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40496 }
40497 return resultobj;
40498 fail:
40499 return NULL;
40500 }
40501
40502
40503 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40504 PyObject *resultobj;
40505 wxSizer *arg1 = (wxSizer *) 0 ;
40506 bool arg2 ;
40507 PyObject * obj0 = 0 ;
40508 PyObject * obj1 = 0 ;
40509 char *kwnames[] = {
40510 (char *) "self",(char *) "show", NULL
40511 };
40512
40513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40515 if (SWIG_arg_fail(1)) SWIG_fail;
40516 {
40517 arg2 = (bool)(SWIG_As_bool(obj1));
40518 if (SWIG_arg_fail(2)) SWIG_fail;
40519 }
40520 {
40521 PyThreadState* __tstate = wxPyBeginAllowThreads();
40522 (arg1)->ShowItems(arg2);
40523
40524 wxPyEndAllowThreads(__tstate);
40525 if (PyErr_Occurred()) SWIG_fail;
40526 }
40527 Py_INCREF(Py_None); resultobj = Py_None;
40528 return resultobj;
40529 fail:
40530 return NULL;
40531 }
40532
40533
40534 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40535 PyObject *obj;
40536 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40537 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40538 Py_INCREF(obj);
40539 return Py_BuildValue((char *)"");
40540 }
40541 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40542 PyObject *resultobj;
40543 wxPySizer *result;
40544 char *kwnames[] = {
40545 NULL
40546 };
40547
40548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40549 {
40550 PyThreadState* __tstate = wxPyBeginAllowThreads();
40551 result = (wxPySizer *)new wxPySizer();
40552
40553 wxPyEndAllowThreads(__tstate);
40554 if (PyErr_Occurred()) SWIG_fail;
40555 }
40556 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40557 return resultobj;
40558 fail:
40559 return NULL;
40560 }
40561
40562
40563 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40564 PyObject *resultobj;
40565 wxPySizer *arg1 = (wxPySizer *) 0 ;
40566 PyObject *arg2 = (PyObject *) 0 ;
40567 PyObject *arg3 = (PyObject *) 0 ;
40568 PyObject * obj0 = 0 ;
40569 PyObject * obj1 = 0 ;
40570 PyObject * obj2 = 0 ;
40571 char *kwnames[] = {
40572 (char *) "self",(char *) "self",(char *) "_class", NULL
40573 };
40574
40575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40577 if (SWIG_arg_fail(1)) SWIG_fail;
40578 arg2 = obj1;
40579 arg3 = obj2;
40580 {
40581 PyThreadState* __tstate = wxPyBeginAllowThreads();
40582 (arg1)->_setCallbackInfo(arg2,arg3);
40583
40584 wxPyEndAllowThreads(__tstate);
40585 if (PyErr_Occurred()) SWIG_fail;
40586 }
40587 Py_INCREF(Py_None); resultobj = Py_None;
40588 return resultobj;
40589 fail:
40590 return NULL;
40591 }
40592
40593
40594 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40595 PyObject *obj;
40596 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40597 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40598 Py_INCREF(obj);
40599 return Py_BuildValue((char *)"");
40600 }
40601 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40602 PyObject *resultobj;
40603 int arg1 = (int) wxHORIZONTAL ;
40604 wxBoxSizer *result;
40605 PyObject * obj0 = 0 ;
40606 char *kwnames[] = {
40607 (char *) "orient", NULL
40608 };
40609
40610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40611 if (obj0) {
40612 {
40613 arg1 = (int)(SWIG_As_int(obj0));
40614 if (SWIG_arg_fail(1)) SWIG_fail;
40615 }
40616 }
40617 {
40618 PyThreadState* __tstate = wxPyBeginAllowThreads();
40619 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40620
40621 wxPyEndAllowThreads(__tstate);
40622 if (PyErr_Occurred()) SWIG_fail;
40623 }
40624 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40625 return resultobj;
40626 fail:
40627 return NULL;
40628 }
40629
40630
40631 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40632 PyObject *resultobj;
40633 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40634 int result;
40635 PyObject * obj0 = 0 ;
40636 char *kwnames[] = {
40637 (char *) "self", NULL
40638 };
40639
40640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40642 if (SWIG_arg_fail(1)) SWIG_fail;
40643 {
40644 PyThreadState* __tstate = wxPyBeginAllowThreads();
40645 result = (int)(arg1)->GetOrientation();
40646
40647 wxPyEndAllowThreads(__tstate);
40648 if (PyErr_Occurred()) SWIG_fail;
40649 }
40650 {
40651 resultobj = SWIG_From_int((int)(result));
40652 }
40653 return resultobj;
40654 fail:
40655 return NULL;
40656 }
40657
40658
40659 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40660 PyObject *resultobj;
40661 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40662 int arg2 ;
40663 PyObject * obj0 = 0 ;
40664 PyObject * obj1 = 0 ;
40665 char *kwnames[] = {
40666 (char *) "self",(char *) "orient", NULL
40667 };
40668
40669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40671 if (SWIG_arg_fail(1)) SWIG_fail;
40672 {
40673 arg2 = (int)(SWIG_As_int(obj1));
40674 if (SWIG_arg_fail(2)) SWIG_fail;
40675 }
40676 {
40677 PyThreadState* __tstate = wxPyBeginAllowThreads();
40678 (arg1)->SetOrientation(arg2);
40679
40680 wxPyEndAllowThreads(__tstate);
40681 if (PyErr_Occurred()) SWIG_fail;
40682 }
40683 Py_INCREF(Py_None); resultobj = Py_None;
40684 return resultobj;
40685 fail:
40686 return NULL;
40687 }
40688
40689
40690 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40691 PyObject *obj;
40692 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40693 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40694 Py_INCREF(obj);
40695 return Py_BuildValue((char *)"");
40696 }
40697 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40698 PyObject *resultobj;
40699 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40700 int arg2 = (int) wxHORIZONTAL ;
40701 wxStaticBoxSizer *result;
40702 PyObject * obj0 = 0 ;
40703 PyObject * obj1 = 0 ;
40704 char *kwnames[] = {
40705 (char *) "box",(char *) "orient", NULL
40706 };
40707
40708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40710 if (SWIG_arg_fail(1)) SWIG_fail;
40711 if (obj1) {
40712 {
40713 arg2 = (int)(SWIG_As_int(obj1));
40714 if (SWIG_arg_fail(2)) SWIG_fail;
40715 }
40716 }
40717 {
40718 PyThreadState* __tstate = wxPyBeginAllowThreads();
40719 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40720
40721 wxPyEndAllowThreads(__tstate);
40722 if (PyErr_Occurred()) SWIG_fail;
40723 }
40724 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40725 return resultobj;
40726 fail:
40727 return NULL;
40728 }
40729
40730
40731 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40732 PyObject *resultobj;
40733 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40734 wxStaticBox *result;
40735 PyObject * obj0 = 0 ;
40736 char *kwnames[] = {
40737 (char *) "self", NULL
40738 };
40739
40740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40742 if (SWIG_arg_fail(1)) SWIG_fail;
40743 {
40744 PyThreadState* __tstate = wxPyBeginAllowThreads();
40745 result = (wxStaticBox *)(arg1)->GetStaticBox();
40746
40747 wxPyEndAllowThreads(__tstate);
40748 if (PyErr_Occurred()) SWIG_fail;
40749 }
40750 {
40751 resultobj = wxPyMake_wxObject(result, 0);
40752 }
40753 return resultobj;
40754 fail:
40755 return NULL;
40756 }
40757
40758
40759 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40760 PyObject *obj;
40761 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40762 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40763 Py_INCREF(obj);
40764 return Py_BuildValue((char *)"");
40765 }
40766 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40767 PyObject *resultobj;
40768 int arg1 = (int) 1 ;
40769 int arg2 = (int) 0 ;
40770 int arg3 = (int) 0 ;
40771 int arg4 = (int) 0 ;
40772 wxGridSizer *result;
40773 PyObject * obj0 = 0 ;
40774 PyObject * obj1 = 0 ;
40775 PyObject * obj2 = 0 ;
40776 PyObject * obj3 = 0 ;
40777 char *kwnames[] = {
40778 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40779 };
40780
40781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40782 if (obj0) {
40783 {
40784 arg1 = (int)(SWIG_As_int(obj0));
40785 if (SWIG_arg_fail(1)) SWIG_fail;
40786 }
40787 }
40788 if (obj1) {
40789 {
40790 arg2 = (int)(SWIG_As_int(obj1));
40791 if (SWIG_arg_fail(2)) SWIG_fail;
40792 }
40793 }
40794 if (obj2) {
40795 {
40796 arg3 = (int)(SWIG_As_int(obj2));
40797 if (SWIG_arg_fail(3)) SWIG_fail;
40798 }
40799 }
40800 if (obj3) {
40801 {
40802 arg4 = (int)(SWIG_As_int(obj3));
40803 if (SWIG_arg_fail(4)) SWIG_fail;
40804 }
40805 }
40806 {
40807 PyThreadState* __tstate = wxPyBeginAllowThreads();
40808 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40809
40810 wxPyEndAllowThreads(__tstate);
40811 if (PyErr_Occurred()) SWIG_fail;
40812 }
40813 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40814 return resultobj;
40815 fail:
40816 return NULL;
40817 }
40818
40819
40820 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40821 PyObject *resultobj;
40822 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40823 int arg2 ;
40824 PyObject * obj0 = 0 ;
40825 PyObject * obj1 = 0 ;
40826 char *kwnames[] = {
40827 (char *) "self",(char *) "cols", NULL
40828 };
40829
40830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40832 if (SWIG_arg_fail(1)) SWIG_fail;
40833 {
40834 arg2 = (int)(SWIG_As_int(obj1));
40835 if (SWIG_arg_fail(2)) SWIG_fail;
40836 }
40837 {
40838 PyThreadState* __tstate = wxPyBeginAllowThreads();
40839 (arg1)->SetCols(arg2);
40840
40841 wxPyEndAllowThreads(__tstate);
40842 if (PyErr_Occurred()) SWIG_fail;
40843 }
40844 Py_INCREF(Py_None); resultobj = Py_None;
40845 return resultobj;
40846 fail:
40847 return NULL;
40848 }
40849
40850
40851 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40852 PyObject *resultobj;
40853 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40854 int arg2 ;
40855 PyObject * obj0 = 0 ;
40856 PyObject * obj1 = 0 ;
40857 char *kwnames[] = {
40858 (char *) "self",(char *) "rows", NULL
40859 };
40860
40861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40862 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40863 if (SWIG_arg_fail(1)) SWIG_fail;
40864 {
40865 arg2 = (int)(SWIG_As_int(obj1));
40866 if (SWIG_arg_fail(2)) SWIG_fail;
40867 }
40868 {
40869 PyThreadState* __tstate = wxPyBeginAllowThreads();
40870 (arg1)->SetRows(arg2);
40871
40872 wxPyEndAllowThreads(__tstate);
40873 if (PyErr_Occurred()) SWIG_fail;
40874 }
40875 Py_INCREF(Py_None); resultobj = Py_None;
40876 return resultobj;
40877 fail:
40878 return NULL;
40879 }
40880
40881
40882 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40883 PyObject *resultobj;
40884 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40885 int arg2 ;
40886 PyObject * obj0 = 0 ;
40887 PyObject * obj1 = 0 ;
40888 char *kwnames[] = {
40889 (char *) "self",(char *) "gap", NULL
40890 };
40891
40892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40894 if (SWIG_arg_fail(1)) SWIG_fail;
40895 {
40896 arg2 = (int)(SWIG_As_int(obj1));
40897 if (SWIG_arg_fail(2)) SWIG_fail;
40898 }
40899 {
40900 PyThreadState* __tstate = wxPyBeginAllowThreads();
40901 (arg1)->SetVGap(arg2);
40902
40903 wxPyEndAllowThreads(__tstate);
40904 if (PyErr_Occurred()) SWIG_fail;
40905 }
40906 Py_INCREF(Py_None); resultobj = Py_None;
40907 return resultobj;
40908 fail:
40909 return NULL;
40910 }
40911
40912
40913 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40914 PyObject *resultobj;
40915 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40916 int arg2 ;
40917 PyObject * obj0 = 0 ;
40918 PyObject * obj1 = 0 ;
40919 char *kwnames[] = {
40920 (char *) "self",(char *) "gap", NULL
40921 };
40922
40923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40925 if (SWIG_arg_fail(1)) SWIG_fail;
40926 {
40927 arg2 = (int)(SWIG_As_int(obj1));
40928 if (SWIG_arg_fail(2)) SWIG_fail;
40929 }
40930 {
40931 PyThreadState* __tstate = wxPyBeginAllowThreads();
40932 (arg1)->SetHGap(arg2);
40933
40934 wxPyEndAllowThreads(__tstate);
40935 if (PyErr_Occurred()) SWIG_fail;
40936 }
40937 Py_INCREF(Py_None); resultobj = Py_None;
40938 return resultobj;
40939 fail:
40940 return NULL;
40941 }
40942
40943
40944 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40945 PyObject *resultobj;
40946 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40947 int result;
40948 PyObject * obj0 = 0 ;
40949 char *kwnames[] = {
40950 (char *) "self", NULL
40951 };
40952
40953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40955 if (SWIG_arg_fail(1)) SWIG_fail;
40956 {
40957 PyThreadState* __tstate = wxPyBeginAllowThreads();
40958 result = (int)(arg1)->GetCols();
40959
40960 wxPyEndAllowThreads(__tstate);
40961 if (PyErr_Occurred()) SWIG_fail;
40962 }
40963 {
40964 resultobj = SWIG_From_int((int)(result));
40965 }
40966 return resultobj;
40967 fail:
40968 return NULL;
40969 }
40970
40971
40972 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40973 PyObject *resultobj;
40974 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40975 int result;
40976 PyObject * obj0 = 0 ;
40977 char *kwnames[] = {
40978 (char *) "self", NULL
40979 };
40980
40981 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40982 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40983 if (SWIG_arg_fail(1)) SWIG_fail;
40984 {
40985 PyThreadState* __tstate = wxPyBeginAllowThreads();
40986 result = (int)(arg1)->GetRows();
40987
40988 wxPyEndAllowThreads(__tstate);
40989 if (PyErr_Occurred()) SWIG_fail;
40990 }
40991 {
40992 resultobj = SWIG_From_int((int)(result));
40993 }
40994 return resultobj;
40995 fail:
40996 return NULL;
40997 }
40998
40999
41000 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41001 PyObject *resultobj;
41002 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41003 int result;
41004 PyObject * obj0 = 0 ;
41005 char *kwnames[] = {
41006 (char *) "self", NULL
41007 };
41008
41009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41011 if (SWIG_arg_fail(1)) SWIG_fail;
41012 {
41013 PyThreadState* __tstate = wxPyBeginAllowThreads();
41014 result = (int)(arg1)->GetVGap();
41015
41016 wxPyEndAllowThreads(__tstate);
41017 if (PyErr_Occurred()) SWIG_fail;
41018 }
41019 {
41020 resultobj = SWIG_From_int((int)(result));
41021 }
41022 return resultobj;
41023 fail:
41024 return NULL;
41025 }
41026
41027
41028 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41029 PyObject *resultobj;
41030 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41031 int result;
41032 PyObject * obj0 = 0 ;
41033 char *kwnames[] = {
41034 (char *) "self", NULL
41035 };
41036
41037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41039 if (SWIG_arg_fail(1)) SWIG_fail;
41040 {
41041 PyThreadState* __tstate = wxPyBeginAllowThreads();
41042 result = (int)(arg1)->GetHGap();
41043
41044 wxPyEndAllowThreads(__tstate);
41045 if (PyErr_Occurred()) SWIG_fail;
41046 }
41047 {
41048 resultobj = SWIG_From_int((int)(result));
41049 }
41050 return resultobj;
41051 fail:
41052 return NULL;
41053 }
41054
41055
41056 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41057 PyObject *obj;
41058 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41059 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41060 Py_INCREF(obj);
41061 return Py_BuildValue((char *)"");
41062 }
41063 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41064 PyObject *resultobj;
41065 int arg1 = (int) 1 ;
41066 int arg2 = (int) 0 ;
41067 int arg3 = (int) 0 ;
41068 int arg4 = (int) 0 ;
41069 wxFlexGridSizer *result;
41070 PyObject * obj0 = 0 ;
41071 PyObject * obj1 = 0 ;
41072 PyObject * obj2 = 0 ;
41073 PyObject * obj3 = 0 ;
41074 char *kwnames[] = {
41075 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41076 };
41077
41078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41079 if (obj0) {
41080 {
41081 arg1 = (int)(SWIG_As_int(obj0));
41082 if (SWIG_arg_fail(1)) SWIG_fail;
41083 }
41084 }
41085 if (obj1) {
41086 {
41087 arg2 = (int)(SWIG_As_int(obj1));
41088 if (SWIG_arg_fail(2)) SWIG_fail;
41089 }
41090 }
41091 if (obj2) {
41092 {
41093 arg3 = (int)(SWIG_As_int(obj2));
41094 if (SWIG_arg_fail(3)) SWIG_fail;
41095 }
41096 }
41097 if (obj3) {
41098 {
41099 arg4 = (int)(SWIG_As_int(obj3));
41100 if (SWIG_arg_fail(4)) SWIG_fail;
41101 }
41102 }
41103 {
41104 PyThreadState* __tstate = wxPyBeginAllowThreads();
41105 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41106
41107 wxPyEndAllowThreads(__tstate);
41108 if (PyErr_Occurred()) SWIG_fail;
41109 }
41110 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41111 return resultobj;
41112 fail:
41113 return NULL;
41114 }
41115
41116
41117 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41118 PyObject *resultobj;
41119 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41120 size_t arg2 ;
41121 int arg3 = (int) 0 ;
41122 PyObject * obj0 = 0 ;
41123 PyObject * obj1 = 0 ;
41124 PyObject * obj2 = 0 ;
41125 char *kwnames[] = {
41126 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41127 };
41128
41129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41131 if (SWIG_arg_fail(1)) SWIG_fail;
41132 {
41133 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41134 if (SWIG_arg_fail(2)) SWIG_fail;
41135 }
41136 if (obj2) {
41137 {
41138 arg3 = (int)(SWIG_As_int(obj2));
41139 if (SWIG_arg_fail(3)) SWIG_fail;
41140 }
41141 }
41142 {
41143 PyThreadState* __tstate = wxPyBeginAllowThreads();
41144 (arg1)->AddGrowableRow(arg2,arg3);
41145
41146 wxPyEndAllowThreads(__tstate);
41147 if (PyErr_Occurred()) SWIG_fail;
41148 }
41149 Py_INCREF(Py_None); resultobj = Py_None;
41150 return resultobj;
41151 fail:
41152 return NULL;
41153 }
41154
41155
41156 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41157 PyObject *resultobj;
41158 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41159 size_t arg2 ;
41160 PyObject * obj0 = 0 ;
41161 PyObject * obj1 = 0 ;
41162 char *kwnames[] = {
41163 (char *) "self",(char *) "idx", NULL
41164 };
41165
41166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41168 if (SWIG_arg_fail(1)) SWIG_fail;
41169 {
41170 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41171 if (SWIG_arg_fail(2)) SWIG_fail;
41172 }
41173 {
41174 PyThreadState* __tstate = wxPyBeginAllowThreads();
41175 (arg1)->RemoveGrowableRow(arg2);
41176
41177 wxPyEndAllowThreads(__tstate);
41178 if (PyErr_Occurred()) SWIG_fail;
41179 }
41180 Py_INCREF(Py_None); resultobj = Py_None;
41181 return resultobj;
41182 fail:
41183 return NULL;
41184 }
41185
41186
41187 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41188 PyObject *resultobj;
41189 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41190 size_t arg2 ;
41191 int arg3 = (int) 0 ;
41192 PyObject * obj0 = 0 ;
41193 PyObject * obj1 = 0 ;
41194 PyObject * obj2 = 0 ;
41195 char *kwnames[] = {
41196 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41197 };
41198
41199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41201 if (SWIG_arg_fail(1)) SWIG_fail;
41202 {
41203 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41204 if (SWIG_arg_fail(2)) SWIG_fail;
41205 }
41206 if (obj2) {
41207 {
41208 arg3 = (int)(SWIG_As_int(obj2));
41209 if (SWIG_arg_fail(3)) SWIG_fail;
41210 }
41211 }
41212 {
41213 PyThreadState* __tstate = wxPyBeginAllowThreads();
41214 (arg1)->AddGrowableCol(arg2,arg3);
41215
41216 wxPyEndAllowThreads(__tstate);
41217 if (PyErr_Occurred()) SWIG_fail;
41218 }
41219 Py_INCREF(Py_None); resultobj = Py_None;
41220 return resultobj;
41221 fail:
41222 return NULL;
41223 }
41224
41225
41226 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41227 PyObject *resultobj;
41228 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41229 size_t arg2 ;
41230 PyObject * obj0 = 0 ;
41231 PyObject * obj1 = 0 ;
41232 char *kwnames[] = {
41233 (char *) "self",(char *) "idx", NULL
41234 };
41235
41236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41238 if (SWIG_arg_fail(1)) SWIG_fail;
41239 {
41240 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41241 if (SWIG_arg_fail(2)) SWIG_fail;
41242 }
41243 {
41244 PyThreadState* __tstate = wxPyBeginAllowThreads();
41245 (arg1)->RemoveGrowableCol(arg2);
41246
41247 wxPyEndAllowThreads(__tstate);
41248 if (PyErr_Occurred()) SWIG_fail;
41249 }
41250 Py_INCREF(Py_None); resultobj = Py_None;
41251 return resultobj;
41252 fail:
41253 return NULL;
41254 }
41255
41256
41257 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41258 PyObject *resultobj;
41259 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41260 int arg2 ;
41261 PyObject * obj0 = 0 ;
41262 PyObject * obj1 = 0 ;
41263 char *kwnames[] = {
41264 (char *) "self",(char *) "direction", NULL
41265 };
41266
41267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41269 if (SWIG_arg_fail(1)) SWIG_fail;
41270 {
41271 arg2 = (int)(SWIG_As_int(obj1));
41272 if (SWIG_arg_fail(2)) SWIG_fail;
41273 }
41274 {
41275 PyThreadState* __tstate = wxPyBeginAllowThreads();
41276 (arg1)->SetFlexibleDirection(arg2);
41277
41278 wxPyEndAllowThreads(__tstate);
41279 if (PyErr_Occurred()) SWIG_fail;
41280 }
41281 Py_INCREF(Py_None); resultobj = Py_None;
41282 return resultobj;
41283 fail:
41284 return NULL;
41285 }
41286
41287
41288 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41289 PyObject *resultobj;
41290 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41291 int result;
41292 PyObject * obj0 = 0 ;
41293 char *kwnames[] = {
41294 (char *) "self", NULL
41295 };
41296
41297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41299 if (SWIG_arg_fail(1)) SWIG_fail;
41300 {
41301 PyThreadState* __tstate = wxPyBeginAllowThreads();
41302 result = (int)(arg1)->GetFlexibleDirection();
41303
41304 wxPyEndAllowThreads(__tstate);
41305 if (PyErr_Occurred()) SWIG_fail;
41306 }
41307 {
41308 resultobj = SWIG_From_int((int)(result));
41309 }
41310 return resultobj;
41311 fail:
41312 return NULL;
41313 }
41314
41315
41316 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41317 PyObject *resultobj;
41318 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41319 wxFlexSizerGrowMode arg2 ;
41320 PyObject * obj0 = 0 ;
41321 PyObject * obj1 = 0 ;
41322 char *kwnames[] = {
41323 (char *) "self",(char *) "mode", NULL
41324 };
41325
41326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41328 if (SWIG_arg_fail(1)) SWIG_fail;
41329 {
41330 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41331 if (SWIG_arg_fail(2)) SWIG_fail;
41332 }
41333 {
41334 PyThreadState* __tstate = wxPyBeginAllowThreads();
41335 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41336
41337 wxPyEndAllowThreads(__tstate);
41338 if (PyErr_Occurred()) SWIG_fail;
41339 }
41340 Py_INCREF(Py_None); resultobj = Py_None;
41341 return resultobj;
41342 fail:
41343 return NULL;
41344 }
41345
41346
41347 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41348 PyObject *resultobj;
41349 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41350 wxFlexSizerGrowMode result;
41351 PyObject * obj0 = 0 ;
41352 char *kwnames[] = {
41353 (char *) "self", NULL
41354 };
41355
41356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41358 if (SWIG_arg_fail(1)) SWIG_fail;
41359 {
41360 PyThreadState* __tstate = wxPyBeginAllowThreads();
41361 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41362
41363 wxPyEndAllowThreads(__tstate);
41364 if (PyErr_Occurred()) SWIG_fail;
41365 }
41366 resultobj = SWIG_From_int((result));
41367 return resultobj;
41368 fail:
41369 return NULL;
41370 }
41371
41372
41373 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41374 PyObject *resultobj;
41375 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41376 wxArrayInt *result;
41377 PyObject * obj0 = 0 ;
41378 char *kwnames[] = {
41379 (char *) "self", NULL
41380 };
41381
41382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41384 if (SWIG_arg_fail(1)) SWIG_fail;
41385 {
41386 PyThreadState* __tstate = wxPyBeginAllowThreads();
41387 {
41388 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41389 result = (wxArrayInt *) &_result_ref;
41390 }
41391
41392 wxPyEndAllowThreads(__tstate);
41393 if (PyErr_Occurred()) SWIG_fail;
41394 }
41395 {
41396 resultobj = PyList_New(0);
41397 size_t idx;
41398 for (idx = 0; idx < result->GetCount(); idx += 1) {
41399 PyObject* val = PyInt_FromLong( result->Item(idx) );
41400 PyList_Append(resultobj, val);
41401 Py_DECREF(val);
41402 }
41403 }
41404 return resultobj;
41405 fail:
41406 return NULL;
41407 }
41408
41409
41410 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41411 PyObject *resultobj;
41412 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41413 wxArrayInt *result;
41414 PyObject * obj0 = 0 ;
41415 char *kwnames[] = {
41416 (char *) "self", NULL
41417 };
41418
41419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41421 if (SWIG_arg_fail(1)) SWIG_fail;
41422 {
41423 PyThreadState* __tstate = wxPyBeginAllowThreads();
41424 {
41425 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41426 result = (wxArrayInt *) &_result_ref;
41427 }
41428
41429 wxPyEndAllowThreads(__tstate);
41430 if (PyErr_Occurred()) SWIG_fail;
41431 }
41432 {
41433 resultobj = PyList_New(0);
41434 size_t idx;
41435 for (idx = 0; idx < result->GetCount(); idx += 1) {
41436 PyObject* val = PyInt_FromLong( result->Item(idx) );
41437 PyList_Append(resultobj, val);
41438 Py_DECREF(val);
41439 }
41440 }
41441 return resultobj;
41442 fail:
41443 return NULL;
41444 }
41445
41446
41447 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41448 PyObject *obj;
41449 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41450 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41451 Py_INCREF(obj);
41452 return Py_BuildValue((char *)"");
41453 }
41454 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41455 PyObject *resultobj;
41456 wxStdDialogButtonSizer *result;
41457 char *kwnames[] = {
41458 NULL
41459 };
41460
41461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41462 {
41463 PyThreadState* __tstate = wxPyBeginAllowThreads();
41464 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41465
41466 wxPyEndAllowThreads(__tstate);
41467 if (PyErr_Occurred()) SWIG_fail;
41468 }
41469 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41470 return resultobj;
41471 fail:
41472 return NULL;
41473 }
41474
41475
41476 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41477 PyObject *resultobj;
41478 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41479 wxButton *arg2 = (wxButton *) 0 ;
41480 PyObject * obj0 = 0 ;
41481 PyObject * obj1 = 0 ;
41482 char *kwnames[] = {
41483 (char *) "self",(char *) "button", NULL
41484 };
41485
41486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41488 if (SWIG_arg_fail(1)) SWIG_fail;
41489 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41490 if (SWIG_arg_fail(2)) SWIG_fail;
41491 {
41492 PyThreadState* __tstate = wxPyBeginAllowThreads();
41493 (arg1)->AddButton(arg2);
41494
41495 wxPyEndAllowThreads(__tstate);
41496 if (PyErr_Occurred()) SWIG_fail;
41497 }
41498 Py_INCREF(Py_None); resultobj = Py_None;
41499 return resultobj;
41500 fail:
41501 return NULL;
41502 }
41503
41504
41505 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41506 PyObject *resultobj;
41507 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41508 PyObject * obj0 = 0 ;
41509 char *kwnames[] = {
41510 (char *) "self", NULL
41511 };
41512
41513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41515 if (SWIG_arg_fail(1)) SWIG_fail;
41516 {
41517 PyThreadState* __tstate = wxPyBeginAllowThreads();
41518 (arg1)->Realize();
41519
41520 wxPyEndAllowThreads(__tstate);
41521 if (PyErr_Occurred()) SWIG_fail;
41522 }
41523 Py_INCREF(Py_None); resultobj = Py_None;
41524 return resultobj;
41525 fail:
41526 return NULL;
41527 }
41528
41529
41530 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41531 PyObject *resultobj;
41532 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41533 wxButton *arg2 = (wxButton *) 0 ;
41534 PyObject * obj0 = 0 ;
41535 PyObject * obj1 = 0 ;
41536 char *kwnames[] = {
41537 (char *) "self",(char *) "button", NULL
41538 };
41539
41540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41542 if (SWIG_arg_fail(1)) SWIG_fail;
41543 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41544 if (SWIG_arg_fail(2)) SWIG_fail;
41545 {
41546 PyThreadState* __tstate = wxPyBeginAllowThreads();
41547 (arg1)->SetAffirmativeButton(arg2);
41548
41549 wxPyEndAllowThreads(__tstate);
41550 if (PyErr_Occurred()) SWIG_fail;
41551 }
41552 Py_INCREF(Py_None); resultobj = Py_None;
41553 return resultobj;
41554 fail:
41555 return NULL;
41556 }
41557
41558
41559 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41560 PyObject *resultobj;
41561 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41562 wxButton *arg2 = (wxButton *) 0 ;
41563 PyObject * obj0 = 0 ;
41564 PyObject * obj1 = 0 ;
41565 char *kwnames[] = {
41566 (char *) "self",(char *) "button", NULL
41567 };
41568
41569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41571 if (SWIG_arg_fail(1)) SWIG_fail;
41572 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41573 if (SWIG_arg_fail(2)) SWIG_fail;
41574 {
41575 PyThreadState* __tstate = wxPyBeginAllowThreads();
41576 (arg1)->SetNegativeButton(arg2);
41577
41578 wxPyEndAllowThreads(__tstate);
41579 if (PyErr_Occurred()) SWIG_fail;
41580 }
41581 Py_INCREF(Py_None); resultobj = Py_None;
41582 return resultobj;
41583 fail:
41584 return NULL;
41585 }
41586
41587
41588 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41589 PyObject *resultobj;
41590 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41591 wxButton *arg2 = (wxButton *) 0 ;
41592 PyObject * obj0 = 0 ;
41593 PyObject * obj1 = 0 ;
41594 char *kwnames[] = {
41595 (char *) "self",(char *) "button", NULL
41596 };
41597
41598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41600 if (SWIG_arg_fail(1)) SWIG_fail;
41601 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41602 if (SWIG_arg_fail(2)) SWIG_fail;
41603 {
41604 PyThreadState* __tstate = wxPyBeginAllowThreads();
41605 (arg1)->SetCancelButton(arg2);
41606
41607 wxPyEndAllowThreads(__tstate);
41608 if (PyErr_Occurred()) SWIG_fail;
41609 }
41610 Py_INCREF(Py_None); resultobj = Py_None;
41611 return resultobj;
41612 fail:
41613 return NULL;
41614 }
41615
41616
41617 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41618 PyObject *resultobj;
41619 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41620 wxButton *result;
41621 PyObject * obj0 = 0 ;
41622 char *kwnames[] = {
41623 (char *) "self", NULL
41624 };
41625
41626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41628 if (SWIG_arg_fail(1)) SWIG_fail;
41629 {
41630 PyThreadState* __tstate = wxPyBeginAllowThreads();
41631 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41632
41633 wxPyEndAllowThreads(__tstate);
41634 if (PyErr_Occurred()) SWIG_fail;
41635 }
41636 {
41637 resultobj = wxPyMake_wxObject(result, 0);
41638 }
41639 return resultobj;
41640 fail:
41641 return NULL;
41642 }
41643
41644
41645 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41646 PyObject *resultobj;
41647 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41648 wxButton *result;
41649 PyObject * obj0 = 0 ;
41650 char *kwnames[] = {
41651 (char *) "self", NULL
41652 };
41653
41654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41656 if (SWIG_arg_fail(1)) SWIG_fail;
41657 {
41658 PyThreadState* __tstate = wxPyBeginAllowThreads();
41659 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41660
41661 wxPyEndAllowThreads(__tstate);
41662 if (PyErr_Occurred()) SWIG_fail;
41663 }
41664 {
41665 resultobj = wxPyMake_wxObject(result, 0);
41666 }
41667 return resultobj;
41668 fail:
41669 return NULL;
41670 }
41671
41672
41673 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41674 PyObject *resultobj;
41675 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41676 wxButton *result;
41677 PyObject * obj0 = 0 ;
41678 char *kwnames[] = {
41679 (char *) "self", NULL
41680 };
41681
41682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41684 if (SWIG_arg_fail(1)) SWIG_fail;
41685 {
41686 PyThreadState* __tstate = wxPyBeginAllowThreads();
41687 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41688
41689 wxPyEndAllowThreads(__tstate);
41690 if (PyErr_Occurred()) SWIG_fail;
41691 }
41692 {
41693 resultobj = wxPyMake_wxObject(result, 0);
41694 }
41695 return resultobj;
41696 fail:
41697 return NULL;
41698 }
41699
41700
41701 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41702 PyObject *resultobj;
41703 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41704 wxButton *result;
41705 PyObject * obj0 = 0 ;
41706 char *kwnames[] = {
41707 (char *) "self", NULL
41708 };
41709
41710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41712 if (SWIG_arg_fail(1)) SWIG_fail;
41713 {
41714 PyThreadState* __tstate = wxPyBeginAllowThreads();
41715 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41716
41717 wxPyEndAllowThreads(__tstate);
41718 if (PyErr_Occurred()) SWIG_fail;
41719 }
41720 {
41721 resultobj = wxPyMake_wxObject(result, 0);
41722 }
41723 return resultobj;
41724 fail:
41725 return NULL;
41726 }
41727
41728
41729 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41730 PyObject *resultobj;
41731 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41732 wxButton *result;
41733 PyObject * obj0 = 0 ;
41734 char *kwnames[] = {
41735 (char *) "self", NULL
41736 };
41737
41738 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41739 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41740 if (SWIG_arg_fail(1)) SWIG_fail;
41741 {
41742 PyThreadState* __tstate = wxPyBeginAllowThreads();
41743 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41744
41745 wxPyEndAllowThreads(__tstate);
41746 if (PyErr_Occurred()) SWIG_fail;
41747 }
41748 {
41749 resultobj = wxPyMake_wxObject(result, 0);
41750 }
41751 return resultobj;
41752 fail:
41753 return NULL;
41754 }
41755
41756
41757 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41758 PyObject *obj;
41759 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41760 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41761 Py_INCREF(obj);
41762 return Py_BuildValue((char *)"");
41763 }
41764 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41765 PyObject *resultobj;
41766 int arg1 = (int) 0 ;
41767 int arg2 = (int) 0 ;
41768 wxGBPosition *result;
41769 PyObject * obj0 = 0 ;
41770 PyObject * obj1 = 0 ;
41771 char *kwnames[] = {
41772 (char *) "row",(char *) "col", NULL
41773 };
41774
41775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41776 if (obj0) {
41777 {
41778 arg1 = (int)(SWIG_As_int(obj0));
41779 if (SWIG_arg_fail(1)) SWIG_fail;
41780 }
41781 }
41782 if (obj1) {
41783 {
41784 arg2 = (int)(SWIG_As_int(obj1));
41785 if (SWIG_arg_fail(2)) SWIG_fail;
41786 }
41787 }
41788 {
41789 PyThreadState* __tstate = wxPyBeginAllowThreads();
41790 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41791
41792 wxPyEndAllowThreads(__tstate);
41793 if (PyErr_Occurred()) SWIG_fail;
41794 }
41795 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41796 return resultobj;
41797 fail:
41798 return NULL;
41799 }
41800
41801
41802 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41803 PyObject *resultobj;
41804 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41805 int result;
41806 PyObject * obj0 = 0 ;
41807 char *kwnames[] = {
41808 (char *) "self", NULL
41809 };
41810
41811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41813 if (SWIG_arg_fail(1)) SWIG_fail;
41814 {
41815 PyThreadState* __tstate = wxPyBeginAllowThreads();
41816 result = (int)((wxGBPosition const *)arg1)->GetRow();
41817
41818 wxPyEndAllowThreads(__tstate);
41819 if (PyErr_Occurred()) SWIG_fail;
41820 }
41821 {
41822 resultobj = SWIG_From_int((int)(result));
41823 }
41824 return resultobj;
41825 fail:
41826 return NULL;
41827 }
41828
41829
41830 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41831 PyObject *resultobj;
41832 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41833 int result;
41834 PyObject * obj0 = 0 ;
41835 char *kwnames[] = {
41836 (char *) "self", NULL
41837 };
41838
41839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41841 if (SWIG_arg_fail(1)) SWIG_fail;
41842 {
41843 PyThreadState* __tstate = wxPyBeginAllowThreads();
41844 result = (int)((wxGBPosition const *)arg1)->GetCol();
41845
41846 wxPyEndAllowThreads(__tstate);
41847 if (PyErr_Occurred()) SWIG_fail;
41848 }
41849 {
41850 resultobj = SWIG_From_int((int)(result));
41851 }
41852 return resultobj;
41853 fail:
41854 return NULL;
41855 }
41856
41857
41858 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41859 PyObject *resultobj;
41860 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41861 int arg2 ;
41862 PyObject * obj0 = 0 ;
41863 PyObject * obj1 = 0 ;
41864 char *kwnames[] = {
41865 (char *) "self",(char *) "row", NULL
41866 };
41867
41868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41870 if (SWIG_arg_fail(1)) SWIG_fail;
41871 {
41872 arg2 = (int)(SWIG_As_int(obj1));
41873 if (SWIG_arg_fail(2)) SWIG_fail;
41874 }
41875 {
41876 PyThreadState* __tstate = wxPyBeginAllowThreads();
41877 (arg1)->SetRow(arg2);
41878
41879 wxPyEndAllowThreads(__tstate);
41880 if (PyErr_Occurred()) SWIG_fail;
41881 }
41882 Py_INCREF(Py_None); resultobj = Py_None;
41883 return resultobj;
41884 fail:
41885 return NULL;
41886 }
41887
41888
41889 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41890 PyObject *resultobj;
41891 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41892 int arg2 ;
41893 PyObject * obj0 = 0 ;
41894 PyObject * obj1 = 0 ;
41895 char *kwnames[] = {
41896 (char *) "self",(char *) "col", NULL
41897 };
41898
41899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41901 if (SWIG_arg_fail(1)) SWIG_fail;
41902 {
41903 arg2 = (int)(SWIG_As_int(obj1));
41904 if (SWIG_arg_fail(2)) SWIG_fail;
41905 }
41906 {
41907 PyThreadState* __tstate = wxPyBeginAllowThreads();
41908 (arg1)->SetCol(arg2);
41909
41910 wxPyEndAllowThreads(__tstate);
41911 if (PyErr_Occurred()) SWIG_fail;
41912 }
41913 Py_INCREF(Py_None); resultobj = Py_None;
41914 return resultobj;
41915 fail:
41916 return NULL;
41917 }
41918
41919
41920 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41921 PyObject *resultobj;
41922 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41923 wxGBPosition *arg2 = 0 ;
41924 bool result;
41925 wxGBPosition temp2 ;
41926 PyObject * obj0 = 0 ;
41927 PyObject * obj1 = 0 ;
41928 char *kwnames[] = {
41929 (char *) "self",(char *) "other", NULL
41930 };
41931
41932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41934 if (SWIG_arg_fail(1)) SWIG_fail;
41935 {
41936 arg2 = &temp2;
41937 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41938 }
41939 {
41940 PyThreadState* __tstate = wxPyBeginAllowThreads();
41941 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41942
41943 wxPyEndAllowThreads(__tstate);
41944 if (PyErr_Occurred()) SWIG_fail;
41945 }
41946 {
41947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41948 }
41949 return resultobj;
41950 fail:
41951 return NULL;
41952 }
41953
41954
41955 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41956 PyObject *resultobj;
41957 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41958 wxGBPosition *arg2 = 0 ;
41959 bool result;
41960 wxGBPosition temp2 ;
41961 PyObject * obj0 = 0 ;
41962 PyObject * obj1 = 0 ;
41963 char *kwnames[] = {
41964 (char *) "self",(char *) "other", NULL
41965 };
41966
41967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41969 if (SWIG_arg_fail(1)) SWIG_fail;
41970 {
41971 arg2 = &temp2;
41972 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41973 }
41974 {
41975 PyThreadState* __tstate = wxPyBeginAllowThreads();
41976 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41977
41978 wxPyEndAllowThreads(__tstate);
41979 if (PyErr_Occurred()) SWIG_fail;
41980 }
41981 {
41982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41983 }
41984 return resultobj;
41985 fail:
41986 return NULL;
41987 }
41988
41989
41990 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41991 PyObject *resultobj;
41992 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41993 int arg2 = (int) 0 ;
41994 int arg3 = (int) 0 ;
41995 PyObject * obj0 = 0 ;
41996 PyObject * obj1 = 0 ;
41997 PyObject * obj2 = 0 ;
41998 char *kwnames[] = {
41999 (char *) "self",(char *) "row",(char *) "col", NULL
42000 };
42001
42002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42004 if (SWIG_arg_fail(1)) SWIG_fail;
42005 if (obj1) {
42006 {
42007 arg2 = (int)(SWIG_As_int(obj1));
42008 if (SWIG_arg_fail(2)) SWIG_fail;
42009 }
42010 }
42011 if (obj2) {
42012 {
42013 arg3 = (int)(SWIG_As_int(obj2));
42014 if (SWIG_arg_fail(3)) SWIG_fail;
42015 }
42016 }
42017 {
42018 PyThreadState* __tstate = wxPyBeginAllowThreads();
42019 wxGBPosition_Set(arg1,arg2,arg3);
42020
42021 wxPyEndAllowThreads(__tstate);
42022 if (PyErr_Occurred()) SWIG_fail;
42023 }
42024 Py_INCREF(Py_None); resultobj = Py_None;
42025 return resultobj;
42026 fail:
42027 return NULL;
42028 }
42029
42030
42031 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42032 PyObject *resultobj;
42033 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42034 PyObject *result;
42035 PyObject * obj0 = 0 ;
42036 char *kwnames[] = {
42037 (char *) "self", NULL
42038 };
42039
42040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42042 if (SWIG_arg_fail(1)) SWIG_fail;
42043 {
42044 PyThreadState* __tstate = wxPyBeginAllowThreads();
42045 result = (PyObject *)wxGBPosition_Get(arg1);
42046
42047 wxPyEndAllowThreads(__tstate);
42048 if (PyErr_Occurred()) SWIG_fail;
42049 }
42050 resultobj = result;
42051 return resultobj;
42052 fail:
42053 return NULL;
42054 }
42055
42056
42057 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42058 PyObject *obj;
42059 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42060 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42061 Py_INCREF(obj);
42062 return Py_BuildValue((char *)"");
42063 }
42064 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42065 PyObject *resultobj;
42066 int arg1 = (int) 1 ;
42067 int arg2 = (int) 1 ;
42068 wxGBSpan *result;
42069 PyObject * obj0 = 0 ;
42070 PyObject * obj1 = 0 ;
42071 char *kwnames[] = {
42072 (char *) "rowspan",(char *) "colspan", NULL
42073 };
42074
42075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42076 if (obj0) {
42077 {
42078 arg1 = (int)(SWIG_As_int(obj0));
42079 if (SWIG_arg_fail(1)) SWIG_fail;
42080 }
42081 }
42082 if (obj1) {
42083 {
42084 arg2 = (int)(SWIG_As_int(obj1));
42085 if (SWIG_arg_fail(2)) SWIG_fail;
42086 }
42087 }
42088 {
42089 PyThreadState* __tstate = wxPyBeginAllowThreads();
42090 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42091
42092 wxPyEndAllowThreads(__tstate);
42093 if (PyErr_Occurred()) SWIG_fail;
42094 }
42095 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42096 return resultobj;
42097 fail:
42098 return NULL;
42099 }
42100
42101
42102 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42103 PyObject *resultobj;
42104 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42105 int result;
42106 PyObject * obj0 = 0 ;
42107 char *kwnames[] = {
42108 (char *) "self", NULL
42109 };
42110
42111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42113 if (SWIG_arg_fail(1)) SWIG_fail;
42114 {
42115 PyThreadState* __tstate = wxPyBeginAllowThreads();
42116 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42117
42118 wxPyEndAllowThreads(__tstate);
42119 if (PyErr_Occurred()) SWIG_fail;
42120 }
42121 {
42122 resultobj = SWIG_From_int((int)(result));
42123 }
42124 return resultobj;
42125 fail:
42126 return NULL;
42127 }
42128
42129
42130 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42131 PyObject *resultobj;
42132 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42133 int result;
42134 PyObject * obj0 = 0 ;
42135 char *kwnames[] = {
42136 (char *) "self", NULL
42137 };
42138
42139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42141 if (SWIG_arg_fail(1)) SWIG_fail;
42142 {
42143 PyThreadState* __tstate = wxPyBeginAllowThreads();
42144 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42145
42146 wxPyEndAllowThreads(__tstate);
42147 if (PyErr_Occurred()) SWIG_fail;
42148 }
42149 {
42150 resultobj = SWIG_From_int((int)(result));
42151 }
42152 return resultobj;
42153 fail:
42154 return NULL;
42155 }
42156
42157
42158 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42159 PyObject *resultobj;
42160 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42161 int arg2 ;
42162 PyObject * obj0 = 0 ;
42163 PyObject * obj1 = 0 ;
42164 char *kwnames[] = {
42165 (char *) "self",(char *) "rowspan", NULL
42166 };
42167
42168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42170 if (SWIG_arg_fail(1)) SWIG_fail;
42171 {
42172 arg2 = (int)(SWIG_As_int(obj1));
42173 if (SWIG_arg_fail(2)) SWIG_fail;
42174 }
42175 {
42176 PyThreadState* __tstate = wxPyBeginAllowThreads();
42177 (arg1)->SetRowspan(arg2);
42178
42179 wxPyEndAllowThreads(__tstate);
42180 if (PyErr_Occurred()) SWIG_fail;
42181 }
42182 Py_INCREF(Py_None); resultobj = Py_None;
42183 return resultobj;
42184 fail:
42185 return NULL;
42186 }
42187
42188
42189 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42190 PyObject *resultobj;
42191 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42192 int arg2 ;
42193 PyObject * obj0 = 0 ;
42194 PyObject * obj1 = 0 ;
42195 char *kwnames[] = {
42196 (char *) "self",(char *) "colspan", NULL
42197 };
42198
42199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42201 if (SWIG_arg_fail(1)) SWIG_fail;
42202 {
42203 arg2 = (int)(SWIG_As_int(obj1));
42204 if (SWIG_arg_fail(2)) SWIG_fail;
42205 }
42206 {
42207 PyThreadState* __tstate = wxPyBeginAllowThreads();
42208 (arg1)->SetColspan(arg2);
42209
42210 wxPyEndAllowThreads(__tstate);
42211 if (PyErr_Occurred()) SWIG_fail;
42212 }
42213 Py_INCREF(Py_None); resultobj = Py_None;
42214 return resultobj;
42215 fail:
42216 return NULL;
42217 }
42218
42219
42220 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42221 PyObject *resultobj;
42222 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42223 wxGBSpan *arg2 = 0 ;
42224 bool result;
42225 wxGBSpan temp2 ;
42226 PyObject * obj0 = 0 ;
42227 PyObject * obj1 = 0 ;
42228 char *kwnames[] = {
42229 (char *) "self",(char *) "other", NULL
42230 };
42231
42232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42234 if (SWIG_arg_fail(1)) SWIG_fail;
42235 {
42236 arg2 = &temp2;
42237 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42238 }
42239 {
42240 PyThreadState* __tstate = wxPyBeginAllowThreads();
42241 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42242
42243 wxPyEndAllowThreads(__tstate);
42244 if (PyErr_Occurred()) SWIG_fail;
42245 }
42246 {
42247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42248 }
42249 return resultobj;
42250 fail:
42251 return NULL;
42252 }
42253
42254
42255 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42256 PyObject *resultobj;
42257 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42258 wxGBSpan *arg2 = 0 ;
42259 bool result;
42260 wxGBSpan temp2 ;
42261 PyObject * obj0 = 0 ;
42262 PyObject * obj1 = 0 ;
42263 char *kwnames[] = {
42264 (char *) "self",(char *) "other", NULL
42265 };
42266
42267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42268 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42269 if (SWIG_arg_fail(1)) SWIG_fail;
42270 {
42271 arg2 = &temp2;
42272 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42273 }
42274 {
42275 PyThreadState* __tstate = wxPyBeginAllowThreads();
42276 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42277
42278 wxPyEndAllowThreads(__tstate);
42279 if (PyErr_Occurred()) SWIG_fail;
42280 }
42281 {
42282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42283 }
42284 return resultobj;
42285 fail:
42286 return NULL;
42287 }
42288
42289
42290 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42291 PyObject *resultobj;
42292 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42293 int arg2 = (int) 1 ;
42294 int arg3 = (int) 1 ;
42295 PyObject * obj0 = 0 ;
42296 PyObject * obj1 = 0 ;
42297 PyObject * obj2 = 0 ;
42298 char *kwnames[] = {
42299 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42300 };
42301
42302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42304 if (SWIG_arg_fail(1)) SWIG_fail;
42305 if (obj1) {
42306 {
42307 arg2 = (int)(SWIG_As_int(obj1));
42308 if (SWIG_arg_fail(2)) SWIG_fail;
42309 }
42310 }
42311 if (obj2) {
42312 {
42313 arg3 = (int)(SWIG_As_int(obj2));
42314 if (SWIG_arg_fail(3)) SWIG_fail;
42315 }
42316 }
42317 {
42318 PyThreadState* __tstate = wxPyBeginAllowThreads();
42319 wxGBSpan_Set(arg1,arg2,arg3);
42320
42321 wxPyEndAllowThreads(__tstate);
42322 if (PyErr_Occurred()) SWIG_fail;
42323 }
42324 Py_INCREF(Py_None); resultobj = Py_None;
42325 return resultobj;
42326 fail:
42327 return NULL;
42328 }
42329
42330
42331 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42332 PyObject *resultobj;
42333 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42334 PyObject *result;
42335 PyObject * obj0 = 0 ;
42336 char *kwnames[] = {
42337 (char *) "self", NULL
42338 };
42339
42340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42342 if (SWIG_arg_fail(1)) SWIG_fail;
42343 {
42344 PyThreadState* __tstate = wxPyBeginAllowThreads();
42345 result = (PyObject *)wxGBSpan_Get(arg1);
42346
42347 wxPyEndAllowThreads(__tstate);
42348 if (PyErr_Occurred()) SWIG_fail;
42349 }
42350 resultobj = result;
42351 return resultobj;
42352 fail:
42353 return NULL;
42354 }
42355
42356
42357 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42358 PyObject *obj;
42359 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42360 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42361 Py_INCREF(obj);
42362 return Py_BuildValue((char *)"");
42363 }
42364 static int _wrap_DefaultSpan_set(PyObject *) {
42365 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42366 return 1;
42367 }
42368
42369
42370 static PyObject *_wrap_DefaultSpan_get(void) {
42371 PyObject *pyobj;
42372
42373 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42374 return pyobj;
42375 }
42376
42377
42378 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42379 PyObject *resultobj;
42380 wxGBSizerItem *result;
42381 char *kwnames[] = {
42382 NULL
42383 };
42384
42385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42386 {
42387 PyThreadState* __tstate = wxPyBeginAllowThreads();
42388 result = (wxGBSizerItem *)new wxGBSizerItem();
42389
42390 wxPyEndAllowThreads(__tstate);
42391 if (PyErr_Occurred()) SWIG_fail;
42392 }
42393 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42394 return resultobj;
42395 fail:
42396 return NULL;
42397 }
42398
42399
42400 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42401 PyObject *resultobj;
42402 wxWindow *arg1 = (wxWindow *) 0 ;
42403 wxGBPosition *arg2 = 0 ;
42404 wxGBSpan *arg3 = 0 ;
42405 int arg4 ;
42406 int arg5 ;
42407 PyObject *arg6 = (PyObject *) NULL ;
42408 wxGBSizerItem *result;
42409 wxGBPosition temp2 ;
42410 wxGBSpan temp3 ;
42411 PyObject * obj0 = 0 ;
42412 PyObject * obj1 = 0 ;
42413 PyObject * obj2 = 0 ;
42414 PyObject * obj3 = 0 ;
42415 PyObject * obj4 = 0 ;
42416 PyObject * obj5 = 0 ;
42417 char *kwnames[] = {
42418 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42419 };
42420
42421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42423 if (SWIG_arg_fail(1)) SWIG_fail;
42424 {
42425 arg2 = &temp2;
42426 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42427 }
42428 {
42429 arg3 = &temp3;
42430 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42431 }
42432 {
42433 arg4 = (int)(SWIG_As_int(obj3));
42434 if (SWIG_arg_fail(4)) SWIG_fail;
42435 }
42436 {
42437 arg5 = (int)(SWIG_As_int(obj4));
42438 if (SWIG_arg_fail(5)) SWIG_fail;
42439 }
42440 if (obj5) {
42441 arg6 = obj5;
42442 }
42443 {
42444 PyThreadState* __tstate = wxPyBeginAllowThreads();
42445 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42446
42447 wxPyEndAllowThreads(__tstate);
42448 if (PyErr_Occurred()) SWIG_fail;
42449 }
42450 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42451 return resultobj;
42452 fail:
42453 return NULL;
42454 }
42455
42456
42457 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42458 PyObject *resultobj;
42459 wxSizer *arg1 = (wxSizer *) 0 ;
42460 wxGBPosition *arg2 = 0 ;
42461 wxGBSpan *arg3 = 0 ;
42462 int arg4 ;
42463 int arg5 ;
42464 PyObject *arg6 = (PyObject *) NULL ;
42465 wxGBSizerItem *result;
42466 wxGBPosition temp2 ;
42467 wxGBSpan temp3 ;
42468 PyObject * obj0 = 0 ;
42469 PyObject * obj1 = 0 ;
42470 PyObject * obj2 = 0 ;
42471 PyObject * obj3 = 0 ;
42472 PyObject * obj4 = 0 ;
42473 PyObject * obj5 = 0 ;
42474 char *kwnames[] = {
42475 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42476 };
42477
42478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42480 if (SWIG_arg_fail(1)) SWIG_fail;
42481 {
42482 arg2 = &temp2;
42483 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42484 }
42485 {
42486 arg3 = &temp3;
42487 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42488 }
42489 {
42490 arg4 = (int)(SWIG_As_int(obj3));
42491 if (SWIG_arg_fail(4)) SWIG_fail;
42492 }
42493 {
42494 arg5 = (int)(SWIG_As_int(obj4));
42495 if (SWIG_arg_fail(5)) SWIG_fail;
42496 }
42497 if (obj5) {
42498 arg6 = obj5;
42499 }
42500 {
42501 PyThreadState* __tstate = wxPyBeginAllowThreads();
42502 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42503
42504 wxPyEndAllowThreads(__tstate);
42505 if (PyErr_Occurred()) SWIG_fail;
42506 }
42507 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42508 return resultobj;
42509 fail:
42510 return NULL;
42511 }
42512
42513
42514 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42515 PyObject *resultobj;
42516 int arg1 ;
42517 int arg2 ;
42518 wxGBPosition *arg3 = 0 ;
42519 wxGBSpan *arg4 = 0 ;
42520 int arg5 ;
42521 int arg6 ;
42522 PyObject *arg7 = (PyObject *) NULL ;
42523 wxGBSizerItem *result;
42524 wxGBPosition temp3 ;
42525 wxGBSpan temp4 ;
42526 PyObject * obj0 = 0 ;
42527 PyObject * obj1 = 0 ;
42528 PyObject * obj2 = 0 ;
42529 PyObject * obj3 = 0 ;
42530 PyObject * obj4 = 0 ;
42531 PyObject * obj5 = 0 ;
42532 PyObject * obj6 = 0 ;
42533 char *kwnames[] = {
42534 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42535 };
42536
42537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42538 {
42539 arg1 = (int)(SWIG_As_int(obj0));
42540 if (SWIG_arg_fail(1)) SWIG_fail;
42541 }
42542 {
42543 arg2 = (int)(SWIG_As_int(obj1));
42544 if (SWIG_arg_fail(2)) SWIG_fail;
42545 }
42546 {
42547 arg3 = &temp3;
42548 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42549 }
42550 {
42551 arg4 = &temp4;
42552 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42553 }
42554 {
42555 arg5 = (int)(SWIG_As_int(obj4));
42556 if (SWIG_arg_fail(5)) SWIG_fail;
42557 }
42558 {
42559 arg6 = (int)(SWIG_As_int(obj5));
42560 if (SWIG_arg_fail(6)) SWIG_fail;
42561 }
42562 if (obj6) {
42563 arg7 = obj6;
42564 }
42565 {
42566 PyThreadState* __tstate = wxPyBeginAllowThreads();
42567 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42568
42569 wxPyEndAllowThreads(__tstate);
42570 if (PyErr_Occurred()) SWIG_fail;
42571 }
42572 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42573 return resultobj;
42574 fail:
42575 return NULL;
42576 }
42577
42578
42579 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42580 PyObject *resultobj;
42581 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42582 wxGBPosition result;
42583 PyObject * obj0 = 0 ;
42584 char *kwnames[] = {
42585 (char *) "self", NULL
42586 };
42587
42588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42590 if (SWIG_arg_fail(1)) SWIG_fail;
42591 {
42592 PyThreadState* __tstate = wxPyBeginAllowThreads();
42593 result = ((wxGBSizerItem const *)arg1)->GetPos();
42594
42595 wxPyEndAllowThreads(__tstate);
42596 if (PyErr_Occurred()) SWIG_fail;
42597 }
42598 {
42599 wxGBPosition * resultptr;
42600 resultptr = new wxGBPosition((wxGBPosition &)(result));
42601 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42602 }
42603 return resultobj;
42604 fail:
42605 return NULL;
42606 }
42607
42608
42609 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42610 PyObject *resultobj;
42611 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42612 wxGBSpan result;
42613 PyObject * obj0 = 0 ;
42614 char *kwnames[] = {
42615 (char *) "self", NULL
42616 };
42617
42618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42620 if (SWIG_arg_fail(1)) SWIG_fail;
42621 {
42622 PyThreadState* __tstate = wxPyBeginAllowThreads();
42623 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42624
42625 wxPyEndAllowThreads(__tstate);
42626 if (PyErr_Occurred()) SWIG_fail;
42627 }
42628 {
42629 wxGBSpan * resultptr;
42630 resultptr = new wxGBSpan((wxGBSpan &)(result));
42631 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42632 }
42633 return resultobj;
42634 fail:
42635 return NULL;
42636 }
42637
42638
42639 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42640 PyObject *resultobj;
42641 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42642 wxGBPosition *arg2 = 0 ;
42643 bool result;
42644 wxGBPosition temp2 ;
42645 PyObject * obj0 = 0 ;
42646 PyObject * obj1 = 0 ;
42647 char *kwnames[] = {
42648 (char *) "self",(char *) "pos", NULL
42649 };
42650
42651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42653 if (SWIG_arg_fail(1)) SWIG_fail;
42654 {
42655 arg2 = &temp2;
42656 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42657 }
42658 {
42659 PyThreadState* __tstate = wxPyBeginAllowThreads();
42660 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42661
42662 wxPyEndAllowThreads(__tstate);
42663 if (PyErr_Occurred()) SWIG_fail;
42664 }
42665 {
42666 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42667 }
42668 return resultobj;
42669 fail:
42670 return NULL;
42671 }
42672
42673
42674 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42675 PyObject *resultobj;
42676 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42677 wxGBSpan *arg2 = 0 ;
42678 bool result;
42679 wxGBSpan temp2 ;
42680 PyObject * obj0 = 0 ;
42681 PyObject * obj1 = 0 ;
42682 char *kwnames[] = {
42683 (char *) "self",(char *) "span", NULL
42684 };
42685
42686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42688 if (SWIG_arg_fail(1)) SWIG_fail;
42689 {
42690 arg2 = &temp2;
42691 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42692 }
42693 {
42694 PyThreadState* __tstate = wxPyBeginAllowThreads();
42695 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42696
42697 wxPyEndAllowThreads(__tstate);
42698 if (PyErr_Occurred()) SWIG_fail;
42699 }
42700 {
42701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42702 }
42703 return resultobj;
42704 fail:
42705 return NULL;
42706 }
42707
42708
42709 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42710 PyObject *resultobj;
42711 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42712 wxGBSizerItem *arg2 = 0 ;
42713 bool result;
42714 PyObject * obj0 = 0 ;
42715 PyObject * obj1 = 0 ;
42716 char *kwnames[] = {
42717 (char *) "self",(char *) "other", NULL
42718 };
42719
42720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42722 if (SWIG_arg_fail(1)) SWIG_fail;
42723 {
42724 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42725 if (SWIG_arg_fail(2)) SWIG_fail;
42726 if (arg2 == NULL) {
42727 SWIG_null_ref("wxGBSizerItem");
42728 }
42729 if (SWIG_arg_fail(2)) SWIG_fail;
42730 }
42731 {
42732 PyThreadState* __tstate = wxPyBeginAllowThreads();
42733 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42734
42735 wxPyEndAllowThreads(__tstate);
42736 if (PyErr_Occurred()) SWIG_fail;
42737 }
42738 {
42739 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42740 }
42741 return resultobj;
42742 fail:
42743 return NULL;
42744 }
42745
42746
42747 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42748 PyObject *resultobj;
42749 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42750 wxGBPosition *arg2 = 0 ;
42751 wxGBSpan *arg3 = 0 ;
42752 bool result;
42753 wxGBPosition temp2 ;
42754 wxGBSpan temp3 ;
42755 PyObject * obj0 = 0 ;
42756 PyObject * obj1 = 0 ;
42757 PyObject * obj2 = 0 ;
42758 char *kwnames[] = {
42759 (char *) "self",(char *) "pos",(char *) "span", NULL
42760 };
42761
42762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42764 if (SWIG_arg_fail(1)) SWIG_fail;
42765 {
42766 arg2 = &temp2;
42767 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42768 }
42769 {
42770 arg3 = &temp3;
42771 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42772 }
42773 {
42774 PyThreadState* __tstate = wxPyBeginAllowThreads();
42775 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42776
42777 wxPyEndAllowThreads(__tstate);
42778 if (PyErr_Occurred()) SWIG_fail;
42779 }
42780 {
42781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42782 }
42783 return resultobj;
42784 fail:
42785 return NULL;
42786 }
42787
42788
42789 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42790 PyObject *resultobj;
42791 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42792 wxGBPosition result;
42793 PyObject * obj0 = 0 ;
42794 char *kwnames[] = {
42795 (char *) "self", NULL
42796 };
42797
42798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42800 if (SWIG_arg_fail(1)) SWIG_fail;
42801 {
42802 PyThreadState* __tstate = wxPyBeginAllowThreads();
42803 result = wxGBSizerItem_GetEndPos(arg1);
42804
42805 wxPyEndAllowThreads(__tstate);
42806 if (PyErr_Occurred()) SWIG_fail;
42807 }
42808 {
42809 wxGBPosition * resultptr;
42810 resultptr = new wxGBPosition((wxGBPosition &)(result));
42811 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42812 }
42813 return resultobj;
42814 fail:
42815 return NULL;
42816 }
42817
42818
42819 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42820 PyObject *resultobj;
42821 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42822 wxGridBagSizer *result;
42823 PyObject * obj0 = 0 ;
42824 char *kwnames[] = {
42825 (char *) "self", NULL
42826 };
42827
42828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42830 if (SWIG_arg_fail(1)) SWIG_fail;
42831 {
42832 PyThreadState* __tstate = wxPyBeginAllowThreads();
42833 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42834
42835 wxPyEndAllowThreads(__tstate);
42836 if (PyErr_Occurred()) SWIG_fail;
42837 }
42838 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42839 return resultobj;
42840 fail:
42841 return NULL;
42842 }
42843
42844
42845 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42846 PyObject *resultobj;
42847 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42848 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42849 PyObject * obj0 = 0 ;
42850 PyObject * obj1 = 0 ;
42851 char *kwnames[] = {
42852 (char *) "self",(char *) "sizer", NULL
42853 };
42854
42855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42857 if (SWIG_arg_fail(1)) SWIG_fail;
42858 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42859 if (SWIG_arg_fail(2)) SWIG_fail;
42860 {
42861 PyThreadState* __tstate = wxPyBeginAllowThreads();
42862 (arg1)->SetGBSizer(arg2);
42863
42864 wxPyEndAllowThreads(__tstate);
42865 if (PyErr_Occurred()) SWIG_fail;
42866 }
42867 Py_INCREF(Py_None); resultobj = Py_None;
42868 return resultobj;
42869 fail:
42870 return NULL;
42871 }
42872
42873
42874 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42875 PyObject *obj;
42876 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42877 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42878 Py_INCREF(obj);
42879 return Py_BuildValue((char *)"");
42880 }
42881 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42882 PyObject *resultobj;
42883 int arg1 = (int) 0 ;
42884 int arg2 = (int) 0 ;
42885 wxGridBagSizer *result;
42886 PyObject * obj0 = 0 ;
42887 PyObject * obj1 = 0 ;
42888 char *kwnames[] = {
42889 (char *) "vgap",(char *) "hgap", NULL
42890 };
42891
42892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42893 if (obj0) {
42894 {
42895 arg1 = (int)(SWIG_As_int(obj0));
42896 if (SWIG_arg_fail(1)) SWIG_fail;
42897 }
42898 }
42899 if (obj1) {
42900 {
42901 arg2 = (int)(SWIG_As_int(obj1));
42902 if (SWIG_arg_fail(2)) SWIG_fail;
42903 }
42904 }
42905 {
42906 PyThreadState* __tstate = wxPyBeginAllowThreads();
42907 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42908
42909 wxPyEndAllowThreads(__tstate);
42910 if (PyErr_Occurred()) SWIG_fail;
42911 }
42912 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42913 return resultobj;
42914 fail:
42915 return NULL;
42916 }
42917
42918
42919 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42920 PyObject *resultobj;
42921 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42922 PyObject *arg2 = (PyObject *) 0 ;
42923 wxGBPosition *arg3 = 0 ;
42924 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42925 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42926 int arg5 = (int) 0 ;
42927 int arg6 = (int) 0 ;
42928 PyObject *arg7 = (PyObject *) NULL ;
42929 wxGBSizerItem *result;
42930 wxGBPosition temp3 ;
42931 wxGBSpan temp4 ;
42932 PyObject * obj0 = 0 ;
42933 PyObject * obj1 = 0 ;
42934 PyObject * obj2 = 0 ;
42935 PyObject * obj3 = 0 ;
42936 PyObject * obj4 = 0 ;
42937 PyObject * obj5 = 0 ;
42938 PyObject * obj6 = 0 ;
42939 char *kwnames[] = {
42940 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42941 };
42942
42943 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42945 if (SWIG_arg_fail(1)) SWIG_fail;
42946 arg2 = obj1;
42947 {
42948 arg3 = &temp3;
42949 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42950 }
42951 if (obj3) {
42952 {
42953 arg4 = &temp4;
42954 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42955 }
42956 }
42957 if (obj4) {
42958 {
42959 arg5 = (int)(SWIG_As_int(obj4));
42960 if (SWIG_arg_fail(5)) SWIG_fail;
42961 }
42962 }
42963 if (obj5) {
42964 {
42965 arg6 = (int)(SWIG_As_int(obj5));
42966 if (SWIG_arg_fail(6)) SWIG_fail;
42967 }
42968 }
42969 if (obj6) {
42970 arg7 = obj6;
42971 }
42972 {
42973 PyThreadState* __tstate = wxPyBeginAllowThreads();
42974 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42975
42976 wxPyEndAllowThreads(__tstate);
42977 if (PyErr_Occurred()) SWIG_fail;
42978 }
42979 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42980 return resultobj;
42981 fail:
42982 return NULL;
42983 }
42984
42985
42986 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42987 PyObject *resultobj;
42988 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42989 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42990 wxGBSizerItem *result;
42991 PyObject * obj0 = 0 ;
42992 PyObject * obj1 = 0 ;
42993 char *kwnames[] = {
42994 (char *) "self",(char *) "item", NULL
42995 };
42996
42997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42999 if (SWIG_arg_fail(1)) SWIG_fail;
43000 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43001 if (SWIG_arg_fail(2)) SWIG_fail;
43002 {
43003 PyThreadState* __tstate = wxPyBeginAllowThreads();
43004 result = (wxGBSizerItem *)(arg1)->Add(arg2);
43005
43006 wxPyEndAllowThreads(__tstate);
43007 if (PyErr_Occurred()) SWIG_fail;
43008 }
43009 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43010 return resultobj;
43011 fail:
43012 return NULL;
43013 }
43014
43015
43016 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43017 PyObject *resultobj;
43018 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43019 int arg2 ;
43020 int arg3 ;
43021 wxSize result;
43022 PyObject * obj0 = 0 ;
43023 PyObject * obj1 = 0 ;
43024 PyObject * obj2 = 0 ;
43025 char *kwnames[] = {
43026 (char *) "self",(char *) "row",(char *) "col", NULL
43027 };
43028
43029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
43030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43031 if (SWIG_arg_fail(1)) SWIG_fail;
43032 {
43033 arg2 = (int)(SWIG_As_int(obj1));
43034 if (SWIG_arg_fail(2)) SWIG_fail;
43035 }
43036 {
43037 arg3 = (int)(SWIG_As_int(obj2));
43038 if (SWIG_arg_fail(3)) SWIG_fail;
43039 }
43040 {
43041 PyThreadState* __tstate = wxPyBeginAllowThreads();
43042 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
43043
43044 wxPyEndAllowThreads(__tstate);
43045 if (PyErr_Occurred()) SWIG_fail;
43046 }
43047 {
43048 wxSize * resultptr;
43049 resultptr = new wxSize((wxSize &)(result));
43050 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43051 }
43052 return resultobj;
43053 fail:
43054 return NULL;
43055 }
43056
43057
43058 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43059 PyObject *resultobj;
43060 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43061 wxSize result;
43062 PyObject * obj0 = 0 ;
43063 char *kwnames[] = {
43064 (char *) "self", NULL
43065 };
43066
43067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43069 if (SWIG_arg_fail(1)) SWIG_fail;
43070 {
43071 PyThreadState* __tstate = wxPyBeginAllowThreads();
43072 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43073
43074 wxPyEndAllowThreads(__tstate);
43075 if (PyErr_Occurred()) SWIG_fail;
43076 }
43077 {
43078 wxSize * resultptr;
43079 resultptr = new wxSize((wxSize &)(result));
43080 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43081 }
43082 return resultobj;
43083 fail:
43084 return NULL;
43085 }
43086
43087
43088 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43089 PyObject *resultobj;
43090 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43091 wxSize *arg2 = 0 ;
43092 wxSize temp2 ;
43093 PyObject * obj0 = 0 ;
43094 PyObject * obj1 = 0 ;
43095 char *kwnames[] = {
43096 (char *) "self",(char *) "sz", NULL
43097 };
43098
43099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43101 if (SWIG_arg_fail(1)) SWIG_fail;
43102 {
43103 arg2 = &temp2;
43104 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43105 }
43106 {
43107 PyThreadState* __tstate = wxPyBeginAllowThreads();
43108 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43109
43110 wxPyEndAllowThreads(__tstate);
43111 if (PyErr_Occurred()) SWIG_fail;
43112 }
43113 Py_INCREF(Py_None); resultobj = Py_None;
43114 return resultobj;
43115 fail:
43116 return NULL;
43117 }
43118
43119
43120 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43121 PyObject *resultobj;
43122 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43123 wxWindow *arg2 = (wxWindow *) 0 ;
43124 wxGBPosition result;
43125 PyObject * obj0 = 0 ;
43126 PyObject * obj1 = 0 ;
43127
43128 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43130 if (SWIG_arg_fail(1)) SWIG_fail;
43131 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43132 if (SWIG_arg_fail(2)) SWIG_fail;
43133 {
43134 PyThreadState* __tstate = wxPyBeginAllowThreads();
43135 result = (arg1)->GetItemPosition(arg2);
43136
43137 wxPyEndAllowThreads(__tstate);
43138 if (PyErr_Occurred()) SWIG_fail;
43139 }
43140 {
43141 wxGBPosition * resultptr;
43142 resultptr = new wxGBPosition((wxGBPosition &)(result));
43143 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43144 }
43145 return resultobj;
43146 fail:
43147 return NULL;
43148 }
43149
43150
43151 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43152 PyObject *resultobj;
43153 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43154 wxSizer *arg2 = (wxSizer *) 0 ;
43155 wxGBPosition result;
43156 PyObject * obj0 = 0 ;
43157 PyObject * obj1 = 0 ;
43158
43159 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43161 if (SWIG_arg_fail(1)) SWIG_fail;
43162 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43163 if (SWIG_arg_fail(2)) SWIG_fail;
43164 {
43165 PyThreadState* __tstate = wxPyBeginAllowThreads();
43166 result = (arg1)->GetItemPosition(arg2);
43167
43168 wxPyEndAllowThreads(__tstate);
43169 if (PyErr_Occurred()) SWIG_fail;
43170 }
43171 {
43172 wxGBPosition * resultptr;
43173 resultptr = new wxGBPosition((wxGBPosition &)(result));
43174 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43175 }
43176 return resultobj;
43177 fail:
43178 return NULL;
43179 }
43180
43181
43182 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43183 PyObject *resultobj;
43184 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43185 size_t arg2 ;
43186 wxGBPosition result;
43187 PyObject * obj0 = 0 ;
43188 PyObject * obj1 = 0 ;
43189
43190 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43192 if (SWIG_arg_fail(1)) SWIG_fail;
43193 {
43194 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43195 if (SWIG_arg_fail(2)) SWIG_fail;
43196 }
43197 {
43198 PyThreadState* __tstate = wxPyBeginAllowThreads();
43199 result = (arg1)->GetItemPosition(arg2);
43200
43201 wxPyEndAllowThreads(__tstate);
43202 if (PyErr_Occurred()) SWIG_fail;
43203 }
43204 {
43205 wxGBPosition * resultptr;
43206 resultptr = new wxGBPosition((wxGBPosition &)(result));
43207 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43208 }
43209 return resultobj;
43210 fail:
43211 return NULL;
43212 }
43213
43214
43215 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43216 int argc;
43217 PyObject *argv[3];
43218 int ii;
43219
43220 argc = PyObject_Length(args);
43221 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43222 argv[ii] = PyTuple_GetItem(args,ii);
43223 }
43224 if (argc == 2) {
43225 int _v;
43226 {
43227 void *ptr;
43228 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43229 _v = 0;
43230 PyErr_Clear();
43231 } else {
43232 _v = 1;
43233 }
43234 }
43235 if (_v) {
43236 {
43237 void *ptr;
43238 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43239 _v = 0;
43240 PyErr_Clear();
43241 } else {
43242 _v = 1;
43243 }
43244 }
43245 if (_v) {
43246 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43247 }
43248 }
43249 }
43250 if (argc == 2) {
43251 int _v;
43252 {
43253 void *ptr;
43254 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43255 _v = 0;
43256 PyErr_Clear();
43257 } else {
43258 _v = 1;
43259 }
43260 }
43261 if (_v) {
43262 {
43263 void *ptr;
43264 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43265 _v = 0;
43266 PyErr_Clear();
43267 } else {
43268 _v = 1;
43269 }
43270 }
43271 if (_v) {
43272 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43273 }
43274 }
43275 }
43276 if (argc == 2) {
43277 int _v;
43278 {
43279 void *ptr;
43280 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43281 _v = 0;
43282 PyErr_Clear();
43283 } else {
43284 _v = 1;
43285 }
43286 }
43287 if (_v) {
43288 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43289 if (_v) {
43290 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43291 }
43292 }
43293 }
43294
43295 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43296 return NULL;
43297 }
43298
43299
43300 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43301 PyObject *resultobj;
43302 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43303 wxWindow *arg2 = (wxWindow *) 0 ;
43304 wxGBPosition *arg3 = 0 ;
43305 bool result;
43306 wxGBPosition temp3 ;
43307 PyObject * obj0 = 0 ;
43308 PyObject * obj1 = 0 ;
43309 PyObject * obj2 = 0 ;
43310
43311 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43313 if (SWIG_arg_fail(1)) SWIG_fail;
43314 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43315 if (SWIG_arg_fail(2)) SWIG_fail;
43316 {
43317 arg3 = &temp3;
43318 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43319 }
43320 {
43321 PyThreadState* __tstate = wxPyBeginAllowThreads();
43322 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43323
43324 wxPyEndAllowThreads(__tstate);
43325 if (PyErr_Occurred()) SWIG_fail;
43326 }
43327 {
43328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43329 }
43330 return resultobj;
43331 fail:
43332 return NULL;
43333 }
43334
43335
43336 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43337 PyObject *resultobj;
43338 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43339 wxSizer *arg2 = (wxSizer *) 0 ;
43340 wxGBPosition *arg3 = 0 ;
43341 bool result;
43342 wxGBPosition temp3 ;
43343 PyObject * obj0 = 0 ;
43344 PyObject * obj1 = 0 ;
43345 PyObject * obj2 = 0 ;
43346
43347 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43349 if (SWIG_arg_fail(1)) SWIG_fail;
43350 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43351 if (SWIG_arg_fail(2)) SWIG_fail;
43352 {
43353 arg3 = &temp3;
43354 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43355 }
43356 {
43357 PyThreadState* __tstate = wxPyBeginAllowThreads();
43358 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43359
43360 wxPyEndAllowThreads(__tstate);
43361 if (PyErr_Occurred()) SWIG_fail;
43362 }
43363 {
43364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43365 }
43366 return resultobj;
43367 fail:
43368 return NULL;
43369 }
43370
43371
43372 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43373 PyObject *resultobj;
43374 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43375 size_t arg2 ;
43376 wxGBPosition *arg3 = 0 ;
43377 bool result;
43378 wxGBPosition temp3 ;
43379 PyObject * obj0 = 0 ;
43380 PyObject * obj1 = 0 ;
43381 PyObject * obj2 = 0 ;
43382
43383 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43385 if (SWIG_arg_fail(1)) SWIG_fail;
43386 {
43387 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43388 if (SWIG_arg_fail(2)) SWIG_fail;
43389 }
43390 {
43391 arg3 = &temp3;
43392 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43393 }
43394 {
43395 PyThreadState* __tstate = wxPyBeginAllowThreads();
43396 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43397
43398 wxPyEndAllowThreads(__tstate);
43399 if (PyErr_Occurred()) SWIG_fail;
43400 }
43401 {
43402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43403 }
43404 return resultobj;
43405 fail:
43406 return NULL;
43407 }
43408
43409
43410 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43411 int argc;
43412 PyObject *argv[4];
43413 int ii;
43414
43415 argc = PyObject_Length(args);
43416 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43417 argv[ii] = PyTuple_GetItem(args,ii);
43418 }
43419 if (argc == 3) {
43420 int _v;
43421 {
43422 void *ptr;
43423 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43424 _v = 0;
43425 PyErr_Clear();
43426 } else {
43427 _v = 1;
43428 }
43429 }
43430 if (_v) {
43431 {
43432 void *ptr;
43433 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43434 _v = 0;
43435 PyErr_Clear();
43436 } else {
43437 _v = 1;
43438 }
43439 }
43440 if (_v) {
43441 {
43442 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43443 }
43444 if (_v) {
43445 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43446 }
43447 }
43448 }
43449 }
43450 if (argc == 3) {
43451 int _v;
43452 {
43453 void *ptr;
43454 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43455 _v = 0;
43456 PyErr_Clear();
43457 } else {
43458 _v = 1;
43459 }
43460 }
43461 if (_v) {
43462 {
43463 void *ptr;
43464 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43465 _v = 0;
43466 PyErr_Clear();
43467 } else {
43468 _v = 1;
43469 }
43470 }
43471 if (_v) {
43472 {
43473 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43474 }
43475 if (_v) {
43476 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43477 }
43478 }
43479 }
43480 }
43481 if (argc == 3) {
43482 int _v;
43483 {
43484 void *ptr;
43485 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43486 _v = 0;
43487 PyErr_Clear();
43488 } else {
43489 _v = 1;
43490 }
43491 }
43492 if (_v) {
43493 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43494 if (_v) {
43495 {
43496 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43497 }
43498 if (_v) {
43499 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43500 }
43501 }
43502 }
43503 }
43504
43505 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43506 return NULL;
43507 }
43508
43509
43510 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43511 PyObject *resultobj;
43512 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43513 wxWindow *arg2 = (wxWindow *) 0 ;
43514 wxGBSpan result;
43515 PyObject * obj0 = 0 ;
43516 PyObject * obj1 = 0 ;
43517
43518 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43520 if (SWIG_arg_fail(1)) SWIG_fail;
43521 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43522 if (SWIG_arg_fail(2)) SWIG_fail;
43523 {
43524 PyThreadState* __tstate = wxPyBeginAllowThreads();
43525 result = (arg1)->GetItemSpan(arg2);
43526
43527 wxPyEndAllowThreads(__tstate);
43528 if (PyErr_Occurred()) SWIG_fail;
43529 }
43530 {
43531 wxGBSpan * resultptr;
43532 resultptr = new wxGBSpan((wxGBSpan &)(result));
43533 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43534 }
43535 return resultobj;
43536 fail:
43537 return NULL;
43538 }
43539
43540
43541 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43542 PyObject *resultobj;
43543 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43544 wxSizer *arg2 = (wxSizer *) 0 ;
43545 wxGBSpan result;
43546 PyObject * obj0 = 0 ;
43547 PyObject * obj1 = 0 ;
43548
43549 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43551 if (SWIG_arg_fail(1)) SWIG_fail;
43552 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43553 if (SWIG_arg_fail(2)) SWIG_fail;
43554 {
43555 PyThreadState* __tstate = wxPyBeginAllowThreads();
43556 result = (arg1)->GetItemSpan(arg2);
43557
43558 wxPyEndAllowThreads(__tstate);
43559 if (PyErr_Occurred()) SWIG_fail;
43560 }
43561 {
43562 wxGBSpan * resultptr;
43563 resultptr = new wxGBSpan((wxGBSpan &)(result));
43564 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43565 }
43566 return resultobj;
43567 fail:
43568 return NULL;
43569 }
43570
43571
43572 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43573 PyObject *resultobj;
43574 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43575 size_t arg2 ;
43576 wxGBSpan result;
43577 PyObject * obj0 = 0 ;
43578 PyObject * obj1 = 0 ;
43579
43580 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43582 if (SWIG_arg_fail(1)) SWIG_fail;
43583 {
43584 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43585 if (SWIG_arg_fail(2)) SWIG_fail;
43586 }
43587 {
43588 PyThreadState* __tstate = wxPyBeginAllowThreads();
43589 result = (arg1)->GetItemSpan(arg2);
43590
43591 wxPyEndAllowThreads(__tstate);
43592 if (PyErr_Occurred()) SWIG_fail;
43593 }
43594 {
43595 wxGBSpan * resultptr;
43596 resultptr = new wxGBSpan((wxGBSpan &)(result));
43597 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43598 }
43599 return resultobj;
43600 fail:
43601 return NULL;
43602 }
43603
43604
43605 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43606 int argc;
43607 PyObject *argv[3];
43608 int ii;
43609
43610 argc = PyObject_Length(args);
43611 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43612 argv[ii] = PyTuple_GetItem(args,ii);
43613 }
43614 if (argc == 2) {
43615 int _v;
43616 {
43617 void *ptr;
43618 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43619 _v = 0;
43620 PyErr_Clear();
43621 } else {
43622 _v = 1;
43623 }
43624 }
43625 if (_v) {
43626 {
43627 void *ptr;
43628 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43629 _v = 0;
43630 PyErr_Clear();
43631 } else {
43632 _v = 1;
43633 }
43634 }
43635 if (_v) {
43636 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43637 }
43638 }
43639 }
43640 if (argc == 2) {
43641 int _v;
43642 {
43643 void *ptr;
43644 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43645 _v = 0;
43646 PyErr_Clear();
43647 } else {
43648 _v = 1;
43649 }
43650 }
43651 if (_v) {
43652 {
43653 void *ptr;
43654 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43655 _v = 0;
43656 PyErr_Clear();
43657 } else {
43658 _v = 1;
43659 }
43660 }
43661 if (_v) {
43662 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43663 }
43664 }
43665 }
43666 if (argc == 2) {
43667 int _v;
43668 {
43669 void *ptr;
43670 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43671 _v = 0;
43672 PyErr_Clear();
43673 } else {
43674 _v = 1;
43675 }
43676 }
43677 if (_v) {
43678 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43679 if (_v) {
43680 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43681 }
43682 }
43683 }
43684
43685 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43686 return NULL;
43687 }
43688
43689
43690 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43691 PyObject *resultobj;
43692 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43693 wxWindow *arg2 = (wxWindow *) 0 ;
43694 wxGBSpan *arg3 = 0 ;
43695 bool result;
43696 wxGBSpan temp3 ;
43697 PyObject * obj0 = 0 ;
43698 PyObject * obj1 = 0 ;
43699 PyObject * obj2 = 0 ;
43700
43701 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43703 if (SWIG_arg_fail(1)) SWIG_fail;
43704 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43705 if (SWIG_arg_fail(2)) SWIG_fail;
43706 {
43707 arg3 = &temp3;
43708 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43709 }
43710 {
43711 PyThreadState* __tstate = wxPyBeginAllowThreads();
43712 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43713
43714 wxPyEndAllowThreads(__tstate);
43715 if (PyErr_Occurred()) SWIG_fail;
43716 }
43717 {
43718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43719 }
43720 return resultobj;
43721 fail:
43722 return NULL;
43723 }
43724
43725
43726 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43727 PyObject *resultobj;
43728 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43729 wxSizer *arg2 = (wxSizer *) 0 ;
43730 wxGBSpan *arg3 = 0 ;
43731 bool result;
43732 wxGBSpan temp3 ;
43733 PyObject * obj0 = 0 ;
43734 PyObject * obj1 = 0 ;
43735 PyObject * obj2 = 0 ;
43736
43737 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43739 if (SWIG_arg_fail(1)) SWIG_fail;
43740 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43741 if (SWIG_arg_fail(2)) SWIG_fail;
43742 {
43743 arg3 = &temp3;
43744 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43745 }
43746 {
43747 PyThreadState* __tstate = wxPyBeginAllowThreads();
43748 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43749
43750 wxPyEndAllowThreads(__tstate);
43751 if (PyErr_Occurred()) SWIG_fail;
43752 }
43753 {
43754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43755 }
43756 return resultobj;
43757 fail:
43758 return NULL;
43759 }
43760
43761
43762 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43763 PyObject *resultobj;
43764 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43765 size_t arg2 ;
43766 wxGBSpan *arg3 = 0 ;
43767 bool result;
43768 wxGBSpan temp3 ;
43769 PyObject * obj0 = 0 ;
43770 PyObject * obj1 = 0 ;
43771 PyObject * obj2 = 0 ;
43772
43773 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43775 if (SWIG_arg_fail(1)) SWIG_fail;
43776 {
43777 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43778 if (SWIG_arg_fail(2)) SWIG_fail;
43779 }
43780 {
43781 arg3 = &temp3;
43782 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43783 }
43784 {
43785 PyThreadState* __tstate = wxPyBeginAllowThreads();
43786 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43787
43788 wxPyEndAllowThreads(__tstate);
43789 if (PyErr_Occurred()) SWIG_fail;
43790 }
43791 {
43792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43793 }
43794 return resultobj;
43795 fail:
43796 return NULL;
43797 }
43798
43799
43800 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43801 int argc;
43802 PyObject *argv[4];
43803 int ii;
43804
43805 argc = PyObject_Length(args);
43806 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43807 argv[ii] = PyTuple_GetItem(args,ii);
43808 }
43809 if (argc == 3) {
43810 int _v;
43811 {
43812 void *ptr;
43813 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43814 _v = 0;
43815 PyErr_Clear();
43816 } else {
43817 _v = 1;
43818 }
43819 }
43820 if (_v) {
43821 {
43822 void *ptr;
43823 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43824 _v = 0;
43825 PyErr_Clear();
43826 } else {
43827 _v = 1;
43828 }
43829 }
43830 if (_v) {
43831 {
43832 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43833 }
43834 if (_v) {
43835 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43836 }
43837 }
43838 }
43839 }
43840 if (argc == 3) {
43841 int _v;
43842 {
43843 void *ptr;
43844 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43845 _v = 0;
43846 PyErr_Clear();
43847 } else {
43848 _v = 1;
43849 }
43850 }
43851 if (_v) {
43852 {
43853 void *ptr;
43854 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43855 _v = 0;
43856 PyErr_Clear();
43857 } else {
43858 _v = 1;
43859 }
43860 }
43861 if (_v) {
43862 {
43863 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43864 }
43865 if (_v) {
43866 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43867 }
43868 }
43869 }
43870 }
43871 if (argc == 3) {
43872 int _v;
43873 {
43874 void *ptr;
43875 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43876 _v = 0;
43877 PyErr_Clear();
43878 } else {
43879 _v = 1;
43880 }
43881 }
43882 if (_v) {
43883 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43884 if (_v) {
43885 {
43886 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43887 }
43888 if (_v) {
43889 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43890 }
43891 }
43892 }
43893 }
43894
43895 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43896 return NULL;
43897 }
43898
43899
43900 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43901 PyObject *resultobj;
43902 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43903 wxWindow *arg2 = (wxWindow *) 0 ;
43904 wxGBSizerItem *result;
43905 PyObject * obj0 = 0 ;
43906 PyObject * obj1 = 0 ;
43907
43908 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43910 if (SWIG_arg_fail(1)) SWIG_fail;
43911 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43912 if (SWIG_arg_fail(2)) SWIG_fail;
43913 {
43914 PyThreadState* __tstate = wxPyBeginAllowThreads();
43915 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43916
43917 wxPyEndAllowThreads(__tstate);
43918 if (PyErr_Occurred()) SWIG_fail;
43919 }
43920 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43921 return resultobj;
43922 fail:
43923 return NULL;
43924 }
43925
43926
43927 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43928 PyObject *resultobj;
43929 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43930 wxSizer *arg2 = (wxSizer *) 0 ;
43931 wxGBSizerItem *result;
43932 PyObject * obj0 = 0 ;
43933 PyObject * obj1 = 0 ;
43934
43935 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43937 if (SWIG_arg_fail(1)) SWIG_fail;
43938 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43939 if (SWIG_arg_fail(2)) SWIG_fail;
43940 {
43941 PyThreadState* __tstate = wxPyBeginAllowThreads();
43942 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43943
43944 wxPyEndAllowThreads(__tstate);
43945 if (PyErr_Occurred()) SWIG_fail;
43946 }
43947 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43948 return resultobj;
43949 fail:
43950 return NULL;
43951 }
43952
43953
43954 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43955 int argc;
43956 PyObject *argv[3];
43957 int ii;
43958
43959 argc = PyObject_Length(args);
43960 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43961 argv[ii] = PyTuple_GetItem(args,ii);
43962 }
43963 if (argc == 2) {
43964 int _v;
43965 {
43966 void *ptr;
43967 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43968 _v = 0;
43969 PyErr_Clear();
43970 } else {
43971 _v = 1;
43972 }
43973 }
43974 if (_v) {
43975 {
43976 void *ptr;
43977 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43978 _v = 0;
43979 PyErr_Clear();
43980 } else {
43981 _v = 1;
43982 }
43983 }
43984 if (_v) {
43985 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43986 }
43987 }
43988 }
43989 if (argc == 2) {
43990 int _v;
43991 {
43992 void *ptr;
43993 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43994 _v = 0;
43995 PyErr_Clear();
43996 } else {
43997 _v = 1;
43998 }
43999 }
44000 if (_v) {
44001 {
44002 void *ptr;
44003 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44004 _v = 0;
44005 PyErr_Clear();
44006 } else {
44007 _v = 1;
44008 }
44009 }
44010 if (_v) {
44011 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
44012 }
44013 }
44014 }
44015
44016 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
44017 return NULL;
44018 }
44019
44020
44021 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
44022 PyObject *resultobj;
44023 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44024 wxGBPosition *arg2 = 0 ;
44025 wxGBSizerItem *result;
44026 wxGBPosition temp2 ;
44027 PyObject * obj0 = 0 ;
44028 PyObject * obj1 = 0 ;
44029 char *kwnames[] = {
44030 (char *) "self",(char *) "pos", NULL
44031 };
44032
44033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
44034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44035 if (SWIG_arg_fail(1)) SWIG_fail;
44036 {
44037 arg2 = &temp2;
44038 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44039 }
44040 {
44041 PyThreadState* __tstate = wxPyBeginAllowThreads();
44042 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
44043
44044 wxPyEndAllowThreads(__tstate);
44045 if (PyErr_Occurred()) SWIG_fail;
44046 }
44047 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44048 return resultobj;
44049 fail:
44050 return NULL;
44051 }
44052
44053
44054 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44055 PyObject *resultobj;
44056 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44057 wxPoint *arg2 = 0 ;
44058 wxGBSizerItem *result;
44059 wxPoint temp2 ;
44060 PyObject * obj0 = 0 ;
44061 PyObject * obj1 = 0 ;
44062 char *kwnames[] = {
44063 (char *) "self",(char *) "pt", NULL
44064 };
44065
44066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44068 if (SWIG_arg_fail(1)) SWIG_fail;
44069 {
44070 arg2 = &temp2;
44071 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44072 }
44073 {
44074 PyThreadState* __tstate = wxPyBeginAllowThreads();
44075 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44076
44077 wxPyEndAllowThreads(__tstate);
44078 if (PyErr_Occurred()) SWIG_fail;
44079 }
44080 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44081 return resultobj;
44082 fail:
44083 return NULL;
44084 }
44085
44086
44087 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44088 PyObject *resultobj;
44089 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44090 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44091 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44092 bool result;
44093 PyObject * obj0 = 0 ;
44094 PyObject * obj1 = 0 ;
44095 PyObject * obj2 = 0 ;
44096 char *kwnames[] = {
44097 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44098 };
44099
44100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44102 if (SWIG_arg_fail(1)) SWIG_fail;
44103 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44104 if (SWIG_arg_fail(2)) SWIG_fail;
44105 if (obj2) {
44106 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44107 if (SWIG_arg_fail(3)) SWIG_fail;
44108 }
44109 {
44110 PyThreadState* __tstate = wxPyBeginAllowThreads();
44111 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44112
44113 wxPyEndAllowThreads(__tstate);
44114 if (PyErr_Occurred()) SWIG_fail;
44115 }
44116 {
44117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44118 }
44119 return resultobj;
44120 fail:
44121 return NULL;
44122 }
44123
44124
44125 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44126 PyObject *resultobj;
44127 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44128 wxGBPosition *arg2 = 0 ;
44129 wxGBSpan *arg3 = 0 ;
44130 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44131 bool result;
44132 wxGBPosition temp2 ;
44133 wxGBSpan temp3 ;
44134 PyObject * obj0 = 0 ;
44135 PyObject * obj1 = 0 ;
44136 PyObject * obj2 = 0 ;
44137 PyObject * obj3 = 0 ;
44138 char *kwnames[] = {
44139 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44140 };
44141
44142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44144 if (SWIG_arg_fail(1)) SWIG_fail;
44145 {
44146 arg2 = &temp2;
44147 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44148 }
44149 {
44150 arg3 = &temp3;
44151 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44152 }
44153 if (obj3) {
44154 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44155 if (SWIG_arg_fail(4)) SWIG_fail;
44156 }
44157 {
44158 PyThreadState* __tstate = wxPyBeginAllowThreads();
44159 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44160
44161 wxPyEndAllowThreads(__tstate);
44162 if (PyErr_Occurred()) SWIG_fail;
44163 }
44164 {
44165 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44166 }
44167 return resultobj;
44168 fail:
44169 return NULL;
44170 }
44171
44172
44173 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44174 PyObject *obj;
44175 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44176 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44177 Py_INCREF(obj);
44178 return Py_BuildValue((char *)"");
44179 }
44180 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44181 PyObject *resultobj;
44182 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44183 wxRelationship arg2 ;
44184 wxWindow *arg3 = (wxWindow *) 0 ;
44185 wxEdge arg4 ;
44186 int arg5 = (int) 0 ;
44187 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44188 PyObject * obj0 = 0 ;
44189 PyObject * obj1 = 0 ;
44190 PyObject * obj2 = 0 ;
44191 PyObject * obj3 = 0 ;
44192 PyObject * obj4 = 0 ;
44193 PyObject * obj5 = 0 ;
44194 char *kwnames[] = {
44195 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44196 };
44197
44198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44200 if (SWIG_arg_fail(1)) SWIG_fail;
44201 {
44202 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44203 if (SWIG_arg_fail(2)) SWIG_fail;
44204 }
44205 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44206 if (SWIG_arg_fail(3)) SWIG_fail;
44207 {
44208 arg4 = (wxEdge)(SWIG_As_int(obj3));
44209 if (SWIG_arg_fail(4)) SWIG_fail;
44210 }
44211 if (obj4) {
44212 {
44213 arg5 = (int)(SWIG_As_int(obj4));
44214 if (SWIG_arg_fail(5)) SWIG_fail;
44215 }
44216 }
44217 if (obj5) {
44218 {
44219 arg6 = (int)(SWIG_As_int(obj5));
44220 if (SWIG_arg_fail(6)) SWIG_fail;
44221 }
44222 }
44223 {
44224 PyThreadState* __tstate = wxPyBeginAllowThreads();
44225 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44226
44227 wxPyEndAllowThreads(__tstate);
44228 if (PyErr_Occurred()) SWIG_fail;
44229 }
44230 Py_INCREF(Py_None); resultobj = Py_None;
44231 return resultobj;
44232 fail:
44233 return NULL;
44234 }
44235
44236
44237 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44238 PyObject *resultobj;
44239 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44240 wxWindow *arg2 = (wxWindow *) 0 ;
44241 int arg3 = (int) 0 ;
44242 PyObject * obj0 = 0 ;
44243 PyObject * obj1 = 0 ;
44244 PyObject * obj2 = 0 ;
44245 char *kwnames[] = {
44246 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44247 };
44248
44249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44251 if (SWIG_arg_fail(1)) SWIG_fail;
44252 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44253 if (SWIG_arg_fail(2)) SWIG_fail;
44254 if (obj2) {
44255 {
44256 arg3 = (int)(SWIG_As_int(obj2));
44257 if (SWIG_arg_fail(3)) SWIG_fail;
44258 }
44259 }
44260 {
44261 PyThreadState* __tstate = wxPyBeginAllowThreads();
44262 (arg1)->LeftOf(arg2,arg3);
44263
44264 wxPyEndAllowThreads(__tstate);
44265 if (PyErr_Occurred()) SWIG_fail;
44266 }
44267 Py_INCREF(Py_None); resultobj = Py_None;
44268 return resultobj;
44269 fail:
44270 return NULL;
44271 }
44272
44273
44274 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44275 PyObject *resultobj;
44276 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44277 wxWindow *arg2 = (wxWindow *) 0 ;
44278 int arg3 = (int) 0 ;
44279 PyObject * obj0 = 0 ;
44280 PyObject * obj1 = 0 ;
44281 PyObject * obj2 = 0 ;
44282 char *kwnames[] = {
44283 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44284 };
44285
44286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44288 if (SWIG_arg_fail(1)) SWIG_fail;
44289 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44290 if (SWIG_arg_fail(2)) SWIG_fail;
44291 if (obj2) {
44292 {
44293 arg3 = (int)(SWIG_As_int(obj2));
44294 if (SWIG_arg_fail(3)) SWIG_fail;
44295 }
44296 }
44297 {
44298 PyThreadState* __tstate = wxPyBeginAllowThreads();
44299 (arg1)->RightOf(arg2,arg3);
44300
44301 wxPyEndAllowThreads(__tstate);
44302 if (PyErr_Occurred()) SWIG_fail;
44303 }
44304 Py_INCREF(Py_None); resultobj = Py_None;
44305 return resultobj;
44306 fail:
44307 return NULL;
44308 }
44309
44310
44311 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44312 PyObject *resultobj;
44313 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44314 wxWindow *arg2 = (wxWindow *) 0 ;
44315 int arg3 = (int) 0 ;
44316 PyObject * obj0 = 0 ;
44317 PyObject * obj1 = 0 ;
44318 PyObject * obj2 = 0 ;
44319 char *kwnames[] = {
44320 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44321 };
44322
44323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44325 if (SWIG_arg_fail(1)) SWIG_fail;
44326 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44327 if (SWIG_arg_fail(2)) SWIG_fail;
44328 if (obj2) {
44329 {
44330 arg3 = (int)(SWIG_As_int(obj2));
44331 if (SWIG_arg_fail(3)) SWIG_fail;
44332 }
44333 }
44334 {
44335 PyThreadState* __tstate = wxPyBeginAllowThreads();
44336 (arg1)->Above(arg2,arg3);
44337
44338 wxPyEndAllowThreads(__tstate);
44339 if (PyErr_Occurred()) SWIG_fail;
44340 }
44341 Py_INCREF(Py_None); resultobj = Py_None;
44342 return resultobj;
44343 fail:
44344 return NULL;
44345 }
44346
44347
44348 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44349 PyObject *resultobj;
44350 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44351 wxWindow *arg2 = (wxWindow *) 0 ;
44352 int arg3 = (int) 0 ;
44353 PyObject * obj0 = 0 ;
44354 PyObject * obj1 = 0 ;
44355 PyObject * obj2 = 0 ;
44356 char *kwnames[] = {
44357 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44358 };
44359
44360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44362 if (SWIG_arg_fail(1)) SWIG_fail;
44363 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44364 if (SWIG_arg_fail(2)) SWIG_fail;
44365 if (obj2) {
44366 {
44367 arg3 = (int)(SWIG_As_int(obj2));
44368 if (SWIG_arg_fail(3)) SWIG_fail;
44369 }
44370 }
44371 {
44372 PyThreadState* __tstate = wxPyBeginAllowThreads();
44373 (arg1)->Below(arg2,arg3);
44374
44375 wxPyEndAllowThreads(__tstate);
44376 if (PyErr_Occurred()) SWIG_fail;
44377 }
44378 Py_INCREF(Py_None); resultobj = Py_None;
44379 return resultobj;
44380 fail:
44381 return NULL;
44382 }
44383
44384
44385 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44386 PyObject *resultobj;
44387 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44388 wxWindow *arg2 = (wxWindow *) 0 ;
44389 wxEdge arg3 ;
44390 int arg4 = (int) 0 ;
44391 PyObject * obj0 = 0 ;
44392 PyObject * obj1 = 0 ;
44393 PyObject * obj2 = 0 ;
44394 PyObject * obj3 = 0 ;
44395 char *kwnames[] = {
44396 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44397 };
44398
44399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44401 if (SWIG_arg_fail(1)) SWIG_fail;
44402 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44403 if (SWIG_arg_fail(2)) SWIG_fail;
44404 {
44405 arg3 = (wxEdge)(SWIG_As_int(obj2));
44406 if (SWIG_arg_fail(3)) SWIG_fail;
44407 }
44408 if (obj3) {
44409 {
44410 arg4 = (int)(SWIG_As_int(obj3));
44411 if (SWIG_arg_fail(4)) SWIG_fail;
44412 }
44413 }
44414 {
44415 PyThreadState* __tstate = wxPyBeginAllowThreads();
44416 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44417
44418 wxPyEndAllowThreads(__tstate);
44419 if (PyErr_Occurred()) SWIG_fail;
44420 }
44421 Py_INCREF(Py_None); resultobj = Py_None;
44422 return resultobj;
44423 fail:
44424 return NULL;
44425 }
44426
44427
44428 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44429 PyObject *resultobj;
44430 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44431 wxWindow *arg2 = (wxWindow *) 0 ;
44432 wxEdge arg3 ;
44433 int arg4 ;
44434 PyObject * obj0 = 0 ;
44435 PyObject * obj1 = 0 ;
44436 PyObject * obj2 = 0 ;
44437 PyObject * obj3 = 0 ;
44438 char *kwnames[] = {
44439 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44440 };
44441
44442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44444 if (SWIG_arg_fail(1)) SWIG_fail;
44445 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44446 if (SWIG_arg_fail(2)) SWIG_fail;
44447 {
44448 arg3 = (wxEdge)(SWIG_As_int(obj2));
44449 if (SWIG_arg_fail(3)) SWIG_fail;
44450 }
44451 {
44452 arg4 = (int)(SWIG_As_int(obj3));
44453 if (SWIG_arg_fail(4)) SWIG_fail;
44454 }
44455 {
44456 PyThreadState* __tstate = wxPyBeginAllowThreads();
44457 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44458
44459 wxPyEndAllowThreads(__tstate);
44460 if (PyErr_Occurred()) SWIG_fail;
44461 }
44462 Py_INCREF(Py_None); resultobj = Py_None;
44463 return resultobj;
44464 fail:
44465 return NULL;
44466 }
44467
44468
44469 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44470 PyObject *resultobj;
44471 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44472 int arg2 ;
44473 PyObject * obj0 = 0 ;
44474 PyObject * obj1 = 0 ;
44475 char *kwnames[] = {
44476 (char *) "self",(char *) "val", NULL
44477 };
44478
44479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44481 if (SWIG_arg_fail(1)) SWIG_fail;
44482 {
44483 arg2 = (int)(SWIG_As_int(obj1));
44484 if (SWIG_arg_fail(2)) SWIG_fail;
44485 }
44486 {
44487 PyThreadState* __tstate = wxPyBeginAllowThreads();
44488 (arg1)->Absolute(arg2);
44489
44490 wxPyEndAllowThreads(__tstate);
44491 if (PyErr_Occurred()) SWIG_fail;
44492 }
44493 Py_INCREF(Py_None); resultobj = Py_None;
44494 return resultobj;
44495 fail:
44496 return NULL;
44497 }
44498
44499
44500 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44501 PyObject *resultobj;
44502 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44503 PyObject * obj0 = 0 ;
44504 char *kwnames[] = {
44505 (char *) "self", NULL
44506 };
44507
44508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44510 if (SWIG_arg_fail(1)) SWIG_fail;
44511 {
44512 PyThreadState* __tstate = wxPyBeginAllowThreads();
44513 (arg1)->Unconstrained();
44514
44515 wxPyEndAllowThreads(__tstate);
44516 if (PyErr_Occurred()) SWIG_fail;
44517 }
44518 Py_INCREF(Py_None); resultobj = Py_None;
44519 return resultobj;
44520 fail:
44521 return NULL;
44522 }
44523
44524
44525 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44526 PyObject *resultobj;
44527 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44528 PyObject * obj0 = 0 ;
44529 char *kwnames[] = {
44530 (char *) "self", NULL
44531 };
44532
44533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44535 if (SWIG_arg_fail(1)) SWIG_fail;
44536 {
44537 PyThreadState* __tstate = wxPyBeginAllowThreads();
44538 (arg1)->AsIs();
44539
44540 wxPyEndAllowThreads(__tstate);
44541 if (PyErr_Occurred()) SWIG_fail;
44542 }
44543 Py_INCREF(Py_None); resultobj = Py_None;
44544 return resultobj;
44545 fail:
44546 return NULL;
44547 }
44548
44549
44550 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44551 PyObject *resultobj;
44552 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44553 wxWindow *result;
44554 PyObject * obj0 = 0 ;
44555 char *kwnames[] = {
44556 (char *) "self", NULL
44557 };
44558
44559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44561 if (SWIG_arg_fail(1)) SWIG_fail;
44562 {
44563 PyThreadState* __tstate = wxPyBeginAllowThreads();
44564 result = (wxWindow *)(arg1)->GetOtherWindow();
44565
44566 wxPyEndAllowThreads(__tstate);
44567 if (PyErr_Occurred()) SWIG_fail;
44568 }
44569 {
44570 resultobj = wxPyMake_wxObject(result, 0);
44571 }
44572 return resultobj;
44573 fail:
44574 return NULL;
44575 }
44576
44577
44578 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44579 PyObject *resultobj;
44580 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44581 wxEdge result;
44582 PyObject * obj0 = 0 ;
44583 char *kwnames[] = {
44584 (char *) "self", NULL
44585 };
44586
44587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44588 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44589 if (SWIG_arg_fail(1)) SWIG_fail;
44590 {
44591 PyThreadState* __tstate = wxPyBeginAllowThreads();
44592 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44593
44594 wxPyEndAllowThreads(__tstate);
44595 if (PyErr_Occurred()) SWIG_fail;
44596 }
44597 resultobj = SWIG_From_int((result));
44598 return resultobj;
44599 fail:
44600 return NULL;
44601 }
44602
44603
44604 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44605 PyObject *resultobj;
44606 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44607 wxEdge arg2 ;
44608 PyObject * obj0 = 0 ;
44609 PyObject * obj1 = 0 ;
44610 char *kwnames[] = {
44611 (char *) "self",(char *) "which", NULL
44612 };
44613
44614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44616 if (SWIG_arg_fail(1)) SWIG_fail;
44617 {
44618 arg2 = (wxEdge)(SWIG_As_int(obj1));
44619 if (SWIG_arg_fail(2)) SWIG_fail;
44620 }
44621 {
44622 PyThreadState* __tstate = wxPyBeginAllowThreads();
44623 (arg1)->SetEdge((wxEdge )arg2);
44624
44625 wxPyEndAllowThreads(__tstate);
44626 if (PyErr_Occurred()) SWIG_fail;
44627 }
44628 Py_INCREF(Py_None); resultobj = Py_None;
44629 return resultobj;
44630 fail:
44631 return NULL;
44632 }
44633
44634
44635 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44636 PyObject *resultobj;
44637 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44638 int arg2 ;
44639 PyObject * obj0 = 0 ;
44640 PyObject * obj1 = 0 ;
44641 char *kwnames[] = {
44642 (char *) "self",(char *) "v", NULL
44643 };
44644
44645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44647 if (SWIG_arg_fail(1)) SWIG_fail;
44648 {
44649 arg2 = (int)(SWIG_As_int(obj1));
44650 if (SWIG_arg_fail(2)) SWIG_fail;
44651 }
44652 {
44653 PyThreadState* __tstate = wxPyBeginAllowThreads();
44654 (arg1)->SetValue(arg2);
44655
44656 wxPyEndAllowThreads(__tstate);
44657 if (PyErr_Occurred()) SWIG_fail;
44658 }
44659 Py_INCREF(Py_None); resultobj = Py_None;
44660 return resultobj;
44661 fail:
44662 return NULL;
44663 }
44664
44665
44666 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44667 PyObject *resultobj;
44668 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44669 int result;
44670 PyObject * obj0 = 0 ;
44671 char *kwnames[] = {
44672 (char *) "self", NULL
44673 };
44674
44675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44677 if (SWIG_arg_fail(1)) SWIG_fail;
44678 {
44679 PyThreadState* __tstate = wxPyBeginAllowThreads();
44680 result = (int)(arg1)->GetMargin();
44681
44682 wxPyEndAllowThreads(__tstate);
44683 if (PyErr_Occurred()) SWIG_fail;
44684 }
44685 {
44686 resultobj = SWIG_From_int((int)(result));
44687 }
44688 return resultobj;
44689 fail:
44690 return NULL;
44691 }
44692
44693
44694 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44695 PyObject *resultobj;
44696 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44697 int arg2 ;
44698 PyObject * obj0 = 0 ;
44699 PyObject * obj1 = 0 ;
44700 char *kwnames[] = {
44701 (char *) "self",(char *) "m", NULL
44702 };
44703
44704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44706 if (SWIG_arg_fail(1)) SWIG_fail;
44707 {
44708 arg2 = (int)(SWIG_As_int(obj1));
44709 if (SWIG_arg_fail(2)) SWIG_fail;
44710 }
44711 {
44712 PyThreadState* __tstate = wxPyBeginAllowThreads();
44713 (arg1)->SetMargin(arg2);
44714
44715 wxPyEndAllowThreads(__tstate);
44716 if (PyErr_Occurred()) SWIG_fail;
44717 }
44718 Py_INCREF(Py_None); resultobj = Py_None;
44719 return resultobj;
44720 fail:
44721 return NULL;
44722 }
44723
44724
44725 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44726 PyObject *resultobj;
44727 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44728 int result;
44729 PyObject * obj0 = 0 ;
44730 char *kwnames[] = {
44731 (char *) "self", NULL
44732 };
44733
44734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44736 if (SWIG_arg_fail(1)) SWIG_fail;
44737 {
44738 PyThreadState* __tstate = wxPyBeginAllowThreads();
44739 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44740
44741 wxPyEndAllowThreads(__tstate);
44742 if (PyErr_Occurred()) SWIG_fail;
44743 }
44744 {
44745 resultobj = SWIG_From_int((int)(result));
44746 }
44747 return resultobj;
44748 fail:
44749 return NULL;
44750 }
44751
44752
44753 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44754 PyObject *resultobj;
44755 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44756 int result;
44757 PyObject * obj0 = 0 ;
44758 char *kwnames[] = {
44759 (char *) "self", NULL
44760 };
44761
44762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44764 if (SWIG_arg_fail(1)) SWIG_fail;
44765 {
44766 PyThreadState* __tstate = wxPyBeginAllowThreads();
44767 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44768
44769 wxPyEndAllowThreads(__tstate);
44770 if (PyErr_Occurred()) SWIG_fail;
44771 }
44772 {
44773 resultobj = SWIG_From_int((int)(result));
44774 }
44775 return resultobj;
44776 fail:
44777 return NULL;
44778 }
44779
44780
44781 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44782 PyObject *resultobj;
44783 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44784 int result;
44785 PyObject * obj0 = 0 ;
44786 char *kwnames[] = {
44787 (char *) "self", NULL
44788 };
44789
44790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44792 if (SWIG_arg_fail(1)) SWIG_fail;
44793 {
44794 PyThreadState* __tstate = wxPyBeginAllowThreads();
44795 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44796
44797 wxPyEndAllowThreads(__tstate);
44798 if (PyErr_Occurred()) SWIG_fail;
44799 }
44800 {
44801 resultobj = SWIG_From_int((int)(result));
44802 }
44803 return resultobj;
44804 fail:
44805 return NULL;
44806 }
44807
44808
44809 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44810 PyObject *resultobj;
44811 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44812 bool result;
44813 PyObject * obj0 = 0 ;
44814 char *kwnames[] = {
44815 (char *) "self", NULL
44816 };
44817
44818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44820 if (SWIG_arg_fail(1)) SWIG_fail;
44821 {
44822 PyThreadState* __tstate = wxPyBeginAllowThreads();
44823 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44824
44825 wxPyEndAllowThreads(__tstate);
44826 if (PyErr_Occurred()) SWIG_fail;
44827 }
44828 {
44829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44830 }
44831 return resultobj;
44832 fail:
44833 return NULL;
44834 }
44835
44836
44837 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44838 PyObject *resultobj;
44839 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44840 bool arg2 ;
44841 PyObject * obj0 = 0 ;
44842 PyObject * obj1 = 0 ;
44843 char *kwnames[] = {
44844 (char *) "self",(char *) "d", NULL
44845 };
44846
44847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44849 if (SWIG_arg_fail(1)) SWIG_fail;
44850 {
44851 arg2 = (bool)(SWIG_As_bool(obj1));
44852 if (SWIG_arg_fail(2)) SWIG_fail;
44853 }
44854 {
44855 PyThreadState* __tstate = wxPyBeginAllowThreads();
44856 (arg1)->SetDone(arg2);
44857
44858 wxPyEndAllowThreads(__tstate);
44859 if (PyErr_Occurred()) SWIG_fail;
44860 }
44861 Py_INCREF(Py_None); resultobj = Py_None;
44862 return resultobj;
44863 fail:
44864 return NULL;
44865 }
44866
44867
44868 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44869 PyObject *resultobj;
44870 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44871 wxRelationship result;
44872 PyObject * obj0 = 0 ;
44873 char *kwnames[] = {
44874 (char *) "self", NULL
44875 };
44876
44877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44879 if (SWIG_arg_fail(1)) SWIG_fail;
44880 {
44881 PyThreadState* __tstate = wxPyBeginAllowThreads();
44882 result = (wxRelationship)(arg1)->GetRelationship();
44883
44884 wxPyEndAllowThreads(__tstate);
44885 if (PyErr_Occurred()) SWIG_fail;
44886 }
44887 resultobj = SWIG_From_int((result));
44888 return resultobj;
44889 fail:
44890 return NULL;
44891 }
44892
44893
44894 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44895 PyObject *resultobj;
44896 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44897 wxRelationship arg2 ;
44898 PyObject * obj0 = 0 ;
44899 PyObject * obj1 = 0 ;
44900 char *kwnames[] = {
44901 (char *) "self",(char *) "r", NULL
44902 };
44903
44904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44906 if (SWIG_arg_fail(1)) SWIG_fail;
44907 {
44908 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44909 if (SWIG_arg_fail(2)) SWIG_fail;
44910 }
44911 {
44912 PyThreadState* __tstate = wxPyBeginAllowThreads();
44913 (arg1)->SetRelationship((wxRelationship )arg2);
44914
44915 wxPyEndAllowThreads(__tstate);
44916 if (PyErr_Occurred()) SWIG_fail;
44917 }
44918 Py_INCREF(Py_None); resultobj = Py_None;
44919 return resultobj;
44920 fail:
44921 return NULL;
44922 }
44923
44924
44925 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44926 PyObject *resultobj;
44927 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44928 wxWindow *arg2 = (wxWindow *) 0 ;
44929 bool result;
44930 PyObject * obj0 = 0 ;
44931 PyObject * obj1 = 0 ;
44932 char *kwnames[] = {
44933 (char *) "self",(char *) "otherW", NULL
44934 };
44935
44936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44938 if (SWIG_arg_fail(1)) SWIG_fail;
44939 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44940 if (SWIG_arg_fail(2)) SWIG_fail;
44941 {
44942 PyThreadState* __tstate = wxPyBeginAllowThreads();
44943 result = (bool)(arg1)->ResetIfWin(arg2);
44944
44945 wxPyEndAllowThreads(__tstate);
44946 if (PyErr_Occurred()) SWIG_fail;
44947 }
44948 {
44949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44950 }
44951 return resultobj;
44952 fail:
44953 return NULL;
44954 }
44955
44956
44957 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44958 PyObject *resultobj;
44959 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44960 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44961 wxWindow *arg3 = (wxWindow *) 0 ;
44962 bool result;
44963 PyObject * obj0 = 0 ;
44964 PyObject * obj1 = 0 ;
44965 PyObject * obj2 = 0 ;
44966 char *kwnames[] = {
44967 (char *) "self",(char *) "constraints",(char *) "win", NULL
44968 };
44969
44970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44972 if (SWIG_arg_fail(1)) SWIG_fail;
44973 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44974 if (SWIG_arg_fail(2)) SWIG_fail;
44975 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44976 if (SWIG_arg_fail(3)) SWIG_fail;
44977 {
44978 PyThreadState* __tstate = wxPyBeginAllowThreads();
44979 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44980
44981 wxPyEndAllowThreads(__tstate);
44982 if (PyErr_Occurred()) SWIG_fail;
44983 }
44984 {
44985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44986 }
44987 return resultobj;
44988 fail:
44989 return NULL;
44990 }
44991
44992
44993 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44994 PyObject *resultobj;
44995 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44996 wxEdge arg2 ;
44997 wxWindow *arg3 = (wxWindow *) 0 ;
44998 wxWindow *arg4 = (wxWindow *) 0 ;
44999 int result;
45000 PyObject * obj0 = 0 ;
45001 PyObject * obj1 = 0 ;
45002 PyObject * obj2 = 0 ;
45003 PyObject * obj3 = 0 ;
45004 char *kwnames[] = {
45005 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
45006 };
45007
45008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45010 if (SWIG_arg_fail(1)) SWIG_fail;
45011 {
45012 arg2 = (wxEdge)(SWIG_As_int(obj1));
45013 if (SWIG_arg_fail(2)) SWIG_fail;
45014 }
45015 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45016 if (SWIG_arg_fail(3)) SWIG_fail;
45017 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45018 if (SWIG_arg_fail(4)) SWIG_fail;
45019 {
45020 PyThreadState* __tstate = wxPyBeginAllowThreads();
45021 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
45022
45023 wxPyEndAllowThreads(__tstate);
45024 if (PyErr_Occurred()) SWIG_fail;
45025 }
45026 {
45027 resultobj = SWIG_From_int((int)(result));
45028 }
45029 return resultobj;
45030 fail:
45031 return NULL;
45032 }
45033
45034
45035 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
45036 PyObject *obj;
45037 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45038 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
45039 Py_INCREF(obj);
45040 return Py_BuildValue((char *)"");
45041 }
45042 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
45043 PyObject *resultobj;
45044 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45045 wxIndividualLayoutConstraint *result;
45046 PyObject * obj0 = 0 ;
45047 char *kwnames[] = {
45048 (char *) "self", NULL
45049 };
45050
45051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45053 if (SWIG_arg_fail(1)) SWIG_fail;
45054 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45055
45056 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45057 return resultobj;
45058 fail:
45059 return NULL;
45060 }
45061
45062
45063 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45064 PyObject *resultobj;
45065 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45066 wxIndividualLayoutConstraint *result;
45067 PyObject * obj0 = 0 ;
45068 char *kwnames[] = {
45069 (char *) "self", NULL
45070 };
45071
45072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45074 if (SWIG_arg_fail(1)) SWIG_fail;
45075 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45076
45077 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45078 return resultobj;
45079 fail:
45080 return NULL;
45081 }
45082
45083
45084 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45085 PyObject *resultobj;
45086 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45087 wxIndividualLayoutConstraint *result;
45088 PyObject * obj0 = 0 ;
45089 char *kwnames[] = {
45090 (char *) "self", NULL
45091 };
45092
45093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45095 if (SWIG_arg_fail(1)) SWIG_fail;
45096 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45097
45098 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45099 return resultobj;
45100 fail:
45101 return NULL;
45102 }
45103
45104
45105 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45106 PyObject *resultobj;
45107 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45108 wxIndividualLayoutConstraint *result;
45109 PyObject * obj0 = 0 ;
45110 char *kwnames[] = {
45111 (char *) "self", NULL
45112 };
45113
45114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45116 if (SWIG_arg_fail(1)) SWIG_fail;
45117 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45118
45119 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45120 return resultobj;
45121 fail:
45122 return NULL;
45123 }
45124
45125
45126 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45127 PyObject *resultobj;
45128 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45129 wxIndividualLayoutConstraint *result;
45130 PyObject * obj0 = 0 ;
45131 char *kwnames[] = {
45132 (char *) "self", NULL
45133 };
45134
45135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45137 if (SWIG_arg_fail(1)) SWIG_fail;
45138 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45139
45140 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45141 return resultobj;
45142 fail:
45143 return NULL;
45144 }
45145
45146
45147 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45148 PyObject *resultobj;
45149 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45150 wxIndividualLayoutConstraint *result;
45151 PyObject * obj0 = 0 ;
45152 char *kwnames[] = {
45153 (char *) "self", NULL
45154 };
45155
45156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45158 if (SWIG_arg_fail(1)) SWIG_fail;
45159 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45160
45161 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45162 return resultobj;
45163 fail:
45164 return NULL;
45165 }
45166
45167
45168 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45169 PyObject *resultobj;
45170 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45171 wxIndividualLayoutConstraint *result;
45172 PyObject * obj0 = 0 ;
45173 char *kwnames[] = {
45174 (char *) "self", NULL
45175 };
45176
45177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45179 if (SWIG_arg_fail(1)) SWIG_fail;
45180 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45181
45182 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45183 return resultobj;
45184 fail:
45185 return NULL;
45186 }
45187
45188
45189 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45190 PyObject *resultobj;
45191 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45192 wxIndividualLayoutConstraint *result;
45193 PyObject * obj0 = 0 ;
45194 char *kwnames[] = {
45195 (char *) "self", NULL
45196 };
45197
45198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45200 if (SWIG_arg_fail(1)) SWIG_fail;
45201 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45202
45203 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45204 return resultobj;
45205 fail:
45206 return NULL;
45207 }
45208
45209
45210 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45211 PyObject *resultobj;
45212 wxLayoutConstraints *result;
45213 char *kwnames[] = {
45214 NULL
45215 };
45216
45217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45218 {
45219 PyThreadState* __tstate = wxPyBeginAllowThreads();
45220 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45221
45222 wxPyEndAllowThreads(__tstate);
45223 if (PyErr_Occurred()) SWIG_fail;
45224 }
45225 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45226 return resultobj;
45227 fail:
45228 return NULL;
45229 }
45230
45231
45232 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45233 PyObject *resultobj;
45234 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45235 wxWindow *arg2 = (wxWindow *) 0 ;
45236 int *arg3 = (int *) 0 ;
45237 bool result;
45238 int temp3 ;
45239 int res3 = 0 ;
45240 PyObject * obj0 = 0 ;
45241 PyObject * obj1 = 0 ;
45242 char *kwnames[] = {
45243 (char *) "self",(char *) "win", NULL
45244 };
45245
45246 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45249 if (SWIG_arg_fail(1)) SWIG_fail;
45250 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45251 if (SWIG_arg_fail(2)) SWIG_fail;
45252 {
45253 PyThreadState* __tstate = wxPyBeginAllowThreads();
45254 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45255
45256 wxPyEndAllowThreads(__tstate);
45257 if (PyErr_Occurred()) SWIG_fail;
45258 }
45259 {
45260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45261 }
45262 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45263 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45264 return resultobj;
45265 fail:
45266 return NULL;
45267 }
45268
45269
45270 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45271 PyObject *resultobj;
45272 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45273 bool result;
45274 PyObject * obj0 = 0 ;
45275 char *kwnames[] = {
45276 (char *) "self", NULL
45277 };
45278
45279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45281 if (SWIG_arg_fail(1)) SWIG_fail;
45282 {
45283 PyThreadState* __tstate = wxPyBeginAllowThreads();
45284 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45285
45286 wxPyEndAllowThreads(__tstate);
45287 if (PyErr_Occurred()) SWIG_fail;
45288 }
45289 {
45290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45291 }
45292 return resultobj;
45293 fail:
45294 return NULL;
45295 }
45296
45297
45298 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45299 PyObject *obj;
45300 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45301 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45302 Py_INCREF(obj);
45303 return Py_BuildValue((char *)"");
45304 }
45305 static PyMethodDef SwigMethods[] = {
45306 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45307 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45308 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45311 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45332 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45345 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45360 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45414 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45442 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45446 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45450 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45456 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45461 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45463 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45466 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45471 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45472 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45476 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45483 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45484 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45496 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45500 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45506 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45516 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45526 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45533 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45563 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45565 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45567 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45569 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45571 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45573 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45575 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45577 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45579 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45581 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45583 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45585 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45587 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45601 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45613 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45615 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45617 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45619 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45621 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45622 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45623 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45625 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45627 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45629 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45631 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45633 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45635 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45637 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45642 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45648 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45651 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45654 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45669 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45672 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45675 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45687 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45692 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45698 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45704 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45717 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45724 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45760 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45767 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45770 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45774 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45776 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45778 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45780 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45783 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45787 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45790 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45793 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45795 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45800 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45808 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45810 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45812 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45815 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45817 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45820 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45821 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45826 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45828 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45830 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45833 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45837 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45838 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45840 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45843 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45845 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45849 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45850 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45853 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45858 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45862 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45864 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45865 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45867 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45870 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45871 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45874 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45888 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45890 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45893 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45895 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45899 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45903 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45914 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45917 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45920 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45924 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45931 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45936 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45941 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45945 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45981 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45990 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
46010 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
46017 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
46021 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
46031 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46203 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46207 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46245 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46259 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46262 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46317 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46344 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46388 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46396 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
46415 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
46416 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46431 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46451 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46453 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46483 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46485 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46486 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46490 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46493 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46503 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46515 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46517 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46527 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46537 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46547 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46561 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46568 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46569 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46570 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46571 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46572 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46576 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46577 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46595 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46596 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46599 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46600 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46602 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46603 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46604 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46605 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46607 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46610 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46611 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46612 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46614 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46616 { NULL, NULL, 0, NULL }
46617 };
46618
46619
46620 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46621
46622 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46623 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46624 }
46625 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46626 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46627 }
46628 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46629 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46630 }
46631 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46632 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46633 }
46634 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46635 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46636 }
46637 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46638 return (void *)((wxSizer *) ((wxGridSizer *) x));
46639 }
46640 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46641 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46642 }
46643 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46644 return (void *)((wxSizer *) ((wxPySizer *) x));
46645 }
46646 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46647 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46648 }
46649 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46650 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46651 }
46652 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46653 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46654 }
46655 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46656 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46657 }
46658 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46659 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46660 }
46661 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46662 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46663 }
46664 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46665 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46666 }
46667 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46668 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46669 }
46670 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46671 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46672 }
46673 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46674 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46675 }
46676 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46677 return (void *)((wxEvent *) ((wxPyEvent *) x));
46678 }
46679 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46680 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46681 }
46682 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46683 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46684 }
46685 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46686 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46687 }
46688 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46689 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46690 }
46691 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46692 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46693 }
46694 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46695 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46696 }
46697 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46698 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46699 }
46700 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46701 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46702 }
46703 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46704 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46705 }
46706 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46707 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46708 }
46709 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46710 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46711 }
46712 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46713 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46714 }
46715 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46716 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46717 }
46718 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46719 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46720 }
46721 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46722 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46723 }
46724 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46725 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46726 }
46727 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46728 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46729 }
46730 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46731 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46732 }
46733 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46734 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46735 }
46736 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46737 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46738 }
46739 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46740 return (void *)((wxEvent *) ((wxShowEvent *) x));
46741 }
46742 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46743 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46744 }
46745 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46746 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46747 }
46748 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46749 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46750 }
46751 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46752 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46753 }
46754 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46755 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46756 }
46757 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46758 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46759 }
46760 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46761 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46762 }
46763 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46764 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46765 }
46766 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46767 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46768 }
46769 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46770 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46771 }
46772 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46773 return (void *)((wxControl *) ((wxControlWithItems *) x));
46774 }
46775 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46776 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46777 }
46778 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46779 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46780 }
46781 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46782 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46783 }
46784 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46785 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46786 }
46787 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46788 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46789 }
46790 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46791 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46792 }
46793 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46794 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46795 }
46796 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46797 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46798 }
46799 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46800 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46801 }
46802 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46803 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46804 }
46805 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46806 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46807 }
46808 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46809 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46810 }
46811 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46812 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46813 }
46814 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46815 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46816 }
46817 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46818 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46819 }
46820 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46821 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46822 }
46823 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46824 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46825 }
46826 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46827 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46828 }
46829 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46830 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46831 }
46832 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46833 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46834 }
46835 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46836 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46837 }
46838 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46839 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46840 }
46841 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46842 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46843 }
46844 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46845 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46846 }
46847 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46848 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46849 }
46850 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46851 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46852 }
46853 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46854 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46855 }
46856 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46857 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46858 }
46859 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46860 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46861 }
46862 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46863 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46864 }
46865 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46866 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46867 }
46868 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46869 return (void *)((wxObject *) ((wxSizerItem *) x));
46870 }
46871 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46872 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46873 }
46874 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46875 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46876 }
46877 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46878 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46879 }
46880 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46881 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46882 }
46883 static void *_p_wxSizerTo_p_wxObject(void *x) {
46884 return (void *)((wxObject *) ((wxSizer *) x));
46885 }
46886 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46887 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46888 }
46889 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46890 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46891 }
46892 static void *_p_wxEventTo_p_wxObject(void *x) {
46893 return (void *)((wxObject *) ((wxEvent *) x));
46894 }
46895 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46896 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46897 }
46898 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46899 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46900 }
46901 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46902 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46903 }
46904 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46905 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46906 }
46907 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46908 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46909 }
46910 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46911 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46912 }
46913 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46914 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46915 }
46916 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46917 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46918 }
46919 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46920 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46921 }
46922 static void *_p_wxControlTo_p_wxObject(void *x) {
46923 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46924 }
46925 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46926 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46927 }
46928 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46929 return (void *)((wxObject *) ((wxFSFile *) x));
46930 }
46931 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46932 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46933 }
46934 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46935 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46936 }
46937 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46938 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46939 }
46940 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46941 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46942 }
46943 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46944 return (void *)((wxObject *) ((wxMenuItem *) x));
46945 }
46946 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46947 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46948 }
46949 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46950 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46951 }
46952 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46953 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46954 }
46955 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46956 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46957 }
46958 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46959 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46960 }
46961 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46962 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46963 }
46964 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46965 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46966 }
46967 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46968 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46969 }
46970 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46971 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46972 }
46973 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46974 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46975 }
46976 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46977 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46978 }
46979 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46980 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46981 }
46982 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46983 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46984 }
46985 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46986 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46987 }
46988 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46989 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46990 }
46991 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46992 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46993 }
46994 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46995 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46996 }
46997 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46998 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46999 }
47000 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
47001 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
47002 }
47003 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
47004 return (void *)((wxObject *) ((wxImageHandler *) x));
47005 }
47006 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
47007 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
47008 }
47009 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
47010 return (void *)((wxObject *) ((wxEvtHandler *) x));
47011 }
47012 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
47013 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47014 }
47015 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
47016 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
47017 }
47018 static void *_p_wxImageTo_p_wxObject(void *x) {
47019 return (void *)((wxObject *) ((wxImage *) x));
47020 }
47021 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
47022 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
47023 }
47024 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
47025 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47026 }
47027 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
47028 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
47029 }
47030 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
47031 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
47032 }
47033 static void *_p_wxWindowTo_p_wxObject(void *x) {
47034 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
47035 }
47036 static void *_p_wxMenuTo_p_wxObject(void *x) {
47037 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
47038 }
47039 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
47040 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
47041 }
47042 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
47043 return (void *)((wxObject *) ((wxFileSystem *) x));
47044 }
47045 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
47046 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
47047 }
47048 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
47049 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
47050 }
47051 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47052 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47053 }
47054 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47055 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47056 }
47057 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47058 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47059 }
47060 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47061 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47062 }
47063 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47064 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47065 }
47066 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47067 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47068 }
47069 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47070 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47071 }
47072 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47073 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47074 }
47075 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47076 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47077 }
47078 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47079 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47080 }
47081 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47082 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47083 }
47084 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47085 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47086 }
47087 static void *_p_wxControlTo_p_wxWindow(void *x) {
47088 return (void *)((wxWindow *) ((wxControl *) x));
47089 }
47090 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47091 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47092 }
47093 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47094 return (void *)((wxWindow *) ((wxMenuBar *) x));
47095 }
47096 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
47097 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
47098 }
47099 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
47100 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47101 }
47102 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47103 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47104 }
47105 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47106 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47107 }
47108 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47109 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47110 }
47111 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47112 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47113 }
47114 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47115 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47116 }
47117 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47118 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47119 }
47120 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47121 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47122 }
47123 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47124 return (void *)((wxValidator *) ((wxPyValidator *) x));
47125 }
47126 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}};
47127 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}};
47128 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}};
47129 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}};
47130 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}};
47131 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}};
47132 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}};
47133 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}};
47134 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}};
47135 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}};
47136 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}};
47137 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}};
47138 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}};
47139 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}};
47140 static swig_type_info _swigt__p_buffer[] = {{"_p_buffer", 0, "buffer *", 0, 0, 0, 0},{"_p_buffer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47141 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}};
47142 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}};
47143 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}};
47144 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}};
47145 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}};
47146 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}};
47147 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}};
47148 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}};
47149 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}};
47150 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}};
47151 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}};
47152 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}};
47153 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}};
47154 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}};
47155 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}};
47156 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}};
47157 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}};
47158 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}};
47159 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}};
47160 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}};
47161 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}};
47162 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}};
47163 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}};
47164 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}};
47165 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}};
47166 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}};
47167 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}};
47168 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}};
47169 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}};
47170 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}};
47171 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}};
47172 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}};
47173 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}};
47174 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}};
47175 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}};
47176 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}};
47177 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}};
47178 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}};
47179 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}};
47180 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}};
47181 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}};
47182 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}};
47183 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}};
47184 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}};
47185 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}};
47186 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}};
47187 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}};
47188 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}};
47189 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}};
47190 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}};
47191 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}};
47192 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}};
47193 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}};
47194 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}};
47195 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}};
47196 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}};
47197 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}};
47198 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}};
47199 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}};
47200 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}};
47201 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}};
47202 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}};
47203 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}};
47204 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}};
47205 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}};
47206 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}};
47207 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}};
47208 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}};
47209 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}};
47210 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}};
47211 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}};
47212 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}};
47213 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}};
47214 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}};
47215 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}};
47216 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}};
47217 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}};
47218 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}};
47219 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}};
47220 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}};
47221 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}};
47222 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}};
47223 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}};
47224 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}};
47225 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}};
47226 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}};
47227 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}};
47228 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}};
47229 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}};
47230 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}};
47231 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}};
47232 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}};
47233 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}};
47234 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}};
47235 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}};
47236 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}};
47237 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}};
47238 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47239 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}};
47240 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}};
47241 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}};
47242 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}};
47243 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}};
47244 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}};
47245 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}};
47246 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}};
47247 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}};
47248 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}};
47249 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}};
47250 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}};
47251 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}};
47252 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}};
47253 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}};
47254
47255 static swig_type_info *swig_types_initial[] = {
47256 _swigt__p_wxLayoutConstraints,
47257 _swigt__p_wxRealPoint,
47258 _swigt__p_wxSizerItem,
47259 _swigt__p_wxGBSizerItem,
47260 _swigt__p_wxScrollEvent,
47261 _swigt__p_wxEventLoop,
47262 _swigt__p_wxIndividualLayoutConstraint,
47263 _swigt__p_wxSizer,
47264 _swigt__p_wxBoxSizer,
47265 _swigt__p_wxStaticBoxSizer,
47266 _swigt__p_wxGridBagSizer,
47267 _swigt__p_wxAcceleratorEntry,
47268 _swigt__p_wxUpdateUIEvent,
47269 _swigt__p_wxEvent,
47270 _swigt__p_buffer,
47271 _swigt__p_wxMenu,
47272 _swigt__p_wxGridSizer,
47273 _swigt__p_wxFlexGridSizer,
47274 _swigt__p_wxInitDialogEvent,
47275 _swigt__p_wxItemContainer,
47276 _swigt__p_wxNcPaintEvent,
47277 _swigt__p_wxPaintEvent,
47278 _swigt__p_wxSysColourChangedEvent,
47279 _swigt__p_wxMouseCaptureChangedEvent,
47280 _swigt__p_wxDisplayChangedEvent,
47281 _swigt__p_wxPaletteChangedEvent,
47282 _swigt__p_wxControl,
47283 _swigt__p_wxFont,
47284 _swigt__p_wxMenuBarBase,
47285 _swigt__p_wxSetCursorEvent,
47286 _swigt__p_wxFSFile,
47287 _swigt__p_wxCaret,
47288 _swigt__ptrdiff_t,
47289 _swigt__std__ptrdiff_t,
47290 _swigt__p_wxRegion,
47291 _swigt__p_wxPoint2D,
47292 _swigt__p_int,
47293 _swigt__p_wxSize,
47294 _swigt__p_wxDC,
47295 _swigt__p_wxPySizer,
47296 _swigt__p_wxVisualAttributes,
47297 _swigt__p_wxNotifyEvent,
47298 _swigt__p_wxPyEvent,
47299 _swigt__p_wxPropagationDisabler,
47300 _swigt__p_form_ops_t,
47301 _swigt__p_wxAppTraits,
47302 _swigt__p_wxArrayString,
47303 _swigt__p_wxShowEvent,
47304 _swigt__p_wxToolTip,
47305 _swigt__p_wxMoveEvent,
47306 _swigt__p_wxSizeEvent,
47307 _swigt__p_wxActivateEvent,
47308 _swigt__p_wxIconizeEvent,
47309 _swigt__p_wxMaximizeEvent,
47310 _swigt__p_wxQueryNewPaletteEvent,
47311 _swigt__p_wxWindowCreateEvent,
47312 _swigt__p_wxIdleEvent,
47313 _swigt__p_wxDateEvent,
47314 _swigt__p_wxMenuItem,
47315 _swigt__p_wxStaticBox,
47316 _swigt__p_long,
47317 _swigt__p_wxDuplexMode,
47318 _swigt__p_wxTIFFHandler,
47319 _swigt__p_wxXPMHandler,
47320 _swigt__p_wxPNMHandler,
47321 _swigt__p_wxJPEGHandler,
47322 _swigt__p_wxPCXHandler,
47323 _swigt__p_wxGIFHandler,
47324 _swigt__p_wxPNGHandler,
47325 _swigt__p_wxANIHandler,
47326 _swigt__p_wxMemoryFSHandler,
47327 _swigt__p_wxZipFSHandler,
47328 _swigt__p_wxInternetFSHandler,
47329 _swigt__p_wxPyFileSystemHandler,
47330 _swigt__p_wxEvtHandler,
47331 _swigt__p_wxCURHandler,
47332 _swigt__p_wxICOHandler,
47333 _swigt__p_wxBMPHandler,
47334 _swigt__p_wxImageHandler,
47335 _swigt__p_wxFileSystemHandler,
47336 _swigt__p_wxRect,
47337 _swigt__p_wxButton,
47338 _swigt__p_wxGBSpan,
47339 _swigt__p_wxPropagateOnce,
47340 _swigt__p_wxAcceleratorTable,
47341 _swigt__p_wxStdDialogButtonSizer,
47342 _swigt__p_char,
47343 _swigt__p_wxGBPosition,
47344 _swigt__p_wxImage,
47345 _swigt__p_wxFrame,
47346 _swigt__p_wxScrollWinEvent,
47347 _swigt__p_wxPaperSize,
47348 _swigt__p_wxImageHistogram,
47349 _swigt__p_wxPoint,
47350 _swigt__p_wxCursor,
47351 _swigt__p_wxObject,
47352 _swigt__p_wxInputStream,
47353 _swigt__p_wxOutputStream,
47354 _swigt__p_wxPyInputStream,
47355 _swigt__p_wxDateTime,
47356 _swigt__p_wxKeyEvent,
47357 _swigt__p_wxNavigationKeyEvent,
47358 _swigt__p_wxWindowDestroyEvent,
47359 _swigt__p_unsigned_long,
47360 _swigt__p_wxWindow,
47361 _swigt__p_wxMenuBar,
47362 _swigt__p_wxFileSystem,
47363 _swigt__p_wxBitmap,
47364 _swigt__unsigned_int,
47365 _swigt__p_unsigned_int,
47366 _swigt__p_wxMenuEvent,
47367 _swigt__p_wxContextMenuEvent,
47368 _swigt__p_unsigned_char,
47369 _swigt__p_wxEraseEvent,
47370 _swigt__p_wxMouseEvent,
47371 _swigt__p_wxCloseEvent,
47372 _swigt__p_wxPyApp,
47373 _swigt__p_wxCommandEvent,
47374 _swigt__p_wxPyCommandEvent,
47375 _swigt__p_wxPyDropTarget,
47376 _swigt__p_wxQuantize,
47377 _swigt__p_wxFocusEvent,
47378 _swigt__p_wxChildFocusEvent,
47379 _swigt__p_wxDropFilesEvent,
47380 _swigt__p_wxControlWithItems,
47381 _swigt__p_wxColour,
47382 _swigt__p_wxValidator,
47383 _swigt__p_wxPyValidator,
47384 0
47385 };
47386
47387
47388 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47389
47390 static swig_const_info swig_const_table[] = {
47391 {0, 0, 0, 0.0, 0, 0}};
47392
47393 #ifdef __cplusplus
47394 }
47395 #endif
47396
47397
47398 #ifdef __cplusplus
47399 extern "C" {
47400 #endif
47401
47402 /* Python-specific SWIG API */
47403 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47404 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47405 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47406
47407 /* -----------------------------------------------------------------------------
47408 * global variable support code.
47409 * ----------------------------------------------------------------------------- */
47410
47411 typedef struct swig_globalvar {
47412 char *name; /* Name of global variable */
47413 PyObject *(*get_attr)(); /* Return the current value */
47414 int (*set_attr)(PyObject *); /* Set the value */
47415 struct swig_globalvar *next;
47416 } swig_globalvar;
47417
47418 typedef struct swig_varlinkobject {
47419 PyObject_HEAD
47420 swig_globalvar *vars;
47421 } swig_varlinkobject;
47422
47423 static PyObject *
47424 swig_varlink_repr(swig_varlinkobject *v) {
47425 v = v;
47426 return PyString_FromString("<Swig global variables>");
47427 }
47428
47429 static int
47430 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47431 swig_globalvar *var;
47432 flags = flags;
47433 fprintf(fp,"Swig global variables { ");
47434 for (var = v->vars; var; var=var->next) {
47435 fprintf(fp,"%s", var->name);
47436 if (var->next) fprintf(fp,", ");
47437 }
47438 fprintf(fp," }\n");
47439 return 0;
47440 }
47441
47442 static PyObject *
47443 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47444 swig_globalvar *var = v->vars;
47445 while (var) {
47446 if (strcmp(var->name,n) == 0) {
47447 return (*var->get_attr)();
47448 }
47449 var = var->next;
47450 }
47451 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47452 return NULL;
47453 }
47454
47455 static int
47456 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47457 swig_globalvar *var = v->vars;
47458 while (var) {
47459 if (strcmp(var->name,n) == 0) {
47460 return (*var->set_attr)(p);
47461 }
47462 var = var->next;
47463 }
47464 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47465 return 1;
47466 }
47467
47468 static PyTypeObject varlinktype = {
47469 PyObject_HEAD_INIT(0)
47470 0, /* Number of items in variable part (ob_size) */
47471 (char *)"swigvarlink", /* Type name (tp_name) */
47472 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47473 0, /* Itemsize (tp_itemsize) */
47474 0, /* Deallocator (tp_dealloc) */
47475 (printfunc) swig_varlink_print, /* Print (tp_print) */
47476 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47477 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47478 0, /* tp_compare */
47479 (reprfunc) swig_varlink_repr, /* tp_repr */
47480 0, /* tp_as_number */
47481 0, /* tp_as_sequence */
47482 0, /* tp_as_mapping */
47483 0, /* tp_hash */
47484 0, /* tp_call */
47485 0, /* tp_str */
47486 0, /* tp_getattro */
47487 0, /* tp_setattro */
47488 0, /* tp_as_buffer */
47489 0, /* tp_flags */
47490 0, /* tp_doc */
47491 #if PY_VERSION_HEX >= 0x02000000
47492 0, /* tp_traverse */
47493 0, /* tp_clear */
47494 #endif
47495 #if PY_VERSION_HEX >= 0x02010000
47496 0, /* tp_richcompare */
47497 0, /* tp_weaklistoffset */
47498 #endif
47499 #if PY_VERSION_HEX >= 0x02020000
47500 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47501 #endif
47502 #if PY_VERSION_HEX >= 0x02030000
47503 0, /* tp_del */
47504 #endif
47505 #ifdef COUNT_ALLOCS
47506 0,0,0,0 /* tp_alloc -> tp_next */
47507 #endif
47508 };
47509
47510 /* Create a variable linking object for use later */
47511 static PyObject *
47512 SWIG_Python_newvarlink(void) {
47513 swig_varlinkobject *result = 0;
47514 result = PyMem_NEW(swig_varlinkobject,1);
47515 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47516 result->ob_type = &varlinktype;
47517 result->vars = 0;
47518 result->ob_refcnt = 0;
47519 Py_XINCREF((PyObject *) result);
47520 return ((PyObject*) result);
47521 }
47522
47523 static void
47524 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47525 swig_varlinkobject *v;
47526 swig_globalvar *gv;
47527 v= (swig_varlinkobject *) p;
47528 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47529 gv->name = (char *) malloc(strlen(name)+1);
47530 strcpy(gv->name,name);
47531 gv->get_attr = get_attr;
47532 gv->set_attr = set_attr;
47533 gv->next = v->vars;
47534 v->vars = gv;
47535 }
47536
47537 /* -----------------------------------------------------------------------------
47538 * constants/methods manipulation
47539 * ----------------------------------------------------------------------------- */
47540
47541 /* Install Constants */
47542 static void
47543 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47544 PyObject *obj = 0;
47545 size_t i;
47546 for (i = 0; constants[i].type; i++) {
47547 switch(constants[i].type) {
47548 case SWIG_PY_INT:
47549 obj = PyInt_FromLong(constants[i].lvalue);
47550 break;
47551 case SWIG_PY_FLOAT:
47552 obj = PyFloat_FromDouble(constants[i].dvalue);
47553 break;
47554 case SWIG_PY_STRING:
47555 if (constants[i].pvalue) {
47556 obj = PyString_FromString((char *) constants[i].pvalue);
47557 } else {
47558 Py_INCREF(Py_None);
47559 obj = Py_None;
47560 }
47561 break;
47562 case SWIG_PY_POINTER:
47563 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47564 break;
47565 case SWIG_PY_BINARY:
47566 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47567 break;
47568 default:
47569 obj = 0;
47570 break;
47571 }
47572 if (obj) {
47573 PyDict_SetItemString(d,constants[i].name,obj);
47574 Py_DECREF(obj);
47575 }
47576 }
47577 }
47578
47579 /* -----------------------------------------------------------------------------*/
47580 /* Fix SwigMethods to carry the callback ptrs when needed */
47581 /* -----------------------------------------------------------------------------*/
47582
47583 static void
47584 SWIG_Python_FixMethods(PyMethodDef *methods,
47585 swig_const_info *const_table,
47586 swig_type_info **types,
47587 swig_type_info **types_initial) {
47588 size_t i;
47589 for (i = 0; methods[i].ml_name; ++i) {
47590 char *c = methods[i].ml_doc;
47591 if (c && (c = strstr(c, "swig_ptr: "))) {
47592 int j;
47593 swig_const_info *ci = 0;
47594 char *name = c + 10;
47595 for (j = 0; const_table[j].type; j++) {
47596 if (strncmp(const_table[j].name, name,
47597 strlen(const_table[j].name)) == 0) {
47598 ci = &(const_table[j]);
47599 break;
47600 }
47601 }
47602 if (ci) {
47603 size_t shift = (ci->ptype) - types;
47604 swig_type_info *ty = types_initial[shift];
47605 size_t ldoc = (c - methods[i].ml_doc);
47606 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47607 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47608 char *buff = ndoc;
47609 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47610 strncpy(buff, methods[i].ml_doc, ldoc);
47611 buff += ldoc;
47612 strncpy(buff, "swig_ptr: ", 10);
47613 buff += 10;
47614 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47615 methods[i].ml_doc = ndoc;
47616 }
47617 }
47618 }
47619 }
47620
47621 /* -----------------------------------------------------------------------------*
47622 * Initialize type list
47623 * -----------------------------------------------------------------------------*/
47624
47625 #if PY_MAJOR_VERSION < 2
47626 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47627 is copied out of Python/modsupport.c in python version 2.3.4 */
47628 static int
47629 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47630 {
47631 PyObject *dict;
47632 if (!PyModule_Check(m)) {
47633 PyErr_SetString(PyExc_TypeError,
47634 "PyModule_AddObject() needs module as first arg");
47635 return -1;
47636 }
47637 if (!o) {
47638 PyErr_SetString(PyExc_TypeError,
47639 "PyModule_AddObject() needs non-NULL value");
47640 return -1;
47641 }
47642
47643 dict = PyModule_GetDict(m);
47644 if (dict == NULL) {
47645 /* Internal error -- modules must have a dict! */
47646 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47647 PyModule_GetName(m));
47648 return -1;
47649 }
47650 if (PyDict_SetItemString(dict, name, o))
47651 return -1;
47652 Py_DECREF(o);
47653 return 0;
47654 }
47655 #endif
47656
47657 static swig_type_info **
47658 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47659 static PyMethodDef swig_empty_runtime_method_table[] = {
47660 {
47661 NULL, NULL, 0, NULL
47662 }
47663 };/* Sentinel */
47664
47665 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47666 swig_empty_runtime_method_table);
47667 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47668 if (pointer && module) {
47669 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47670 }
47671 return type_list_handle;
47672 }
47673
47674 static swig_type_info **
47675 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47676 swig_type_info **type_pointer;
47677
47678 /* first check if module already created */
47679 type_pointer = SWIG_Python_GetTypeListHandle();
47680 if (type_pointer) {
47681 return type_pointer;
47682 } else {
47683 /* create a new module and variable */
47684 return SWIG_Python_SetTypeListHandle(type_list_handle);
47685 }
47686 }
47687
47688 #ifdef __cplusplus
47689 }
47690 #endif
47691
47692 /* -----------------------------------------------------------------------------*
47693 * Partial Init method
47694 * -----------------------------------------------------------------------------*/
47695
47696 #ifdef SWIG_LINK_RUNTIME
47697 #ifdef __cplusplus
47698 extern "C"
47699 #endif
47700 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47701 #endif
47702
47703 #ifdef __cplusplus
47704 extern "C"
47705 #endif
47706 SWIGEXPORT(void) SWIG_init(void) {
47707 static PyObject *SWIG_globals = 0;
47708 static int typeinit = 0;
47709 PyObject *m, *d;
47710 int i;
47711 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47712
47713 /* Fix SwigMethods to carry the callback ptrs when needed */
47714 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47715
47716 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47717 d = PyModule_GetDict(m);
47718
47719 if (!typeinit) {
47720 #ifdef SWIG_LINK_RUNTIME
47721 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47722 #else
47723 # ifndef SWIG_STATIC_RUNTIME
47724 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47725 # endif
47726 #endif
47727 for (i = 0; swig_types_initial[i]; i++) {
47728 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47729 }
47730 typeinit = 1;
47731 }
47732 SWIG_InstallConstants(d,swig_const_table);
47733
47734
47735 #ifndef wxPyUSE_EXPORT
47736 // Make our API structure a CObject so other modules can import it
47737 // from this module.
47738 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47739 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47740 Py_XDECREF(cobj);
47741 #endif
47742
47743 {
47744 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47745 }
47746 {
47747 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47748 }
47749 {
47750 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47751 }
47752 {
47753 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47754 }
47755 {
47756 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47757 }
47758 {
47759 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47760 }
47761 {
47762 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47763 }
47764 {
47765 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47766 }
47767 {
47768 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47769 }
47770 {
47771 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47772 }
47773 {
47774 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47775 }
47776 {
47777 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47778 }
47779 {
47780 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int((int)(wxDEFAULT_CONTROL_BORDER)));
47781 }
47782 {
47783 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47784 }
47785 {
47786 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47787 }
47788 {
47789 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47790 }
47791 {
47792 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47793 }
47794 {
47795 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47796 }
47797 {
47798 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47799 }
47800 {
47801 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47802 }
47803 {
47804 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47805 }
47806 {
47807 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47808 }
47809 {
47810 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47811 }
47812 {
47813 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47814 }
47815 {
47816 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47817 }
47818 {
47819 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47820 }
47821 {
47822 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47823 }
47824 {
47825 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47826 }
47827 {
47828 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47829 }
47830 {
47831 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47832 }
47833 {
47834 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47835 }
47836 {
47837 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47838 }
47839 {
47840 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47841 }
47842 {
47843 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47844 }
47845 {
47846 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47847 }
47848 {
47849 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47850 }
47851 {
47852 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47853 }
47854 {
47855 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47856 }
47857 {
47858 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47859 }
47860 {
47861 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47862 }
47863 {
47864 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47865 }
47866 {
47867 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47868 }
47869 {
47870 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47871 }
47872 {
47873 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47874 }
47875 {
47876 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47877 }
47878 {
47879 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47880 }
47881 {
47882 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47883 }
47884 {
47885 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47886 }
47887 {
47888 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47889 }
47890 {
47891 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47892 }
47893 {
47894 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47895 }
47896 {
47897 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47898 }
47899 {
47900 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47901 }
47902 {
47903 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47904 }
47905 {
47906 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47907 }
47908 {
47909 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47910 }
47911 {
47912 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47913 }
47914 {
47915 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47916 }
47917 {
47918 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47919 }
47920 {
47921 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47922 }
47923 {
47924 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47925 }
47926 {
47927 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47928 }
47929 {
47930 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47931 }
47932 {
47933 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47934 }
47935 {
47936 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47937 }
47938 {
47939 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47940 }
47941 {
47942 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47943 }
47944 {
47945 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47946 }
47947 {
47948 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47949 }
47950 {
47951 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47952 }
47953 {
47954 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47955 }
47956 {
47957 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47958 }
47959 {
47960 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47961 }
47962 {
47963 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47964 }
47965 {
47966 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47967 }
47968 {
47969 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47970 }
47971 {
47972 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47973 }
47974 {
47975 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47976 }
47977 {
47978 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47979 }
47980 {
47981 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47982 }
47983 {
47984 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47985 }
47986 {
47987 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47988 }
47989 {
47990 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47991 }
47992 {
47993 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47994 }
47995 {
47996 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47997 }
47998 {
47999 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
48000 }
48001 {
48002 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
48003 }
48004 {
48005 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
48006 }
48007 {
48008 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
48009 }
48010 {
48011 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
48012 }
48013 {
48014 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
48015 }
48016 {
48017 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
48018 }
48019 {
48020 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
48021 }
48022 {
48023 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
48024 }
48025 {
48026 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
48027 }
48028 {
48029 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
48030 }
48031 {
48032 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
48033 }
48034 {
48035 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
48036 }
48037 {
48038 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
48039 }
48040 {
48041 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
48042 }
48043 {
48044 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
48045 }
48046 {
48047 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
48048 }
48049 {
48050 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
48051 }
48052 {
48053 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
48054 }
48055 {
48056 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
48057 }
48058 {
48059 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
48060 }
48061 {
48062 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
48063 }
48064 {
48065 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
48066 }
48067 {
48068 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
48069 }
48070 {
48071 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
48072 }
48073 {
48074 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
48075 }
48076 {
48077 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
48078 }
48079 {
48080 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
48081 }
48082 {
48083 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
48084 }
48085 {
48086 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
48087 }
48088 {
48089 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
48090 }
48091 {
48092 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
48093 }
48094 {
48095 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
48096 }
48097 {
48098 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
48099 }
48100 {
48101 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
48102 }
48103 {
48104 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
48105 }
48106 {
48107 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48108 }
48109 {
48110 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48111 }
48112 {
48113 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48114 }
48115 {
48116 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48117 }
48118 {
48119 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48120 }
48121 {
48122 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48123 }
48124 {
48125 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48126 }
48127 {
48128 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48129 }
48130 {
48131 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48132 }
48133 {
48134 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48135 }
48136 {
48137 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48138 }
48139 {
48140 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48141 }
48142 {
48143 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48144 }
48145 {
48146 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48147 }
48148 {
48149 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48150 }
48151 {
48152 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48153 }
48154 {
48155 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48156 }
48157 {
48158 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48159 }
48160 {
48161 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48162 }
48163 {
48164 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48165 }
48166 {
48167 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48168 }
48169 {
48170 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48171 }
48172 {
48173 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48174 }
48175 {
48176 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48177 }
48178 {
48179 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48180 }
48181 {
48182 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48183 }
48184 {
48185 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48186 }
48187 {
48188 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48189 }
48190 {
48191 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48192 }
48193 {
48194 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48195 }
48196 {
48197 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48198 }
48199 {
48200 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48201 }
48202 {
48203 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48204 }
48205 {
48206 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48207 }
48208 {
48209 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48210 }
48211 {
48212 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48213 }
48214 {
48215 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48216 }
48217 {
48218 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48219 }
48220 {
48221 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48222 }
48223 {
48224 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48225 }
48226 {
48227 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48228 }
48229 {
48230 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48231 }
48232 {
48233 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48234 }
48235 {
48236 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48237 }
48238 {
48239 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48240 }
48241 {
48242 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48243 }
48244 {
48245 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48246 }
48247 {
48248 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48249 }
48250 {
48251 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48252 }
48253 {
48254 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48255 }
48256 {
48257 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48258 }
48259 {
48260 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48261 }
48262 {
48263 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48264 }
48265 {
48266 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48267 }
48268 {
48269 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48270 }
48271 {
48272 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48273 }
48274 {
48275 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48276 }
48277 {
48278 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48279 }
48280 {
48281 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48282 }
48283 {
48284 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48285 }
48286 {
48287 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48288 }
48289 {
48290 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48291 }
48292 {
48293 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48294 }
48295 {
48296 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48297 }
48298 {
48299 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48300 }
48301 {
48302 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48303 }
48304 {
48305 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48306 }
48307 {
48308 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48309 }
48310 {
48311 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48312 }
48313 {
48314 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48315 }
48316 {
48317 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48318 }
48319 {
48320 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48321 }
48322 {
48323 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48324 }
48325 {
48326 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48327 }
48328 {
48329 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48330 }
48331 {
48332 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48333 }
48334 {
48335 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48336 }
48337 {
48338 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48339 }
48340 {
48341 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48342 }
48343 {
48344 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48345 }
48346 {
48347 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48348 }
48349 {
48350 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48351 }
48352 {
48353 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48354 }
48355 {
48356 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48357 }
48358 {
48359 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48360 }
48361 {
48362 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48363 }
48364 {
48365 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48366 }
48367 {
48368 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48369 }
48370 {
48371 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48372 }
48373 {
48374 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48375 }
48376 {
48377 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48378 }
48379 {
48380 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48381 }
48382 {
48383 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48384 }
48385 {
48386 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48387 }
48388 {
48389 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48390 }
48391 {
48392 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48393 }
48394 {
48395 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48396 }
48397 {
48398 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48399 }
48400 {
48401 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48402 }
48403 {
48404 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48405 }
48406 {
48407 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48408 }
48409 {
48410 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48411 }
48412 {
48413 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48414 }
48415 {
48416 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48417 }
48418 {
48419 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48420 }
48421 {
48422 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48423 }
48424 {
48425 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48426 }
48427 {
48428 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48429 }
48430 {
48431 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48432 }
48433 {
48434 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48435 }
48436 {
48437 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48438 }
48439 {
48440 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48441 }
48442 {
48443 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48444 }
48445 {
48446 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48447 }
48448 {
48449 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48450 }
48451 {
48452 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48453 }
48454 {
48455 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48456 }
48457 {
48458 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48459 }
48460 {
48461 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48462 }
48463 {
48464 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48465 }
48466 {
48467 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48468 }
48469 {
48470 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48471 }
48472 {
48473 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48474 }
48475 {
48476 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48477 }
48478 {
48479 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48480 }
48481 {
48482 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48483 }
48484 {
48485 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48486 }
48487 {
48488 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48489 }
48490 {
48491 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48492 }
48493 {
48494 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48495 }
48496 {
48497 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48498 }
48499 {
48500 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48501 }
48502 {
48503 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48504 }
48505 {
48506 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48507 }
48508 {
48509 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48510 }
48511 {
48512 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48513 }
48514 {
48515 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48516 }
48517 {
48518 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48519 }
48520 {
48521 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48522 }
48523 {
48524 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48525 }
48526 {
48527 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48528 }
48529 {
48530 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48531 }
48532 {
48533 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48534 }
48535 {
48536 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48537 }
48538 {
48539 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48540 }
48541 {
48542 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48543 }
48544 {
48545 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48546 }
48547 {
48548 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48549 }
48550 {
48551 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48552 }
48553 {
48554 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48555 }
48556 {
48557 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48558 }
48559 {
48560 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48561 }
48562 {
48563 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48564 }
48565 {
48566 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48567 }
48568 {
48569 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48570 }
48571 {
48572 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48573 }
48574 {
48575 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48576 }
48577 {
48578 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48579 }
48580 {
48581 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48582 }
48583 {
48584 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48585 }
48586 {
48587 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48588 }
48589 {
48590 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48591 }
48592 {
48593 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48594 }
48595 {
48596 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48597 }
48598 {
48599 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48600 }
48601 {
48602 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48603 }
48604 {
48605 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48606 }
48607 {
48608 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48609 }
48610 {
48611 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48612 }
48613 {
48614 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48615 }
48616 {
48617 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48618 }
48619 {
48620 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48621 }
48622 {
48623 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48624 }
48625 {
48626 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48627 }
48628 {
48629 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48630 }
48631 {
48632 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48633 }
48634 {
48635 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48636 }
48637 {
48638 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48639 }
48640 {
48641 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48642 }
48643 {
48644 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48645 }
48646 {
48647 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48648 }
48649 {
48650 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48651 }
48652 {
48653 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48654 }
48655 {
48656 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48657 }
48658 {
48659 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48660 }
48661 {
48662 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48663 }
48664 {
48665 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48666 }
48667 {
48668 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48669 }
48670 {
48671 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48672 }
48673 {
48674 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48675 }
48676 {
48677 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48678 }
48679 {
48680 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48681 }
48682 {
48683 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48684 }
48685 {
48686 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48687 }
48688 {
48689 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48690 }
48691 {
48692 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48693 }
48694 {
48695 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48696 }
48697 {
48698 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48699 }
48700 {
48701 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48702 }
48703 {
48704 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48705 }
48706 {
48707 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48708 }
48709 {
48710 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48711 }
48712 {
48713 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48714 }
48715 {
48716 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48717 }
48718 {
48719 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48720 }
48721 {
48722 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48723 }
48724 {
48725 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48726 }
48727 {
48728 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48729 }
48730 {
48731 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48732 }
48733 {
48734 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48735 }
48736 {
48737 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48738 }
48739 {
48740 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48741 }
48742 {
48743 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48744 }
48745 {
48746 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48747 }
48748 {
48749 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48750 }
48751 {
48752 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48753 }
48754 {
48755 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48756 }
48757 {
48758 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48759 }
48760 {
48761 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48762 }
48763 {
48764 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48765 }
48766 {
48767 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48768 }
48769 {
48770 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48771 }
48772 {
48773 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48774 }
48775 {
48776 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48777 }
48778 {
48779 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48780 }
48781 {
48782 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48783 }
48784 {
48785 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48786 }
48787 {
48788 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48789 }
48790 {
48791 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48792 }
48793 {
48794 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48795 }
48796 {
48797 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48798 }
48799 {
48800 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48801 }
48802 {
48803 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48804 }
48805 {
48806 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48807 }
48808 {
48809 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48810 }
48811 {
48812 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48813 }
48814 {
48815 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48816 }
48817 {
48818 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48819 }
48820 {
48821 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48822 }
48823 {
48824 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48825 }
48826 {
48827 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48828 }
48829 {
48830 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48831 }
48832 {
48833 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48834 }
48835 {
48836 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48837 }
48838 {
48839 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48840 }
48841 {
48842 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48843 }
48844 {
48845 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48846 }
48847 {
48848 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48849 }
48850 {
48851 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48852 }
48853 {
48854 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48855 }
48856 {
48857 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48858 }
48859 {
48860 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48861 }
48862 {
48863 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48864 }
48865 {
48866 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48867 }
48868 {
48869 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48870 }
48871 {
48872 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48873 }
48874 {
48875 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48876 }
48877 {
48878 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48879 }
48880 {
48881 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48882 }
48883 {
48884 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48885 }
48886 {
48887 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48888 }
48889 {
48890 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48891 }
48892 {
48893 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48894 }
48895 {
48896 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48897 }
48898 {
48899 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48900 }
48901 {
48902 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48903 }
48904 {
48905 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48906 }
48907 {
48908 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48909 }
48910 {
48911 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48912 }
48913 {
48914 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48915 }
48916 {
48917 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48918 }
48919 {
48920 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48921 }
48922 {
48923 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48924 }
48925 {
48926 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48927 }
48928 {
48929 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48930 }
48931 {
48932 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48933 }
48934 {
48935 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48936 }
48937 {
48938 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48939 }
48940 {
48941 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48942 }
48943 {
48944 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48945 }
48946 {
48947 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48948 }
48949 {
48950 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48951 }
48952 {
48953 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48954 }
48955 {
48956 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48957 }
48958 {
48959 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48960 }
48961 {
48962 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48963 }
48964 {
48965 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48966 }
48967 {
48968 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48969 }
48970 {
48971 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48972 }
48973 {
48974 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48975 }
48976 {
48977 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48978 }
48979 {
48980 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48981 }
48982 {
48983 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48984 }
48985 {
48986 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48987 }
48988 {
48989 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48990 }
48991 {
48992 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48993 }
48994 {
48995 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48996 }
48997 {
48998 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48999 }
49000 {
49001 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
49002 }
49003 {
49004 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
49005 }
49006 {
49007 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
49008 }
49009 {
49010 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
49011 }
49012 {
49013 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
49014 }
49015 {
49016 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
49017 }
49018 {
49019 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
49020 }
49021 {
49022 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
49023 }
49024 {
49025 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
49026 }
49027 {
49028 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
49029 }
49030 {
49031 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
49032 }
49033 {
49034 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
49035 }
49036 {
49037 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
49038 }
49039 {
49040 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
49041 }
49042 {
49043 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
49044 }
49045 {
49046 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
49047 }
49048 {
49049 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
49050 }
49051 {
49052 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
49053 }
49054 {
49055 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
49056 }
49057 {
49058 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
49059 }
49060 {
49061 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
49062 }
49063 {
49064 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
49065 }
49066 {
49067 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
49068 }
49069 {
49070 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
49071 }
49072 {
49073 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
49074 }
49075 {
49076 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
49077 }
49078 {
49079 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
49080 }
49081 {
49082 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
49083 }
49084 {
49085 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
49086 }
49087 {
49088 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
49089 }
49090 {
49091 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
49092 }
49093 {
49094 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
49095 }
49096 {
49097 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
49098 }
49099 {
49100 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
49101 }
49102 {
49103 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49104 }
49105 {
49106 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49107 }
49108 {
49109 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49110 }
49111 {
49112 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49113 }
49114 {
49115 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49116 }
49117 {
49118 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49119 }
49120 {
49121 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49122 }
49123 {
49124 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49125 }
49126 {
49127 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49128 }
49129 {
49130 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49131 }
49132 {
49133 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49134 }
49135 {
49136 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49137 }
49138 {
49139 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49140 }
49141 {
49142 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49143 }
49144 {
49145 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49146 }
49147 {
49148 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49149 }
49150 {
49151 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49152 }
49153 {
49154 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49155 }
49156 {
49157 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49158 }
49159 {
49160 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49161 }
49162 {
49163 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49164 }
49165 {
49166 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49167 }
49168 {
49169 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49170 }
49171 {
49172 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49173 }
49174 {
49175 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49176 }
49177 {
49178 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49179 }
49180 {
49181 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49182 }
49183 {
49184 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49185 }
49186 {
49187 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49188 }
49189 {
49190 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49191 }
49192 {
49193 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49194 }
49195 {
49196 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49197 }
49198 {
49199 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49200 }
49201 {
49202 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49203 }
49204 {
49205 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49206 }
49207 {
49208 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49209 }
49210 {
49211 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49212 }
49213 {
49214 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49215 }
49216 {
49217 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49218 }
49219 {
49220 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49221 }
49222 {
49223 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49224 }
49225 {
49226 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49227 }
49228 {
49229 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49230 }
49231 {
49232 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49233 }
49234 {
49235 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49236 }
49237 {
49238 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49239 }
49240 {
49241 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49242 }
49243 {
49244 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49245 }
49246 {
49247 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49248 }
49249 {
49250 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49251 }
49252 {
49253 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49254 }
49255 {
49256 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49257 }
49258 {
49259 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49260 }
49261 {
49262 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49263 }
49264 {
49265 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49266 }
49267 {
49268 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49269 }
49270 {
49271 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49272 }
49273 {
49274 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49275 }
49276 {
49277 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49278 }
49279 {
49280 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49281 }
49282 {
49283 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49284 }
49285 {
49286 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49287 }
49288 {
49289 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49290 }
49291 {
49292 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49293 }
49294 {
49295 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49296 }
49297 {
49298 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49299 }
49300 {
49301 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49302 }
49303 {
49304 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49305 }
49306 {
49307 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49308 }
49309 {
49310 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49311 }
49312 {
49313 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49314 }
49315 {
49316 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49317 }
49318 {
49319 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49320 }
49321 {
49322 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49323 }
49324 {
49325 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49326 }
49327 {
49328 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49329 }
49330 {
49331 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49332 }
49333 {
49334 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49335 }
49336 {
49337 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49338 }
49339 {
49340 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49341 }
49342 {
49343 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49344 }
49345 {
49346 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49347 }
49348 {
49349 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49350 }
49351 {
49352 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49353 }
49354 {
49355 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49356 }
49357 {
49358 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49359 }
49360 {
49361 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49362 }
49363 {
49364 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49365 }
49366 {
49367 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49368 }
49369 {
49370 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49371 }
49372 {
49373 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49374 }
49375 {
49376 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49377 }
49378 {
49379 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49380 }
49381 {
49382 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49383 }
49384 {
49385 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49386 }
49387 {
49388 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49389 }
49390 {
49391 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49392 }
49393 {
49394 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49395 }
49396 {
49397 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49398 }
49399 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49400 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49401 {
49402 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49403 }
49404 {
49405 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49406 }
49407 {
49408 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49409 }
49410 {
49411 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49412 }
49413 {
49414 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49415 }
49416 {
49417 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49418 }
49419 {
49420 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49421 }
49422 {
49423 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49424 }
49425 {
49426 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49427 }
49428 {
49429 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49430 }
49431 {
49432 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49433 }
49434 {
49435 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49436 }
49437 {
49438 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49439 }
49440 {
49441 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49442 }
49443 {
49444 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49445 }
49446 {
49447 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49448 }
49449 {
49450 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49451 }
49452 {
49453 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49454 }
49455 {
49456 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49457 }
49458 {
49459 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49460 }
49461 {
49462 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49463 }
49464 {
49465 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49466 }
49467 {
49468 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49469 }
49470 {
49471 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49472 }
49473 {
49474 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49475 }
49476 {
49477 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49478 }
49479 {
49480 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49481 }
49482 {
49483 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49484 }
49485 {
49486 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49487 }
49488 {
49489 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49490 }
49491 {
49492 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49493 }
49494 {
49495 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49496 }
49497 {
49498 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49499 }
49500 {
49501 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49502 }
49503 {
49504 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49505 }
49506 {
49507 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49508 }
49509 {
49510 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49511 }
49512 {
49513 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49514 }
49515 {
49516 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49517 }
49518 {
49519 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49520 }
49521 {
49522 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49523 }
49524 {
49525 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49526 }
49527 {
49528 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49529 }
49530 {
49531 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49532 }
49533 {
49534 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49535 }
49536 {
49537 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49538 }
49539 {
49540 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49541 }
49542 {
49543 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49544 }
49545 {
49546 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49547 }
49548 {
49549 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49550 }
49551 {
49552 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49553 }
49554 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49555 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49556 {
49557 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49558 }
49559 {
49560 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49561 }
49562 {
49563 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49564 }
49565
49566 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49567
49568
49569 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49570
49571 {
49572 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int((int)(wxIMAGE_ALPHA_TRANSPARENT)));
49573 }
49574 {
49575 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int((int)(wxIMAGE_ALPHA_THRESHOLD)));
49576 }
49577 {
49578 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int((int)(wxIMAGE_ALPHA_OPAQUE)));
49579 }
49580 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49581 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49582 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49583 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49584 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49585 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49586 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49587 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49588 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49589 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49590 {
49591 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49592 }
49593 {
49594 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49595 }
49596 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49597 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49598 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49599 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49600 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49601 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49602 {
49603 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49604 }
49605 {
49606 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49607 }
49608 {
49609 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49610 }
49611 {
49612 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49613 }
49614 {
49615 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49616 }
49617 {
49618 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49619 }
49620 {
49621 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49622 }
49623 {
49624 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49625 }
49626 {
49627 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49628 }
49629 {
49630 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49631 }
49632 {
49633 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49634 }
49635 {
49636 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49637 }
49638 {
49639 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49640 }
49641 {
49642 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49643 }
49644 {
49645 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49646 }
49647 {
49648 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49649 }
49650 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49651 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49652 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49653 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49654 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49655 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49656 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49657 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49658 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49659 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49660 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49661 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49662 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49663 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49664 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49665 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49666 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49667 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49668 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49669 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49670 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49671 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49672 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49673 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49674 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49675 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49676 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49677 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49678 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49679 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49680 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49681 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49682 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49683 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49684 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49685 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49686 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49687 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49688 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49689 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49690 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49691 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49692 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49693 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49694 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49695 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49696 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49697 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49698 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49699 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49700 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49701 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49702 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49703 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49704 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49705 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49706 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49707 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49708 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49709 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49710 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49711 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49712 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49713 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49714 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49715 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49716 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49717 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49718 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49719 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49720 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49721 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49722 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49723 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49724 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49725 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49726 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49727 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49728 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49729 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49730 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49731 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49732 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49733 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49734 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49735 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49736 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49737 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49738 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49739 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49740 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49741 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49742 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49743 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49744 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49745 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49746 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49747 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49748 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49749 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49750 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49751 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49752 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49753 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49754 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49755 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49756 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49757 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
49758 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49759 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49760 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49761 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49762 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49763 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49764 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49765 {
49766 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49767 }
49768 {
49769 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49770 }
49771 {
49772 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49773 }
49774 {
49775 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49776 }
49777 {
49778 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49779 }
49780 {
49781 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49782 }
49783 {
49784 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49785 }
49786 {
49787 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49788 }
49789 {
49790 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49791 }
49792 {
49793 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49794 }
49795 {
49796 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49797 }
49798 {
49799 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49800 }
49801 {
49802 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49803 }
49804 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49805 {
49806 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49807 }
49808 {
49809 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49810 }
49811 {
49812 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49813 }
49814 {
49815 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49816 }
49817 {
49818 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49819 }
49820 {
49821 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49822 }
49823 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49824 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49825 {
49826 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49827 }
49828 {
49829 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49830 }
49831 {
49832 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49833 }
49834 {
49835 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49836 }
49837 {
49838 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49839 }
49840 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49841 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49842 {
49843 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49844 }
49845 {
49846 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49847 }
49848 {
49849 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49850 }
49851 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49852 {
49853 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49854 }
49855 {
49856 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49857 }
49858 {
49859 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49860 }
49861 {
49862 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49863 }
49864 {
49865 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49866 }
49867 {
49868 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49869 }
49870 {
49871 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49872 }
49873 {
49874 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49875 }
49876 {
49877 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49878 }
49879 {
49880 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49881 }
49882 {
49883 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49884 }
49885 {
49886 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49887 }
49888 {
49889 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49890 }
49891 {
49892 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49893 }
49894 {
49895 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49896 }
49897 {
49898 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49899 }
49900 {
49901 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49902 }
49903 {
49904 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49905 }
49906 {
49907 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49908 }
49909
49910 // Initialize threading, some globals and such
49911 __wxPyPreStart(d);
49912
49913
49914 // Although these are defined in __version__ they need to be here too so
49915 // that an assert can be done to ensure that the wxPython and the wxWindows
49916 // versions match.
49917 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49918 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49919 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49920
49921 }
49922
wxWidgets (Impactor)