]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/gtk/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:


b1df9473770d87780386dee7474b1dfd103d3b55
[wxWidgets.git] / wxPython / src / gtk / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_wxMenu swig_types[14]
1356 #define SWIGTYPE_p_wxGridSizer swig_types[15]
1357 #define SWIGTYPE_p_wxFlexGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxInitDialogEvent swig_types[17]
1359 #define SWIGTYPE_p_wxItemContainer swig_types[18]
1360 #define SWIGTYPE_p_wxNcPaintEvent swig_types[19]
1361 #define SWIGTYPE_p_wxPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[21]
1363 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxControl swig_types[25]
1367 #define SWIGTYPE_p_wxFont swig_types[26]
1368 #define SWIGTYPE_p_wxMenuBarBase swig_types[27]
1369 #define SWIGTYPE_p_wxSetCursorEvent swig_types[28]
1370 #define SWIGTYPE_p_wxFSFile swig_types[29]
1371 #define SWIGTYPE_p_wxCaret swig_types[30]
1372 #define SWIGTYPE_ptrdiff_t swig_types[31]
1373 #define SWIGTYPE_std__ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_p_wxRegion swig_types[33]
1375 #define SWIGTYPE_p_wxPoint2D swig_types[34]
1376 #define SWIGTYPE_p_int swig_types[35]
1377 #define SWIGTYPE_p_wxSize swig_types[36]
1378 #define SWIGTYPE_p_wxDC swig_types[37]
1379 #define SWIGTYPE_p_wxPySizer swig_types[38]
1380 #define SWIGTYPE_p_wxVisualAttributes swig_types[39]
1381 #define SWIGTYPE_p_wxNotifyEvent swig_types[40]
1382 #define SWIGTYPE_p_wxPyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPropagationDisabler swig_types[42]
1384 #define SWIGTYPE_p_form_ops_t swig_types[43]
1385 #define SWIGTYPE_p_wxAppTraits swig_types[44]
1386 #define SWIGTYPE_p_wxArrayString swig_types[45]
1387 #define SWIGTYPE_p_wxShowEvent swig_types[46]
1388 #define SWIGTYPE_p_wxToolTip swig_types[47]
1389 #define SWIGTYPE_p_wxMoveEvent swig_types[48]
1390 #define SWIGTYPE_p_wxSizeEvent swig_types[49]
1391 #define SWIGTYPE_p_wxActivateEvent swig_types[50]
1392 #define SWIGTYPE_p_wxIconizeEvent swig_types[51]
1393 #define SWIGTYPE_p_wxMaximizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[53]
1395 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[54]
1396 #define SWIGTYPE_p_wxIdleEvent swig_types[55]
1397 #define SWIGTYPE_p_wxDateEvent swig_types[56]
1398 #define SWIGTYPE_p_wxMenuItem swig_types[57]
1399 #define SWIGTYPE_p_wxStaticBox swig_types[58]
1400 #define SWIGTYPE_p_long swig_types[59]
1401 #define SWIGTYPE_p_wxDuplexMode swig_types[60]
1402 #define SWIGTYPE_p_wxTIFFHandler swig_types[61]
1403 #define SWIGTYPE_p_wxXPMHandler swig_types[62]
1404 #define SWIGTYPE_p_wxPNMHandler swig_types[63]
1405 #define SWIGTYPE_p_wxJPEGHandler swig_types[64]
1406 #define SWIGTYPE_p_wxPCXHandler swig_types[65]
1407 #define SWIGTYPE_p_wxGIFHandler swig_types[66]
1408 #define SWIGTYPE_p_wxPNGHandler swig_types[67]
1409 #define SWIGTYPE_p_wxANIHandler swig_types[68]
1410 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[69]
1411 #define SWIGTYPE_p_wxZipFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxInternetFSHandler swig_types[71]
1413 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[72]
1414 #define SWIGTYPE_p_wxEvtHandler swig_types[73]
1415 #define SWIGTYPE_p_wxCURHandler swig_types[74]
1416 #define SWIGTYPE_p_wxICOHandler swig_types[75]
1417 #define SWIGTYPE_p_wxBMPHandler swig_types[76]
1418 #define SWIGTYPE_p_wxImageHandler swig_types[77]
1419 #define SWIGTYPE_p_wxFileSystemHandler swig_types[78]
1420 #define SWIGTYPE_p_wxRect swig_types[79]
1421 #define SWIGTYPE_p_wxButton swig_types[80]
1422 #define SWIGTYPE_p_wxGBSpan swig_types[81]
1423 #define SWIGTYPE_p_wxPropagateOnce swig_types[82]
1424 #define SWIGTYPE_p_wxAcceleratorTable swig_types[83]
1425 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[84]
1426 #define SWIGTYPE_p_char swig_types[85]
1427 #define SWIGTYPE_p_wxGBPosition swig_types[86]
1428 #define SWIGTYPE_p_wxImage swig_types[87]
1429 #define SWIGTYPE_p_wxFrame swig_types[88]
1430 #define SWIGTYPE_p_wxScrollWinEvent swig_types[89]
1431 #define SWIGTYPE_p_wxPaperSize swig_types[90]
1432 #define SWIGTYPE_p_wxImageHistogram swig_types[91]
1433 #define SWIGTYPE_p_wxPoint swig_types[92]
1434 #define SWIGTYPE_p_wxCursor swig_types[93]
1435 #define SWIGTYPE_p_wxObject swig_types[94]
1436 #define SWIGTYPE_p_wxInputStream swig_types[95]
1437 #define SWIGTYPE_p_wxOutputStream swig_types[96]
1438 #define SWIGTYPE_p_wxPyInputStream swig_types[97]
1439 #define SWIGTYPE_p_wxDateTime swig_types[98]
1440 #define SWIGTYPE_p_wxKeyEvent swig_types[99]
1441 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[100]
1442 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[101]
1443 #define SWIGTYPE_p_unsigned_long swig_types[102]
1444 #define SWIGTYPE_p_wxWindow swig_types[103]
1445 #define SWIGTYPE_p_wxMenuBar swig_types[104]
1446 #define SWIGTYPE_p_wxFileSystem swig_types[105]
1447 #define SWIGTYPE_p_wxBitmap swig_types[106]
1448 #define SWIGTYPE_unsigned_int swig_types[107]
1449 #define SWIGTYPE_p_unsigned_int swig_types[108]
1450 #define SWIGTYPE_p_wxMenuEvent swig_types[109]
1451 #define SWIGTYPE_p_wxContextMenuEvent swig_types[110]
1452 #define SWIGTYPE_p_unsigned_char swig_types[111]
1453 #define SWIGTYPE_p_wxEraseEvent swig_types[112]
1454 #define SWIGTYPE_p_wxMouseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxCloseEvent swig_types[114]
1456 #define SWIGTYPE_p_wxPyApp swig_types[115]
1457 #define SWIGTYPE_p_wxCommandEvent swig_types[116]
1458 #define SWIGTYPE_p_wxPyCommandEvent swig_types[117]
1459 #define SWIGTYPE_p_wxPyDropTarget swig_types[118]
1460 #define SWIGTYPE_p_wxQuantize swig_types[119]
1461 #define SWIGTYPE_p_wxChildFocusEvent swig_types[120]
1462 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1463 #define SWIGTYPE_p_wxDropFilesEvent swig_types[122]
1464 #define SWIGTYPE_p_wxControlWithItems swig_types[123]
1465 #define SWIGTYPE_p_wxColour swig_types[124]
1466 #define SWIGTYPE_p_wxValidator swig_types[125]
1467 #define SWIGTYPE_p_wxPyValidator swig_types[126]
1468 static swig_type_info *swig_types[128];
1469
1470 /* -------- TYPES TABLE (END) -------- */
1471
1472
1473 /*-----------------------------------------------
1474 @(target):= _core_.so
1475 ------------------------------------------------*/
1476 #define SWIG_init init_core_
1477
1478 #define SWIG_name "_core_"
1479
1480 #include "wx/wxPython/wxPython_int.h"
1481 #include "wx/wxPython/pyclasses.h"
1482
1483
1484 #ifndef wxPyUSE_EXPORT
1485 // Helper functions for dealing with SWIG objects and such. These are
1486 // located here so they know about the SWIG types and functions declared
1487 // in the wrapper code.
1488
1489 #include <wx/hashmap.h>
1490 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1491
1492
1493 // Maintains a hashmap of className to swig_type_info pointers. Given the
1494 // name of a class either looks up the type info in the cache, or scans the
1495 // SWIG tables for it.
1496 extern PyObject* wxPyPtrTypeMap;
1497 static
1498 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1499
1500 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1501
1502 if (typeInfoCache == NULL)
1503 typeInfoCache = new wxPyTypeInfoHashMap;
1504
1505 wxString name(className);
1506 swig_type_info* swigType = (*typeInfoCache)[name];
1507
1508 if (! swigType) {
1509 // it wasn't in the cache, so look it up from SWIG
1510 name.Append(wxT(" *"));
1511 swigType = SWIG_TypeQuery(name.mb_str());
1512
1513 // if it still wasn't found, try looking for a mapped name
1514 if (!swigType) {
1515 PyObject* item;
1516 name = className;
1517
1518 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1519 (char*)(const char*)name.mbc_str())) != NULL) {
1520 name = wxString(PyString_AsString(item), *wxConvCurrent);
1521 name.Append(wxT(" *"));
1522 swigType = SWIG_TypeQuery(name.mb_str());
1523 }
1524 }
1525 if (swigType) {
1526 // and add it to the map if found
1527 (*typeInfoCache)[className] = swigType;
1528 }
1529 }
1530 return swigType;
1531 }
1532
1533
1534 // Check if a class name is a type known to SWIG
1535 bool wxPyCheckSwigType(const wxChar* className) {
1536
1537 swig_type_info* swigType = wxPyFindSwigType(className);
1538 return swigType != NULL;
1539 }
1540
1541
1542 // Given a pointer to a C++ object and a class name, construct a Python proxy
1543 // object for it.
1544 PyObject* wxPyConstructObject(void* ptr,
1545 const wxChar* className,
1546 int setThisOwn) {
1547
1548 swig_type_info* swigType = wxPyFindSwigType(className);
1549 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1550
1551 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1552 }
1553
1554
1555 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1556 // Ensures that the proxy object is of the specified (or derived) type. If
1557 // not able to perform the conversion then a Python exception is set and the
1558 // error should be handled properly in the caller. Returns True on success.
1559 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1560 const wxChar* className) {
1561
1562 swig_type_info* swigType = wxPyFindSwigType(className);
1563 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1564
1565 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1566 }
1567
1568
1569 // Make a SWIGified pointer object suitable for a .this attribute
1570 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1571
1572 PyObject* robj = NULL;
1573
1574 swig_type_info* swigType = wxPyFindSwigType(className);
1575 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1576
1577 #ifdef SWIG_COBJECT_TYPES
1578 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1579 #else
1580 {
1581 char result[1024];
1582 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1583 PyString_FromString(result) : 0;
1584 }
1585 #endif
1586
1587 return robj;
1588 }
1589
1590
1591
1592
1593 // Export a C API in a struct. Other modules will be able to load this from
1594 // the wx._core_ module and will then have safe access to these functions,
1595 // even if they are located in another shared library.
1596 static wxPyCoreAPI API = {
1597
1598 wxPyCheckSwigType,
1599 wxPyConstructObject,
1600 wxPyConvertSwigPtr,
1601 wxPyMakeSwigPtr,
1602
1603 wxPyBeginAllowThreads,
1604 wxPyEndAllowThreads,
1605 wxPyBeginBlockThreads,
1606 wxPyEndBlockThreads,
1607
1608 wxPy_ConvertList,
1609
1610 wxString_in_helper,
1611 Py2wxString,
1612 wx2PyString,
1613
1614 byte_LIST_helper,
1615 int_LIST_helper,
1616 long_LIST_helper,
1617 string_LIST_helper,
1618 wxPoint_LIST_helper,
1619 wxBitmap_LIST_helper,
1620 wxString_LIST_helper,
1621 wxAcceleratorEntry_LIST_helper,
1622
1623 wxSize_helper,
1624 wxPoint_helper,
1625 wxRealPoint_helper,
1626 wxRect_helper,
1627 wxColour_helper,
1628 wxPoint2D_helper,
1629
1630 wxPySimple_typecheck,
1631 wxColour_typecheck,
1632
1633 wxPyCBH_setCallbackInfo,
1634 wxPyCBH_findCallback,
1635 wxPyCBH_callCallback,
1636 wxPyCBH_callCallbackObj,
1637 wxPyCBH_delete,
1638
1639 wxPyMake_wxObject,
1640 wxPyMake_wxSizer,
1641 wxPyPtrTypeMap_Add,
1642 wxPy2int_seq_helper,
1643 wxPy4int_seq_helper,
1644 wxArrayString2PyList_helper,
1645 wxArrayInt2PyList_helper,
1646
1647 wxPyClientData_dtor,
1648 wxPyUserData_dtor,
1649 wxPyOORClientData_dtor,
1650
1651 wxPyCBInputStream_create,
1652
1653 wxPyInstance_Check,
1654 wxPySwigInstance_Check,
1655
1656 wxPyCheckForApp
1657
1658 };
1659
1660 #endif
1661
1662
1663 #if !WXWIN_COMPATIBILITY_2_4
1664 #define wxHIDE_READONLY 0
1665 #endif
1666
1667
1668 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1669 #define SWIG_From_int PyInt_FromLong
1670 /*@@*/
1671
1672
1673 #if ! wxUSE_HOTKEY
1674 enum wxHotkeyModifier
1675 {
1676 wxMOD_NONE = 0,
1677 wxMOD_ALT = 1,
1678 wxMOD_CONTROL = 2,
1679 wxMOD_SHIFT = 4,
1680 wxMOD_WIN = 8
1681 };
1682 #define wxEVT_HOTKEY 9999
1683 #endif
1684
1685 static const wxString wxPyEmptyString(wxEmptyString);
1686 static wxString wxObject_GetClassName(wxObject *self){
1687 return self->GetClassInfo()->GetClassName();
1688 }
1689 static void wxObject_Destroy(wxObject *self){
1690 delete self;
1691 }
1692
1693 #ifndef __WXMAC__
1694 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1695 #endif
1696
1697
1698 #include <limits.h>
1699
1700
1701 SWIGINTERN int
1702 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1703 const char *errmsg)
1704 {
1705 if (value < min_value) {
1706 if (errmsg) {
1707 PyErr_Format(PyExc_OverflowError,
1708 "value %ld is less than '%s' minimum %ld",
1709 value, errmsg, min_value);
1710 }
1711 return 0;
1712 } else if (value > max_value) {
1713 if (errmsg) {
1714 PyErr_Format(PyExc_OverflowError,
1715 "value %ld is greater than '%s' maximum %ld",
1716 value, errmsg, max_value);
1717 }
1718 return 0;
1719 }
1720 return 1;
1721 }
1722
1723
1724 SWIGINTERN int
1725 SWIG_AsVal_long(PyObject* obj, long* val)
1726 {
1727 if (PyNumber_Check(obj)) {
1728 if (val) *val = PyInt_AsLong(obj);
1729 return 1;
1730 }
1731 else {
1732 SWIG_type_error("number", obj);
1733 }
1734 return 0;
1735 }
1736
1737
1738 #if INT_MAX != LONG_MAX
1739 SWIGINTERN int
1740 SWIG_AsVal_int(PyObject *obj, int *val)
1741 {
1742 const char* errmsg = val ? "int" : (char*)0;
1743 long v;
1744 if (SWIG_AsVal_long(obj, &v)) {
1745 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1746 if (val) *val = (int)(v);
1747 return 1;
1748 } else {
1749 return 0;
1750 }
1751 } else {
1752 PyErr_Clear();
1753 }
1754 if (val) {
1755 SWIG_type_error(errmsg, obj);
1756 }
1757 return 0;
1758 }
1759 #else
1760 SWIGINTERNSHORT int
1761 SWIG_AsVal_int(PyObject *obj, int *val)
1762 {
1763 return SWIG_AsVal_long(obj,(long*)val);
1764 }
1765 #endif
1766
1767
1768 SWIGINTERNSHORT int
1769 SWIG_As_int(PyObject* obj)
1770 {
1771 int v;
1772 if (!SWIG_AsVal_int(obj, &v)) {
1773 /*
1774 this is needed to make valgrind/purify happier.
1775 */
1776 memset((void*)&v, 0, sizeof(int));
1777 }
1778 return v;
1779 }
1780
1781
1782 SWIGINTERNSHORT int
1783 SWIG_Check_int(PyObject* obj)
1784 {
1785 return SWIG_AsVal_int(obj, (int*)0);
1786 }
1787
1788 static PyObject *wxSize_Get(wxSize *self){
1789 bool blocked = wxPyBeginBlockThreads();
1790 PyObject* tup = PyTuple_New(2);
1791 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1792 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1793 wxPyEndBlockThreads(blocked);
1794 return tup;
1795 }
1796
1797 SWIGINTERN int
1798 SWIG_AsVal_double(PyObject *obj, double* val)
1799 {
1800 if (PyNumber_Check(obj)) {
1801 if (val) *val = PyFloat_AsDouble(obj);
1802 return 1;
1803 }
1804 else {
1805 SWIG_type_error("number", obj);
1806 }
1807 return 0;
1808 }
1809
1810
1811 SWIGINTERNSHORT double
1812 SWIG_As_double(PyObject* obj)
1813 {
1814 double v;
1815 if (!SWIG_AsVal_double(obj, &v)) {
1816 /*
1817 this is needed to make valgrind/purify happier.
1818 */
1819 memset((void*)&v, 0, sizeof(double));
1820 }
1821 return v;
1822 }
1823
1824
1825 SWIGINTERNSHORT int
1826 SWIG_Check_double(PyObject* obj)
1827 {
1828 return SWIG_AsVal_double(obj, (double*)0);
1829 }
1830
1831
1832 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1833 #define SWIG_From_double PyFloat_FromDouble
1834 /*@@*/
1835
1836 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1837 self->x = x;
1838 self->y = y;
1839 }
1840 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1841 bool blocked = wxPyBeginBlockThreads();
1842 PyObject* tup = PyTuple_New(2);
1843 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1844 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1845 wxPyEndBlockThreads(blocked);
1846 return tup;
1847 }
1848
1849 SWIGINTERNSHORT long
1850 SWIG_As_long(PyObject* obj)
1851 {
1852 long v;
1853 if (!SWIG_AsVal_long(obj, &v)) {
1854 /*
1855 this is needed to make valgrind/purify happier.
1856 */
1857 memset((void*)&v, 0, sizeof(long));
1858 }
1859 return v;
1860 }
1861
1862
1863 SWIGINTERNSHORT int
1864 SWIG_Check_long(PyObject* obj)
1865 {
1866 return SWIG_AsVal_long(obj, (long*)0);
1867 }
1868
1869 static void wxPoint_Set(wxPoint *self,long x,long y){
1870 self->x = x;
1871 self->y = y;
1872 }
1873 static PyObject *wxPoint_Get(wxPoint *self){
1874 bool blocked = wxPyBeginBlockThreads();
1875 PyObject* tup = PyTuple_New(2);
1876 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1877 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1878 wxPyEndBlockThreads(blocked);
1879 return tup;
1880 }
1881 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1882 self->x = x;
1883 self->y = y;
1884 self->width = width;
1885 self->height = height;
1886 }
1887 static PyObject *wxRect_Get(wxRect *self){
1888 bool blocked = wxPyBeginBlockThreads();
1889 PyObject* tup = PyTuple_New(4);
1890 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1891 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1892 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1893 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1894 wxPyEndBlockThreads(blocked);
1895 return tup;
1896 }
1897
1898 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1899 wxRegion reg1(*r1);
1900 wxRegion reg2(*r2);
1901 wxRect dest(0,0,0,0);
1902 PyObject* obj;
1903
1904 reg1.Intersect(reg2);
1905 dest = reg1.GetBox();
1906
1907 if (dest != wxRect(0,0,0,0)) {
1908 bool blocked = wxPyBeginBlockThreads();
1909 wxRect* newRect = new wxRect(dest);
1910 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1911 wxPyEndBlockThreads(blocked);
1912 return obj;
1913 }
1914 Py_INCREF(Py_None);
1915 return Py_None;
1916 }
1917
1918
1919 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1920 PyObject* o2;
1921 PyObject* o3;
1922
1923 if (!target) {
1924 target = o;
1925 } else if (target == Py_None) {
1926 Py_DECREF(Py_None);
1927 target = o;
1928 } else {
1929 if (!PyTuple_Check(target)) {
1930 o2 = target;
1931 target = PyTuple_New(1);
1932 PyTuple_SetItem(target, 0, o2);
1933 }
1934 o3 = PyTuple_New(1);
1935 PyTuple_SetItem(o3, 0, o);
1936
1937 o2 = target;
1938 target = PySequence_Concat(o2, o3);
1939 Py_DECREF(o2);
1940 Py_DECREF(o3);
1941 }
1942 return target;
1943 }
1944
1945
1946 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1947 self->m_x = x;
1948 self->m_y = y;
1949 }
1950 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1951 bool blocked = wxPyBeginBlockThreads();
1952 PyObject* tup = PyTuple_New(2);
1953 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1954 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1955 wxPyEndBlockThreads(blocked);
1956 return tup;
1957 }
1958
1959 #include "wx/wxPython/pyistream.h"
1960
1961 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1962 wxInputStream* wxis = wxPyCBInputStream::create(p);
1963 if (wxis)
1964 return new wxPyInputStream(wxis);
1965 else
1966 return NULL;
1967 }
1968
1969 SWIGINTERNSHORT PyObject*
1970 SWIG_From_char(char c)
1971 {
1972 return PyString_FromStringAndSize(&c,1);
1973 }
1974
1975
1976 SWIGINTERNSHORT PyObject*
1977 SWIG_From_unsigned_SS_long(unsigned long value)
1978 {
1979 return (value > LONG_MAX) ?
1980 PyLong_FromUnsignedLong(value)
1981 : PyInt_FromLong((long)(value));
1982 }
1983
1984
1985 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1986 SWIGINTERN int
1987 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1988 {
1989 static swig_type_info* pchar_info = 0;
1990 char* vptr = 0;
1991 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1992 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1993 if (cptr) *cptr = vptr;
1994 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1995 return SWIG_OLDOBJ;
1996 } else {
1997 PyErr_Clear();
1998 if (PyString_Check(obj)) {
1999 if (cptr) {
2000 *cptr = PyString_AS_STRING(obj);
2001 if (psize) {
2002 *psize = PyString_GET_SIZE(obj) + 1;
2003 }
2004 }
2005 return SWIG_PYSTR;
2006 }
2007 }
2008 if (cptr) {
2009 SWIG_type_error("char *", obj);
2010 }
2011 return 0;
2012 }
2013
2014
2015 SWIGINTERN int
2016 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2017 {
2018 char* cptr; size_t csize;
2019 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2020 /* in C you can do:
2021
2022 char x[5] = "hello";
2023
2024 ie, assing the array using an extra '0' char.
2025 */
2026 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2027 if (csize <= size) {
2028 if (val) {
2029 if (csize) memcpy(val, cptr, csize);
2030 if (csize < size) memset(val + csize, 0, size - csize);
2031 }
2032 return 1;
2033 }
2034 }
2035 if (val) {
2036 PyErr_Format(PyExc_TypeError,
2037 "a char array of maximum size %lu is expected",
2038 (unsigned long) size);
2039 }
2040 return 0;
2041 }
2042
2043
2044 SWIGINTERN int
2045 SWIG_AsVal_char(PyObject *obj, char *val)
2046 {
2047 const char* errmsg = val ? "char" : (char*)0;
2048 long v;
2049 if (SWIG_AsVal_long(obj, &v)) {
2050 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2051 if (val) *val = (char)(v);
2052 return 1;
2053 } else {
2054 return 0;
2055 }
2056 } else {
2057 PyErr_Clear();
2058 return SWIG_AsCharArray(obj, val, 1);
2059 }
2060 }
2061
2062
2063 SWIGINTERNSHORT char
2064 SWIG_As_char(PyObject* obj)
2065 {
2066 char v;
2067 if (!SWIG_AsVal_char(obj, &v)) {
2068 /*
2069 this is needed to make valgrind/purify happier.
2070 */
2071 memset((void*)&v, 0, sizeof(char));
2072 }
2073 return v;
2074 }
2075
2076
2077 SWIGINTERNSHORT int
2078 SWIG_Check_char(PyObject* obj)
2079 {
2080 return SWIG_AsVal_char(obj, (char*)0);
2081 }
2082
2083
2084 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2085 #define SWIG_From_long PyInt_FromLong
2086 /*@@*/
2087
2088 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2089 // We use only strings for the streams, not unicode
2090 PyObject* str = PyObject_Str(obj);
2091 if (! str) {
2092 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2093 return;
2094 }
2095 self->Write(PyString_AS_STRING(str),
2096 PyString_GET_SIZE(str));
2097 Py_DECREF(str);
2098 }
2099
2100 #include "wx/wxPython/pyistream.h"
2101
2102
2103 class wxPyFileSystemHandler : public wxFileSystemHandler
2104 {
2105 public:
2106 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2107
2108 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2109 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2110 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2111 DEC_PYCALLBACK_STRING__pure(FindNext);
2112
2113 wxString GetProtocol(const wxString& location) {
2114 return wxFileSystemHandler::GetProtocol(location);
2115 }
2116
2117 wxString GetLeftLocation(const wxString& location) {
2118 return wxFileSystemHandler::GetLeftLocation(location);
2119 }
2120
2121 wxString GetAnchor(const wxString& location) {
2122 return wxFileSystemHandler::GetAnchor(location);
2123 }
2124
2125 wxString GetRightLocation(const wxString& location) {
2126 return wxFileSystemHandler::GetRightLocation(location);
2127 }
2128
2129 wxString GetMimeTypeFromExt(const wxString& location) {
2130 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2131 }
2132
2133 PYPRIVATE;
2134 };
2135
2136
2137 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2138 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2139 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2140 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2141
2142
2143 SWIGINTERN int
2144 SWIG_AsVal_bool(PyObject *obj, bool *val)
2145 {
2146 if (obj == Py_True) {
2147 if (val) *val = true;
2148 return 1;
2149 }
2150 if (obj == Py_False) {
2151 if (val) *val = false;
2152 return 1;
2153 }
2154 int res = 0;
2155 if (SWIG_AsVal_int(obj, &res)) {
2156 if (val) *val = res ? true : false;
2157 return 1;
2158 } else {
2159 PyErr_Clear();
2160 }
2161 if (val) {
2162 SWIG_type_error("bool", obj);
2163 }
2164 return 0;
2165 }
2166
2167
2168 SWIGINTERNSHORT bool
2169 SWIG_As_bool(PyObject* obj)
2170 {
2171 bool v;
2172 if (!SWIG_AsVal_bool(obj, &v)) {
2173 /*
2174 this is needed to make valgrind/purify happier.
2175 */
2176 memset((void*)&v, 0, sizeof(bool));
2177 }
2178 return v;
2179 }
2180
2181
2182 SWIGINTERNSHORT int
2183 SWIG_Check_bool(PyObject* obj)
2184 {
2185 return SWIG_AsVal_bool(obj, (bool*)0);
2186 }
2187
2188 static wxString FileSystem_URLToFileName(wxString const &url){
2189 wxFileName fname = wxFileSystem::URLToFileName(url);
2190 return fname.GetFullPath();
2191 }
2192
2193 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2194 wxImage& image,
2195 long type) {
2196 wxMemoryFSHandler::AddFile(filename, image, type);
2197 }
2198
2199 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2200 const wxBitmap& bitmap,
2201 long type) {
2202 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2203 }
2204
2205 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2206 PyObject* data) {
2207 if (! PyString_Check(data)) {
2208 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2209 "Expected string object"));
2210 return;
2211 }
2212
2213 bool blocked = wxPyBeginBlockThreads();
2214 void* ptr = (void*)PyString_AsString(data);
2215 size_t size = PyString_Size(data);
2216 wxPyEndBlockThreads(blocked);
2217
2218 wxMemoryFSHandler::AddFile(filename, ptr, size);
2219 }
2220
2221
2222 #include "wx/wxPython/pyistream.h"
2223
2224
2225 SWIGINTERN int
2226 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2227 {
2228 long v = 0;
2229 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2230 SWIG_type_error("unsigned number", obj);
2231 }
2232 else if (val)
2233 *val = (unsigned long)v;
2234 return 1;
2235 }
2236
2237
2238 SWIGINTERNSHORT int
2239 SWIG_CheckUnsignedLongInRange(unsigned long value,
2240 unsigned long max_value,
2241 const char *errmsg)
2242 {
2243 if (value > max_value) {
2244 if (errmsg) {
2245 PyErr_Format(PyExc_OverflowError,
2246 "value %lu is greater than '%s' minimum %lu",
2247 value, errmsg, max_value);
2248 }
2249 return 0;
2250 }
2251 return 1;
2252 }
2253
2254
2255 SWIGINTERN int
2256 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2257 {
2258 const char* errmsg = val ? "unsigned char" : (char*)0;
2259 unsigned long v;
2260 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2261 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2262 if (val) *val = (unsigned char)(v);
2263 return 1;
2264 } else {
2265 return 0;
2266 }
2267 } else {
2268 PyErr_Clear();
2269 }
2270 if (val) {
2271 SWIG_type_error(errmsg, obj);
2272 }
2273 return 0;
2274 }
2275
2276
2277 SWIGINTERNSHORT unsigned char
2278 SWIG_As_unsigned_SS_char(PyObject* obj)
2279 {
2280 unsigned char v;
2281 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2282 /*
2283 this is needed to make valgrind/purify happier.
2284 */
2285 memset((void*)&v, 0, sizeof(unsigned char));
2286 }
2287 return v;
2288 }
2289
2290
2291 SWIGINTERNSHORT int
2292 SWIG_Check_unsigned_SS_char(PyObject* obj)
2293 {
2294 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2295 }
2296
2297
2298 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2299 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2300 /*@@*/
2301
2302
2303 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2304 if (width > 0 && height > 0)
2305 return new wxImage(width, height, clear);
2306 else
2307 return new wxImage;
2308 }
2309 static wxImage *new_wxImage(wxBitmap const &bitmap){
2310 return new wxImage(bitmap.ConvertToImage());
2311 }
2312 static wxImage *new_wxImage(int width,int height,unsigned char *data){
2313 // Copy the source data so the wxImage can clean it up later
2314 unsigned char* copy = (unsigned char*)malloc(width*height*3);
2315 if (copy == NULL) {
2316 PyErr_NoMemory();
2317 return NULL;
2318 }
2319 memcpy(copy, data, width*height*3);
2320 return new wxImage(width, height, copy, false);
2321 }
2322 static wxImage *new_wxImage(int width,int height,unsigned char *data,unsigned char *alpha){
2323 // Copy the source data so the wxImage can clean it up later
2324 unsigned char* dcopy = (unsigned char*)malloc(width*height*3);
2325 if (dcopy == NULL) {
2326 PyErr_NoMemory();
2327 return NULL;
2328 }
2329 memcpy(dcopy, data, width*height*3);
2330 unsigned char* acopy = (unsigned char*)malloc(width*height);
2331 if (acopy == NULL) {
2332 PyErr_NoMemory();
2333 return NULL;
2334 }
2335 memcpy(acopy, alpha, width*height);
2336
2337 return new wxImage(width, height, dcopy, acopy, false);
2338 }
2339 static wxSize wxImage_GetSize(wxImage *self){
2340 wxSize size(self->GetWidth(), self->GetHeight());
2341 return size;
2342 }
2343 static PyObject *wxImage_GetData(wxImage *self){
2344 unsigned char* data = self->GetData();
2345 int len = self->GetWidth() * self->GetHeight() * 3;
2346 PyObject* rv;
2347 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2348 return rv;
2349 }
2350 static void wxImage_SetData(wxImage *self,PyObject *data){
2351 unsigned char* dataPtr;
2352
2353 if (! PyString_Check(data)) {
2354 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2355 "Expected string object"));
2356 return /* NULL */ ;
2357 }
2358
2359 size_t len = self->GetWidth() * self->GetHeight() * 3;
2360 dataPtr = (unsigned char*) malloc(len);
2361 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2362 self->SetData(dataPtr);
2363 // wxImage takes ownership of dataPtr...
2364 }
2365 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2366 unsigned char* data = self->GetData();
2367 int len = self->GetWidth() * self->GetHeight() * 3;
2368 PyObject* rv;
2369 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2370 return rv;
2371 }
2372 static void wxImage_SetDataBuffer(wxImage *self,PyObject *data){
2373 unsigned char* buffer;
2374 int size;
2375
2376 bool blocked = wxPyBeginBlockThreads();
2377 if (!PyArg_Parse(data, "t#", &buffer, &size))
2378 goto done;
2379
2380 if (size != self->GetWidth() * self->GetHeight() * 3) {
2381 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2382 goto done;
2383 }
2384 self->SetData(buffer);
2385 done:
2386 wxPyEndBlockThreads(blocked);
2387 }
2388 static PyObject *wxImage_GetAlphaData(wxImage *self){
2389 unsigned char* data = self->GetAlpha();
2390 if (! data) {
2391 RETURN_NONE();
2392 } else {
2393 int len = self->GetWidth() * self->GetHeight();
2394 PyObject* rv;
2395 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2396 return rv;
2397 }
2398 }
2399 static void wxImage_SetAlphaData(wxImage *self,PyObject *data){
2400 unsigned char* dataPtr;
2401
2402 if (! PyString_Check(data)) {
2403 PyErr_SetString(PyExc_TypeError, "Expected string object");
2404 return /* NULL */ ;
2405 }
2406
2407 size_t len = self->GetWidth() * self->GetHeight();
2408 dataPtr = (unsigned char*) malloc(len);
2409 wxPyBLOCK_THREADS( memcpy(dataPtr, PyString_AsString(data), len) );
2410 self->SetAlpha(dataPtr);
2411 // wxImage takes ownership of dataPtr...
2412 }
2413 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2414 unsigned char* data = self->GetAlpha();
2415 int len = self->GetWidth() * self->GetHeight();
2416 PyObject* rv;
2417 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2418 return rv;
2419 }
2420 static void wxImage_SetAlphaBuffer(wxImage *self,PyObject *data){
2421 unsigned char* buffer;
2422 int size;
2423
2424 bool blocked = wxPyBeginBlockThreads();
2425 if (!PyArg_Parse(data, "t#", &buffer, &size))
2426 goto done;
2427
2428 if (size != self->GetWidth() * self->GetHeight()) {
2429 PyErr_SetString(PyExc_TypeError, "Incorrect buffer size");
2430 goto done;
2431 }
2432 self->SetAlpha(buffer);
2433 done:
2434 wxPyEndBlockThreads(blocked);
2435 }
2436
2437 SWIGINTERNSHORT unsigned long
2438 SWIG_As_unsigned_SS_long(PyObject* obj)
2439 {
2440 unsigned long v;
2441 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2442 /*
2443 this is needed to make valgrind/purify happier.
2444 */
2445 memset((void*)&v, 0, sizeof(unsigned long));
2446 }
2447 return v;
2448 }
2449
2450
2451 SWIGINTERNSHORT int
2452 SWIG_Check_unsigned_SS_long(PyObject* obj)
2453 {
2454 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2455 }
2456
2457 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2458 wxBitmap bitmap(*self, depth);
2459 return bitmap;
2460 }
2461 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2462 wxImage mono = self->ConvertToMono( red, green, blue );
2463 wxBitmap bitmap( mono, 1 );
2464 return bitmap;
2465 }
2466 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2467 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2468 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2469 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2470 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2471 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2472 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2473 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2474 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2475 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2476 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2477 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2478
2479 #include <wx/quantize.h>
2480
2481 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2482 return wxQuantize::Quantize(src, dest,
2483 //NULL, // palette
2484 desiredNoColours,
2485 NULL, // eightBitData
2486 flags);
2487 }
2488 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2489 if (PyCallable_Check(func)) {
2490 self->Connect(id, lastId, eventType,
2491 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2492 new wxPyCallback(func));
2493 }
2494 else if (func == Py_None) {
2495 self->Disconnect(id, lastId, eventType,
2496 (wxObjectEventFunction)
2497 &wxPyCallback::EventThunker);
2498 }
2499 else {
2500 wxPyBLOCK_THREADS(
2501 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2502 }
2503 }
2504 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2505 return self->Disconnect(id, lastId, eventType,
2506 (wxObjectEventFunction)
2507 &wxPyCallback::EventThunker);
2508 }
2509 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2510 if (_self && _self != Py_None) {
2511 self->SetClientObject(new wxPyOORClientData(_self, incref));
2512 }
2513 else {
2514 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2515 if (data) {
2516 self->SetClientObject(NULL); // This will delete it too
2517 }
2518 }
2519 }
2520
2521 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2522 #if wxUSE_UNICODE
2523 return self->GetUnicodeKey();
2524 #else
2525 return 0;
2526 #endif
2527 }
2528
2529 #if UINT_MAX < LONG_MAX
2530 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2531 #define SWIG_From_unsigned_SS_int SWIG_From_long
2532 /*@@*/
2533 #else
2534 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2535 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2536 /*@@*/
2537 #endif
2538
2539
2540 #if UINT_MAX != ULONG_MAX
2541 SWIGINTERN int
2542 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2543 {
2544 const char* errmsg = val ? "unsigned int" : (char*)0;
2545 unsigned long v;
2546 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2547 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2548 if (val) *val = (unsigned int)(v);
2549 return 1;
2550 }
2551 } else {
2552 PyErr_Clear();
2553 }
2554 if (val) {
2555 SWIG_type_error(errmsg, obj);
2556 }
2557 return 0;
2558 }
2559 #else
2560 SWIGINTERNSHORT unsigned int
2561 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2562 {
2563 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2564 }
2565 #endif
2566
2567
2568 SWIGINTERNSHORT unsigned int
2569 SWIG_As_unsigned_SS_int(PyObject* obj)
2570 {
2571 unsigned int v;
2572 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2573 /*
2574 this is needed to make valgrind/purify happier.
2575 */
2576 memset((void*)&v, 0, sizeof(unsigned int));
2577 }
2578 return v;
2579 }
2580
2581
2582 SWIGINTERNSHORT int
2583 SWIG_Check_unsigned_SS_int(PyObject* obj)
2584 {
2585 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2586 }
2587
2588 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2589 self->m_size = size;
2590 }
2591 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2592 int count = self->GetNumberOfFiles();
2593 wxString* files = self->GetFiles();
2594 PyObject* list = PyList_New(count);
2595
2596 if (!list) {
2597 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2598 return NULL;
2599 }
2600
2601 for (int i=0; i<count; i++) {
2602 PyList_SetItem(list, i, wx2PyString(files[i]));
2603 }
2604 return list;
2605 }
2606
2607
2608 static wxPyApp *new_wxPyApp(){
2609 wxPythonApp = new wxPyApp();
2610 return wxPythonApp;
2611 }
2612 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2613
2614 void wxApp_CleanUp() {
2615 __wxPyCleanup();
2616 }
2617
2618
2619 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2620
2621
2622 SWIGINTERNSHORT int
2623 SWIG_AsCharPtr(PyObject *obj, char **val)
2624 {
2625 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2626 return 1;
2627 }
2628 if (val) {
2629 PyErr_Clear();
2630 SWIG_type_error("char *", obj);
2631 }
2632 return 0;
2633 }
2634
2635
2636 SWIGINTERN PyObject *
2637 SWIG_FromCharPtr(const char* cptr)
2638 {
2639 if (cptr) {
2640 size_t size = strlen(cptr);
2641 if (size > INT_MAX) {
2642 return SWIG_NewPointerObj((char*)(cptr),
2643 SWIG_TypeQuery("char *"), 0);
2644 } else {
2645 if (size != 0) {
2646 return PyString_FromStringAndSize(cptr, size);
2647 } else {
2648 return PyString_FromString(cptr);
2649 }
2650 }
2651 }
2652 Py_INCREF(Py_None);
2653 return Py_None;
2654 }
2655
2656
2657 #ifdef __WXMAC__
2658
2659 // A dummy class that raises an exception if used...
2660 class wxEventLoop
2661 {
2662 public:
2663 wxEventLoop() { wxPyRaiseNotImplemented(); }
2664 int Run() { return 0; }
2665 void Exit(int rc = 0) {}
2666 bool Pending() const { return false; }
2667 bool Dispatch() { return false; }
2668 bool IsRunning() const { return false; }
2669 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2670 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2671 };
2672
2673 #else
2674
2675 #include <wx/evtloop.h>
2676
2677 #endif
2678
2679
2680
2681 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2682 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2683 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2684 static PyObject *wxWindow_GetChildren(wxWindow *self){
2685 wxWindowList& list = self->GetChildren();
2686 return wxPy_ConvertList(&list);
2687 }
2688 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2689 #if wxUSE_HOTKEY
2690 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2691 #else
2692 return false;
2693 #endif
2694 }
2695 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2696
2697
2698
2699 return false;
2700
2701 }
2702 static long wxWindow_GetHandle(wxWindow *self){
2703 return wxPyGetWinHandle(self);
2704 }
2705 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2706 self->AssociateHandle((WXWidget)handle);
2707 }
2708
2709 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2710 return wxWindow::FindWindowById(id, parent);
2711 }
2712
2713 wxWindow* wxFindWindowByName( const wxString& name,
2714 const wxWindow *parent = NULL ) {
2715 return wxWindow::FindWindowByName(name, parent);
2716 }
2717
2718 wxWindow* wxFindWindowByLabel( const wxString& label,
2719 const wxWindow *parent = NULL ) {
2720 return wxWindow::FindWindowByLabel(label, parent);
2721 }
2722
2723
2724 #ifdef __WXMSW__
2725 #include <wx/msw/private.h> // to get wxGetWindowId
2726 #endif
2727
2728
2729 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2730 #ifdef __WXMSW__
2731 WXHWND hWnd = (WXHWND)_hWnd;
2732 long id = wxGetWindowId(hWnd);
2733 wxWindow* win = new wxWindow;
2734 parent->AddChild(win);
2735 win->SetEventHandler(win);
2736 win->SetHWND(hWnd);
2737 win->SetId(id);
2738 win->SubclassWin(hWnd);
2739 win->AdoptAttributesFromHWND();
2740 win->SetupColours();
2741 return win;
2742 #else
2743 wxPyRaiseNotImplemented();
2744 return NULL;
2745 #endif
2746 }
2747
2748
2749 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2750 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2751 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2752
2753 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2754
2755 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2756 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2757 wxMenuItemList& list = self->GetMenuItems();
2758 return wxPy_ConvertList(&list);
2759 }
2760 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2761 static const wxString wxPyControlNameStr(wxControlNameStr);
2762 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2763 if (clientData) {
2764 wxPyClientData* data = new wxPyClientData(clientData);
2765 return self->Append(item, data);
2766 } else
2767 return self->Append(item);
2768 }
2769 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2770 if (clientData) {
2771 wxPyClientData* data = new wxPyClientData(clientData);
2772 return self->Insert(item, pos, data);
2773 } else
2774 return self->Insert(item, pos);
2775 }
2776 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2777 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2778 if (data) {
2779 Py_INCREF(data->m_obj);
2780 return data->m_obj;
2781 } else {
2782 Py_INCREF(Py_None);
2783 return Py_None;
2784 }
2785 }
2786 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2787 wxPyClientData* data = new wxPyClientData(clientData);
2788 self->SetClientObject(n, data);
2789 }
2790
2791
2792 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2793 wxPyUserData* data = NULL;
2794 if ( userData ) {
2795 bool blocked = wxPyBeginBlockThreads();
2796 data = new wxPyUserData(userData);
2797 wxPyEndBlockThreads(blocked);
2798 }
2799 return new wxSizerItem(window, proportion, flag, border, data);
2800 }
2801 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2802 wxPyUserData* data = NULL;
2803 if ( userData ) {
2804 bool blocked = wxPyBeginBlockThreads();
2805 data = new wxPyUserData(userData);
2806 wxPyEndBlockThreads(blocked);
2807 }
2808 return new wxSizerItem(width, height, proportion, flag, border, data);
2809 }
2810 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2811 wxPyUserData* data = NULL;
2812 if ( userData ) {
2813 bool blocked = wxPyBeginBlockThreads();
2814 data = new wxPyUserData(userData);
2815 wxPyEndBlockThreads(blocked);
2816 }
2817 return new wxSizerItem(sizer, proportion, flag, border, data);
2818 }
2819
2820 #include <float.h>
2821 SWIGINTERN int
2822 SWIG_CheckDoubleInRange(double value, double min_value,
2823 double max_value, const char* errmsg)
2824 {
2825 if (value < min_value) {
2826 if (errmsg) {
2827 PyErr_Format(PyExc_OverflowError,
2828 "value %g is less than %s minimum %g",
2829 value, errmsg, min_value);
2830 }
2831 return 0;
2832 } else if (value > max_value) {
2833 if (errmsg) {
2834 PyErr_Format(PyExc_OverflowError,
2835 "value %g is greater than %s maximum %g",
2836 value, errmsg, max_value);
2837 }
2838 return 0;
2839 }
2840 return 1;
2841 }
2842
2843
2844 SWIGINTERN int
2845 SWIG_AsVal_float(PyObject *obj, float *val)
2846 {
2847 const char* errmsg = val ? "float" : (char*)0;
2848 double v;
2849 if (SWIG_AsVal_double(obj, &v)) {
2850 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2851 if (val) *val = (float)(v);
2852 return 1;
2853 } else {
2854 return 0;
2855 }
2856 } else {
2857 PyErr_Clear();
2858 }
2859 if (val) {
2860 SWIG_type_error(errmsg, obj);
2861 }
2862 return 0;
2863 }
2864
2865
2866 SWIGINTERNSHORT float
2867 SWIG_As_float(PyObject* obj)
2868 {
2869 float v;
2870 if (!SWIG_AsVal_float(obj, &v)) {
2871 /*
2872 this is needed to make valgrind/purify happier.
2873 */
2874 memset((void*)&v, 0, sizeof(float));
2875 }
2876 return v;
2877 }
2878
2879
2880 SWIGINTERNSHORT int
2881 SWIG_Check_float(PyObject* obj)
2882 {
2883 return SWIG_AsVal_float(obj, (float*)0);
2884 }
2885
2886
2887 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2888 #define SWIG_From_float PyFloat_FromDouble
2889 /*@@*/
2890
2891 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2892 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2893 if (data) {
2894 Py_INCREF(data->m_obj);
2895 return data->m_obj;
2896 } else {
2897 Py_INCREF(Py_None);
2898 return Py_None;
2899 }
2900 }
2901
2902 // Figure out the type of the sizer item
2903
2904 struct wxPySizerItemInfo {
2905 wxPySizerItemInfo()
2906 : window(NULL), sizer(NULL), gotSize(false),
2907 size(wxDefaultSize), gotPos(false), pos(-1)
2908 {}
2909
2910 wxWindow* window;
2911 wxSizer* sizer;
2912 bool gotSize;
2913 wxSize size;
2914 bool gotPos;
2915 int pos;
2916 };
2917
2918 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2919
2920 wxPySizerItemInfo info;
2921 wxSize size;
2922 wxSize* sizePtr = &size;
2923
2924 // Find out what the type of the item is
2925 // try wxWindow
2926 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2927 PyErr_Clear();
2928 info.window = NULL;
2929
2930 // try wxSizer
2931 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2932 PyErr_Clear();
2933 info.sizer = NULL;
2934
2935 // try wxSize or (w,h)
2936 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2937 info.size = *sizePtr;
2938 info.gotSize = true;
2939 }
2940
2941 // or a single int
2942 if (checkIdx && PyInt_Check(item)) {
2943 info.pos = PyInt_AsLong(item);
2944 info.gotPos = true;
2945 }
2946 }
2947 }
2948
2949 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2950 // no expected type, figure out what kind of error message to generate
2951 if ( !checkSize && !checkIdx )
2952 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2953 else if ( checkSize && !checkIdx )
2954 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2955 else if ( !checkSize && checkIdx)
2956 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2957 else
2958 // can this one happen?
2959 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2960 }
2961
2962 return info;
2963 }
2964
2965 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
2966 if (!self->GetClientObject())
2967 self->SetClientObject(new wxPyOORClientData(_self));
2968 }
2969 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2970
2971 wxPyUserData* data = NULL;
2972 bool blocked = wxPyBeginBlockThreads();
2973 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2974 if ( userData && (info.window || info.sizer || info.gotSize) )
2975 data = new wxPyUserData(userData);
2976 wxPyEndBlockThreads(blocked);
2977
2978 // Now call the real Add method if a valid item type was found
2979 if ( info.window )
2980 return self->Add(info.window, proportion, flag, border, data);
2981 else if ( info.sizer )
2982 return self->Add(info.sizer, proportion, flag, border, data);
2983 else if (info.gotSize)
2984 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
2985 proportion, flag, border, data);
2986 else
2987 return NULL;
2988 }
2989 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
2990
2991 wxPyUserData* data = NULL;
2992 bool blocked = wxPyBeginBlockThreads();
2993 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
2994 if ( userData && (info.window || info.sizer || info.gotSize) )
2995 data = new wxPyUserData(userData);
2996 wxPyEndBlockThreads(blocked);
2997
2998 // Now call the real Insert method if a valid item type was found
2999 if ( info.window )
3000 return self->Insert(before, info.window, proportion, flag, border, data);
3001 else if ( info.sizer )
3002 return self->Insert(before, info.sizer, proportion, flag, border, data);
3003 else if (info.gotSize)
3004 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3005 proportion, flag, border, data);
3006 else
3007 return NULL;
3008 }
3009 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3010
3011 wxPyUserData* data = NULL;
3012 bool blocked = wxPyBeginBlockThreads();
3013 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3014 if ( userData && (info.window || info.sizer || info.gotSize) )
3015 data = new wxPyUserData(userData);
3016 wxPyEndBlockThreads(blocked);
3017
3018 // Now call the real Prepend method if a valid item type was found
3019 if ( info.window )
3020 return self->Prepend(info.window, proportion, flag, border, data);
3021 else if ( info.sizer )
3022 return self->Prepend(info.sizer, proportion, flag, border, data);
3023 else if (info.gotSize)
3024 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3025 proportion, flag, border, data);
3026 else
3027 return NULL;
3028 }
3029 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3030 bool blocked = wxPyBeginBlockThreads();
3031 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3032 wxPyEndBlockThreads(blocked);
3033 if ( info.window )
3034 return self->Remove(info.window);
3035 else if ( info.sizer )
3036 return self->Remove(info.sizer);
3037 else if ( info.gotPos )
3038 return self->Remove(info.pos);
3039 else
3040 return false;
3041 }
3042 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3043 bool blocked = wxPyBeginBlockThreads();
3044 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3045 wxPyEndBlockThreads(blocked);
3046 if ( info.window )
3047 return self->Detach(info.window);
3048 else if ( info.sizer )
3049 return self->Detach(info.sizer);
3050 else if ( info.gotPos )
3051 return self->Detach(info.pos);
3052 else
3053 return false;
3054 }
3055 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3056 bool blocked = wxPyBeginBlockThreads();
3057 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3058 wxPyEndBlockThreads(blocked);
3059 if ( info.window )
3060 return self->GetItem(info.window);
3061 else if ( info.sizer )
3062 return self->GetItem(info.sizer);
3063 else if ( info.gotPos )
3064 return self->GetItem(info.pos);
3065 else
3066 return NULL;
3067 }
3068 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3069 bool blocked = wxPyBeginBlockThreads();
3070 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3071 wxPyEndBlockThreads(blocked);
3072 if ( info.window )
3073 self->SetItemMinSize(info.window, size);
3074 else if ( info.sizer )
3075 self->SetItemMinSize(info.sizer, size);
3076 else if ( info.gotPos )
3077 self->SetItemMinSize(info.pos, size);
3078 }
3079 static PyObject *wxSizer_GetChildren(wxSizer *self){
3080 wxSizerItemList& list = self->GetChildren();
3081 return wxPy_ConvertList(&list);
3082 }
3083 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3084 bool blocked = wxPyBeginBlockThreads();
3085 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3086 wxPyEndBlockThreads(blocked);
3087 if ( info.window )
3088 return self->Show(info.window, show, recursive);
3089 else if ( info.sizer )
3090 return self->Show(info.sizer, show, recursive);
3091 else if ( info.gotPos )
3092 return self->Show(info.pos, show);
3093 else
3094 return false;
3095 }
3096 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3097 bool blocked = wxPyBeginBlockThreads();
3098 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3099 wxPyEndBlockThreads(blocked);
3100 if ( info.window )
3101 return self->IsShown(info.window);
3102 else if ( info.sizer )
3103 return self->IsShown(info.sizer);
3104 else if ( info.gotPos )
3105 return self->IsShown(info.pos);
3106 else
3107 return false;
3108 }
3109
3110 // See pyclasses.h
3111 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3112 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3113 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3114
3115
3116
3117
3118 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3119 {
3120 if (source == Py_None) {
3121 **obj = wxGBPosition(-1,-1);
3122 return true;
3123 }
3124 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3125 }
3126
3127 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3128 {
3129 if (source == Py_None) {
3130 **obj = wxGBSpan(-1,-1);
3131 return true;
3132 }
3133 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3134 }
3135
3136
3137 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3138 self->SetRow(row);
3139 self->SetCol(col);
3140 }
3141 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3142 bool blocked = wxPyBeginBlockThreads();
3143 PyObject* tup = PyTuple_New(2);
3144 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3145 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3146 wxPyEndBlockThreads(blocked);
3147 return tup;
3148 }
3149 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3150 self->SetRowspan(rowspan);
3151 self->SetColspan(colspan);
3152 }
3153 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3154 bool blocked = wxPyBeginBlockThreads();
3155 PyObject* tup = PyTuple_New(2);
3156 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3157 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3158 wxPyEndBlockThreads(blocked);
3159 return tup;
3160 }
3161 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3162 wxPyUserData* data = NULL;
3163 if ( userData ) {
3164 bool blocked = wxPyBeginBlockThreads();
3165 data = new wxPyUserData(userData);
3166 wxPyEndBlockThreads(blocked);
3167 }
3168 return new wxGBSizerItem(window, pos, span, flag, border, data);
3169 }
3170 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3171 wxPyUserData* data = NULL;
3172 if ( userData ) {
3173 bool blocked = wxPyBeginBlockThreads();
3174 data = new wxPyUserData(userData);
3175 wxPyEndBlockThreads(blocked);
3176 }
3177 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3178 }
3179 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3180 wxPyUserData* data = NULL;
3181 if ( userData ) {
3182 bool blocked = wxPyBeginBlockThreads();
3183 data = new wxPyUserData(userData);
3184 wxPyEndBlockThreads(blocked);
3185 }
3186 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3187 }
3188 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3189 int row, col;
3190 self->GetEndPos(row, col);
3191 return wxGBPosition(row, col);
3192 }
3193 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3194
3195 wxPyUserData* data = NULL;
3196 bool blocked = wxPyBeginBlockThreads();
3197 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3198 if ( userData && (info.window || info.sizer || info.gotSize) )
3199 data = new wxPyUserData(userData);
3200 wxPyEndBlockThreads(blocked);
3201
3202 // Now call the real Add method if a valid item type was found
3203 if ( info.window )
3204 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3205 else if ( info.sizer )
3206 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3207 else if (info.gotSize)
3208 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3209 pos, span, flag, border, data);
3210 return NULL;
3211 }
3212
3213
3214 #ifdef __cplusplus
3215 extern "C" {
3216 #endif
3217 static int _wrap_EmptyString_set(PyObject *) {
3218 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3219 return 1;
3220 }
3221
3222
3223 static PyObject *_wrap_EmptyString_get(void) {
3224 PyObject *pyobj;
3225
3226 {
3227 #if wxUSE_UNICODE
3228 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3229 #else
3230 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3231 #endif
3232 }
3233 return pyobj;
3234 }
3235
3236
3237 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3238 PyObject *resultobj;
3239 wxObject *arg1 = (wxObject *) 0 ;
3240 wxString result;
3241 PyObject * obj0 = 0 ;
3242 char *kwnames[] = {
3243 (char *) "self", NULL
3244 };
3245
3246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3248 if (SWIG_arg_fail(1)) SWIG_fail;
3249 {
3250 PyThreadState* __tstate = wxPyBeginAllowThreads();
3251 result = wxObject_GetClassName(arg1);
3252
3253 wxPyEndAllowThreads(__tstate);
3254 if (PyErr_Occurred()) SWIG_fail;
3255 }
3256 {
3257 #if wxUSE_UNICODE
3258 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3259 #else
3260 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3261 #endif
3262 }
3263 return resultobj;
3264 fail:
3265 return NULL;
3266 }
3267
3268
3269 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3270 PyObject *resultobj;
3271 wxObject *arg1 = (wxObject *) 0 ;
3272 PyObject * obj0 = 0 ;
3273 char *kwnames[] = {
3274 (char *) "self", NULL
3275 };
3276
3277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3279 if (SWIG_arg_fail(1)) SWIG_fail;
3280 {
3281 PyThreadState* __tstate = wxPyBeginAllowThreads();
3282 wxObject_Destroy(arg1);
3283
3284 wxPyEndAllowThreads(__tstate);
3285 if (PyErr_Occurred()) SWIG_fail;
3286 }
3287 Py_INCREF(Py_None); resultobj = Py_None;
3288 return resultobj;
3289 fail:
3290 return NULL;
3291 }
3292
3293
3294 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3295 PyObject *obj;
3296 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3297 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3298 Py_INCREF(obj);
3299 return Py_BuildValue((char *)"");
3300 }
3301 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3302 PyObject *resultobj;
3303 wxSize *arg1 = (wxSize *) 0 ;
3304 int arg2 ;
3305 PyObject * obj0 = 0 ;
3306 PyObject * obj1 = 0 ;
3307 char *kwnames[] = {
3308 (char *) "self",(char *) "x", NULL
3309 };
3310
3311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3313 if (SWIG_arg_fail(1)) SWIG_fail;
3314 {
3315 arg2 = (int)(SWIG_As_int(obj1));
3316 if (SWIG_arg_fail(2)) SWIG_fail;
3317 }
3318 if (arg1) (arg1)->x = arg2;
3319
3320 Py_INCREF(Py_None); resultobj = Py_None;
3321 return resultobj;
3322 fail:
3323 return NULL;
3324 }
3325
3326
3327 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3328 PyObject *resultobj;
3329 wxSize *arg1 = (wxSize *) 0 ;
3330 int result;
3331 PyObject * obj0 = 0 ;
3332 char *kwnames[] = {
3333 (char *) "self", NULL
3334 };
3335
3336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3338 if (SWIG_arg_fail(1)) SWIG_fail;
3339 result = (int) ((arg1)->x);
3340
3341 {
3342 resultobj = SWIG_From_int((int)(result));
3343 }
3344 return resultobj;
3345 fail:
3346 return NULL;
3347 }
3348
3349
3350 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3351 PyObject *resultobj;
3352 wxSize *arg1 = (wxSize *) 0 ;
3353 int arg2 ;
3354 PyObject * obj0 = 0 ;
3355 PyObject * obj1 = 0 ;
3356 char *kwnames[] = {
3357 (char *) "self",(char *) "y", NULL
3358 };
3359
3360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3362 if (SWIG_arg_fail(1)) SWIG_fail;
3363 {
3364 arg2 = (int)(SWIG_As_int(obj1));
3365 if (SWIG_arg_fail(2)) SWIG_fail;
3366 }
3367 if (arg1) (arg1)->y = arg2;
3368
3369 Py_INCREF(Py_None); resultobj = Py_None;
3370 return resultobj;
3371 fail:
3372 return NULL;
3373 }
3374
3375
3376 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3377 PyObject *resultobj;
3378 wxSize *arg1 = (wxSize *) 0 ;
3379 int result;
3380 PyObject * obj0 = 0 ;
3381 char *kwnames[] = {
3382 (char *) "self", NULL
3383 };
3384
3385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3387 if (SWIG_arg_fail(1)) SWIG_fail;
3388 result = (int) ((arg1)->y);
3389
3390 {
3391 resultobj = SWIG_From_int((int)(result));
3392 }
3393 return resultobj;
3394 fail:
3395 return NULL;
3396 }
3397
3398
3399 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3400 PyObject *resultobj;
3401 int arg1 = (int) 0 ;
3402 int arg2 = (int) 0 ;
3403 wxSize *result;
3404 PyObject * obj0 = 0 ;
3405 PyObject * obj1 = 0 ;
3406 char *kwnames[] = {
3407 (char *) "w",(char *) "h", NULL
3408 };
3409
3410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3411 if (obj0) {
3412 {
3413 arg1 = (int)(SWIG_As_int(obj0));
3414 if (SWIG_arg_fail(1)) SWIG_fail;
3415 }
3416 }
3417 if (obj1) {
3418 {
3419 arg2 = (int)(SWIG_As_int(obj1));
3420 if (SWIG_arg_fail(2)) SWIG_fail;
3421 }
3422 }
3423 {
3424 PyThreadState* __tstate = wxPyBeginAllowThreads();
3425 result = (wxSize *)new wxSize(arg1,arg2);
3426
3427 wxPyEndAllowThreads(__tstate);
3428 if (PyErr_Occurred()) SWIG_fail;
3429 }
3430 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3431 return resultobj;
3432 fail:
3433 return NULL;
3434 }
3435
3436
3437 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3438 PyObject *resultobj;
3439 wxSize *arg1 = (wxSize *) 0 ;
3440 PyObject * obj0 = 0 ;
3441 char *kwnames[] = {
3442 (char *) "self", NULL
3443 };
3444
3445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3447 if (SWIG_arg_fail(1)) SWIG_fail;
3448 {
3449 PyThreadState* __tstate = wxPyBeginAllowThreads();
3450 delete arg1;
3451
3452 wxPyEndAllowThreads(__tstate);
3453 if (PyErr_Occurred()) SWIG_fail;
3454 }
3455 Py_INCREF(Py_None); resultobj = Py_None;
3456 return resultobj;
3457 fail:
3458 return NULL;
3459 }
3460
3461
3462 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3463 PyObject *resultobj;
3464 wxSize *arg1 = (wxSize *) 0 ;
3465 wxSize *arg2 = 0 ;
3466 bool result;
3467 wxSize temp2 ;
3468 PyObject * obj0 = 0 ;
3469 PyObject * obj1 = 0 ;
3470 char *kwnames[] = {
3471 (char *) "self",(char *) "sz", NULL
3472 };
3473
3474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3476 if (SWIG_arg_fail(1)) SWIG_fail;
3477 {
3478 arg2 = &temp2;
3479 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3480 }
3481 {
3482 PyThreadState* __tstate = wxPyBeginAllowThreads();
3483 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3484
3485 wxPyEndAllowThreads(__tstate);
3486 if (PyErr_Occurred()) SWIG_fail;
3487 }
3488 {
3489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3490 }
3491 return resultobj;
3492 fail:
3493 return NULL;
3494 }
3495
3496
3497 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3498 PyObject *resultobj;
3499 wxSize *arg1 = (wxSize *) 0 ;
3500 wxSize *arg2 = 0 ;
3501 bool result;
3502 wxSize temp2 ;
3503 PyObject * obj0 = 0 ;
3504 PyObject * obj1 = 0 ;
3505 char *kwnames[] = {
3506 (char *) "self",(char *) "sz", NULL
3507 };
3508
3509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3511 if (SWIG_arg_fail(1)) SWIG_fail;
3512 {
3513 arg2 = &temp2;
3514 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3515 }
3516 {
3517 PyThreadState* __tstate = wxPyBeginAllowThreads();
3518 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3519
3520 wxPyEndAllowThreads(__tstate);
3521 if (PyErr_Occurred()) SWIG_fail;
3522 }
3523 {
3524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3525 }
3526 return resultobj;
3527 fail:
3528 return NULL;
3529 }
3530
3531
3532 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3533 PyObject *resultobj;
3534 wxSize *arg1 = (wxSize *) 0 ;
3535 wxSize *arg2 = 0 ;
3536 wxSize result;
3537 wxSize temp2 ;
3538 PyObject * obj0 = 0 ;
3539 PyObject * obj1 = 0 ;
3540 char *kwnames[] = {
3541 (char *) "self",(char *) "sz", NULL
3542 };
3543
3544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3546 if (SWIG_arg_fail(1)) SWIG_fail;
3547 {
3548 arg2 = &temp2;
3549 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3550 }
3551 {
3552 PyThreadState* __tstate = wxPyBeginAllowThreads();
3553 result = (arg1)->operator +((wxSize const &)*arg2);
3554
3555 wxPyEndAllowThreads(__tstate);
3556 if (PyErr_Occurred()) SWIG_fail;
3557 }
3558 {
3559 wxSize * resultptr;
3560 resultptr = new wxSize((wxSize &)(result));
3561 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3562 }
3563 return resultobj;
3564 fail:
3565 return NULL;
3566 }
3567
3568
3569 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3570 PyObject *resultobj;
3571 wxSize *arg1 = (wxSize *) 0 ;
3572 wxSize *arg2 = 0 ;
3573 wxSize result;
3574 wxSize temp2 ;
3575 PyObject * obj0 = 0 ;
3576 PyObject * obj1 = 0 ;
3577 char *kwnames[] = {
3578 (char *) "self",(char *) "sz", NULL
3579 };
3580
3581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3583 if (SWIG_arg_fail(1)) SWIG_fail;
3584 {
3585 arg2 = &temp2;
3586 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3587 }
3588 {
3589 PyThreadState* __tstate = wxPyBeginAllowThreads();
3590 result = (arg1)->operator -((wxSize const &)*arg2);
3591
3592 wxPyEndAllowThreads(__tstate);
3593 if (PyErr_Occurred()) SWIG_fail;
3594 }
3595 {
3596 wxSize * resultptr;
3597 resultptr = new wxSize((wxSize &)(result));
3598 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3599 }
3600 return resultobj;
3601 fail:
3602 return NULL;
3603 }
3604
3605
3606 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3607 PyObject *resultobj;
3608 wxSize *arg1 = (wxSize *) 0 ;
3609 wxSize *arg2 = 0 ;
3610 wxSize temp2 ;
3611 PyObject * obj0 = 0 ;
3612 PyObject * obj1 = 0 ;
3613 char *kwnames[] = {
3614 (char *) "self",(char *) "sz", NULL
3615 };
3616
3617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3619 if (SWIG_arg_fail(1)) SWIG_fail;
3620 {
3621 arg2 = &temp2;
3622 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3623 }
3624 {
3625 PyThreadState* __tstate = wxPyBeginAllowThreads();
3626 (arg1)->IncTo((wxSize const &)*arg2);
3627
3628 wxPyEndAllowThreads(__tstate);
3629 if (PyErr_Occurred()) SWIG_fail;
3630 }
3631 Py_INCREF(Py_None); resultobj = Py_None;
3632 return resultobj;
3633 fail:
3634 return NULL;
3635 }
3636
3637
3638 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3639 PyObject *resultobj;
3640 wxSize *arg1 = (wxSize *) 0 ;
3641 wxSize *arg2 = 0 ;
3642 wxSize temp2 ;
3643 PyObject * obj0 = 0 ;
3644 PyObject * obj1 = 0 ;
3645 char *kwnames[] = {
3646 (char *) "self",(char *) "sz", NULL
3647 };
3648
3649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3651 if (SWIG_arg_fail(1)) SWIG_fail;
3652 {
3653 arg2 = &temp2;
3654 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3655 }
3656 {
3657 PyThreadState* __tstate = wxPyBeginAllowThreads();
3658 (arg1)->DecTo((wxSize const &)*arg2);
3659
3660 wxPyEndAllowThreads(__tstate);
3661 if (PyErr_Occurred()) SWIG_fail;
3662 }
3663 Py_INCREF(Py_None); resultobj = Py_None;
3664 return resultobj;
3665 fail:
3666 return NULL;
3667 }
3668
3669
3670 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3671 PyObject *resultobj;
3672 wxSize *arg1 = (wxSize *) 0 ;
3673 int arg2 ;
3674 int arg3 ;
3675 PyObject * obj0 = 0 ;
3676 PyObject * obj1 = 0 ;
3677 PyObject * obj2 = 0 ;
3678 char *kwnames[] = {
3679 (char *) "self",(char *) "w",(char *) "h", NULL
3680 };
3681
3682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3684 if (SWIG_arg_fail(1)) SWIG_fail;
3685 {
3686 arg2 = (int)(SWIG_As_int(obj1));
3687 if (SWIG_arg_fail(2)) SWIG_fail;
3688 }
3689 {
3690 arg3 = (int)(SWIG_As_int(obj2));
3691 if (SWIG_arg_fail(3)) SWIG_fail;
3692 }
3693 {
3694 PyThreadState* __tstate = wxPyBeginAllowThreads();
3695 (arg1)->Set(arg2,arg3);
3696
3697 wxPyEndAllowThreads(__tstate);
3698 if (PyErr_Occurred()) SWIG_fail;
3699 }
3700 Py_INCREF(Py_None); resultobj = Py_None;
3701 return resultobj;
3702 fail:
3703 return NULL;
3704 }
3705
3706
3707 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3708 PyObject *resultobj;
3709 wxSize *arg1 = (wxSize *) 0 ;
3710 int arg2 ;
3711 PyObject * obj0 = 0 ;
3712 PyObject * obj1 = 0 ;
3713 char *kwnames[] = {
3714 (char *) "self",(char *) "w", NULL
3715 };
3716
3717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3719 if (SWIG_arg_fail(1)) SWIG_fail;
3720 {
3721 arg2 = (int)(SWIG_As_int(obj1));
3722 if (SWIG_arg_fail(2)) SWIG_fail;
3723 }
3724 {
3725 PyThreadState* __tstate = wxPyBeginAllowThreads();
3726 (arg1)->SetWidth(arg2);
3727
3728 wxPyEndAllowThreads(__tstate);
3729 if (PyErr_Occurred()) SWIG_fail;
3730 }
3731 Py_INCREF(Py_None); resultobj = Py_None;
3732 return resultobj;
3733 fail:
3734 return NULL;
3735 }
3736
3737
3738 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3739 PyObject *resultobj;
3740 wxSize *arg1 = (wxSize *) 0 ;
3741 int arg2 ;
3742 PyObject * obj0 = 0 ;
3743 PyObject * obj1 = 0 ;
3744 char *kwnames[] = {
3745 (char *) "self",(char *) "h", NULL
3746 };
3747
3748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3750 if (SWIG_arg_fail(1)) SWIG_fail;
3751 {
3752 arg2 = (int)(SWIG_As_int(obj1));
3753 if (SWIG_arg_fail(2)) SWIG_fail;
3754 }
3755 {
3756 PyThreadState* __tstate = wxPyBeginAllowThreads();
3757 (arg1)->SetHeight(arg2);
3758
3759 wxPyEndAllowThreads(__tstate);
3760 if (PyErr_Occurred()) SWIG_fail;
3761 }
3762 Py_INCREF(Py_None); resultobj = Py_None;
3763 return resultobj;
3764 fail:
3765 return NULL;
3766 }
3767
3768
3769 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3770 PyObject *resultobj;
3771 wxSize *arg1 = (wxSize *) 0 ;
3772 int result;
3773 PyObject * obj0 = 0 ;
3774 char *kwnames[] = {
3775 (char *) "self", NULL
3776 };
3777
3778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3780 if (SWIG_arg_fail(1)) SWIG_fail;
3781 {
3782 PyThreadState* __tstate = wxPyBeginAllowThreads();
3783 result = (int)((wxSize const *)arg1)->GetWidth();
3784
3785 wxPyEndAllowThreads(__tstate);
3786 if (PyErr_Occurred()) SWIG_fail;
3787 }
3788 {
3789 resultobj = SWIG_From_int((int)(result));
3790 }
3791 return resultobj;
3792 fail:
3793 return NULL;
3794 }
3795
3796
3797 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3798 PyObject *resultobj;
3799 wxSize *arg1 = (wxSize *) 0 ;
3800 int result;
3801 PyObject * obj0 = 0 ;
3802 char *kwnames[] = {
3803 (char *) "self", NULL
3804 };
3805
3806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3808 if (SWIG_arg_fail(1)) SWIG_fail;
3809 {
3810 PyThreadState* __tstate = wxPyBeginAllowThreads();
3811 result = (int)((wxSize const *)arg1)->GetHeight();
3812
3813 wxPyEndAllowThreads(__tstate);
3814 if (PyErr_Occurred()) SWIG_fail;
3815 }
3816 {
3817 resultobj = SWIG_From_int((int)(result));
3818 }
3819 return resultobj;
3820 fail:
3821 return NULL;
3822 }
3823
3824
3825 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3826 PyObject *resultobj;
3827 wxSize *arg1 = (wxSize *) 0 ;
3828 bool result;
3829 PyObject * obj0 = 0 ;
3830 char *kwnames[] = {
3831 (char *) "self", NULL
3832 };
3833
3834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3836 if (SWIG_arg_fail(1)) SWIG_fail;
3837 {
3838 PyThreadState* __tstate = wxPyBeginAllowThreads();
3839 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3840
3841 wxPyEndAllowThreads(__tstate);
3842 if (PyErr_Occurred()) SWIG_fail;
3843 }
3844 {
3845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3846 }
3847 return resultobj;
3848 fail:
3849 return NULL;
3850 }
3851
3852
3853 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3854 PyObject *resultobj;
3855 wxSize *arg1 = (wxSize *) 0 ;
3856 wxSize *arg2 = 0 ;
3857 wxSize temp2 ;
3858 PyObject * obj0 = 0 ;
3859 PyObject * obj1 = 0 ;
3860 char *kwnames[] = {
3861 (char *) "self",(char *) "size", NULL
3862 };
3863
3864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3866 if (SWIG_arg_fail(1)) SWIG_fail;
3867 {
3868 arg2 = &temp2;
3869 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3870 }
3871 {
3872 PyThreadState* __tstate = wxPyBeginAllowThreads();
3873 (arg1)->SetDefaults((wxSize const &)*arg2);
3874
3875 wxPyEndAllowThreads(__tstate);
3876 if (PyErr_Occurred()) SWIG_fail;
3877 }
3878 Py_INCREF(Py_None); resultobj = Py_None;
3879 return resultobj;
3880 fail:
3881 return NULL;
3882 }
3883
3884
3885 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3886 PyObject *resultobj;
3887 wxSize *arg1 = (wxSize *) 0 ;
3888 PyObject *result;
3889 PyObject * obj0 = 0 ;
3890 char *kwnames[] = {
3891 (char *) "self", NULL
3892 };
3893
3894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3896 if (SWIG_arg_fail(1)) SWIG_fail;
3897 {
3898 PyThreadState* __tstate = wxPyBeginAllowThreads();
3899 result = (PyObject *)wxSize_Get(arg1);
3900
3901 wxPyEndAllowThreads(__tstate);
3902 if (PyErr_Occurred()) SWIG_fail;
3903 }
3904 resultobj = result;
3905 return resultobj;
3906 fail:
3907 return NULL;
3908 }
3909
3910
3911 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3912 PyObject *obj;
3913 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3914 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3915 Py_INCREF(obj);
3916 return Py_BuildValue((char *)"");
3917 }
3918 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3919 PyObject *resultobj;
3920 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3921 double arg2 ;
3922 PyObject * obj0 = 0 ;
3923 PyObject * obj1 = 0 ;
3924 char *kwnames[] = {
3925 (char *) "self",(char *) "x", NULL
3926 };
3927
3928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3930 if (SWIG_arg_fail(1)) SWIG_fail;
3931 {
3932 arg2 = (double)(SWIG_As_double(obj1));
3933 if (SWIG_arg_fail(2)) SWIG_fail;
3934 }
3935 if (arg1) (arg1)->x = arg2;
3936
3937 Py_INCREF(Py_None); resultobj = Py_None;
3938 return resultobj;
3939 fail:
3940 return NULL;
3941 }
3942
3943
3944 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3945 PyObject *resultobj;
3946 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3947 double result;
3948 PyObject * obj0 = 0 ;
3949 char *kwnames[] = {
3950 (char *) "self", NULL
3951 };
3952
3953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3955 if (SWIG_arg_fail(1)) SWIG_fail;
3956 result = (double) ((arg1)->x);
3957
3958 {
3959 resultobj = SWIG_From_double((double)(result));
3960 }
3961 return resultobj;
3962 fail:
3963 return NULL;
3964 }
3965
3966
3967 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
3968 PyObject *resultobj;
3969 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3970 double arg2 ;
3971 PyObject * obj0 = 0 ;
3972 PyObject * obj1 = 0 ;
3973 char *kwnames[] = {
3974 (char *) "self",(char *) "y", NULL
3975 };
3976
3977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
3978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3979 if (SWIG_arg_fail(1)) SWIG_fail;
3980 {
3981 arg2 = (double)(SWIG_As_double(obj1));
3982 if (SWIG_arg_fail(2)) SWIG_fail;
3983 }
3984 if (arg1) (arg1)->y = arg2;
3985
3986 Py_INCREF(Py_None); resultobj = Py_None;
3987 return resultobj;
3988 fail:
3989 return NULL;
3990 }
3991
3992
3993 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
3994 PyObject *resultobj;
3995 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3996 double result;
3997 PyObject * obj0 = 0 ;
3998 char *kwnames[] = {
3999 (char *) "self", NULL
4000 };
4001
4002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4004 if (SWIG_arg_fail(1)) SWIG_fail;
4005 result = (double) ((arg1)->y);
4006
4007 {
4008 resultobj = SWIG_From_double((double)(result));
4009 }
4010 return resultobj;
4011 fail:
4012 return NULL;
4013 }
4014
4015
4016 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4017 PyObject *resultobj;
4018 double arg1 = (double) 0.0 ;
4019 double arg2 = (double) 0.0 ;
4020 wxRealPoint *result;
4021 PyObject * obj0 = 0 ;
4022 PyObject * obj1 = 0 ;
4023 char *kwnames[] = {
4024 (char *) "x",(char *) "y", NULL
4025 };
4026
4027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4028 if (obj0) {
4029 {
4030 arg1 = (double)(SWIG_As_double(obj0));
4031 if (SWIG_arg_fail(1)) SWIG_fail;
4032 }
4033 }
4034 if (obj1) {
4035 {
4036 arg2 = (double)(SWIG_As_double(obj1));
4037 if (SWIG_arg_fail(2)) SWIG_fail;
4038 }
4039 }
4040 {
4041 PyThreadState* __tstate = wxPyBeginAllowThreads();
4042 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4043
4044 wxPyEndAllowThreads(__tstate);
4045 if (PyErr_Occurred()) SWIG_fail;
4046 }
4047 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4048 return resultobj;
4049 fail:
4050 return NULL;
4051 }
4052
4053
4054 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4055 PyObject *resultobj;
4056 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4057 PyObject * obj0 = 0 ;
4058 char *kwnames[] = {
4059 (char *) "self", NULL
4060 };
4061
4062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4064 if (SWIG_arg_fail(1)) SWIG_fail;
4065 {
4066 PyThreadState* __tstate = wxPyBeginAllowThreads();
4067 delete arg1;
4068
4069 wxPyEndAllowThreads(__tstate);
4070 if (PyErr_Occurred()) SWIG_fail;
4071 }
4072 Py_INCREF(Py_None); resultobj = Py_None;
4073 return resultobj;
4074 fail:
4075 return NULL;
4076 }
4077
4078
4079 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4080 PyObject *resultobj;
4081 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4082 wxRealPoint *arg2 = 0 ;
4083 bool result;
4084 wxRealPoint temp2 ;
4085 PyObject * obj0 = 0 ;
4086 PyObject * obj1 = 0 ;
4087 char *kwnames[] = {
4088 (char *) "self",(char *) "pt", NULL
4089 };
4090
4091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4093 if (SWIG_arg_fail(1)) SWIG_fail;
4094 {
4095 arg2 = &temp2;
4096 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4097 }
4098 {
4099 PyThreadState* __tstate = wxPyBeginAllowThreads();
4100 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4101
4102 wxPyEndAllowThreads(__tstate);
4103 if (PyErr_Occurred()) SWIG_fail;
4104 }
4105 {
4106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4107 }
4108 return resultobj;
4109 fail:
4110 return NULL;
4111 }
4112
4113
4114 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4115 PyObject *resultobj;
4116 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4117 wxRealPoint *arg2 = 0 ;
4118 bool result;
4119 wxRealPoint temp2 ;
4120 PyObject * obj0 = 0 ;
4121 PyObject * obj1 = 0 ;
4122 char *kwnames[] = {
4123 (char *) "self",(char *) "pt", NULL
4124 };
4125
4126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4128 if (SWIG_arg_fail(1)) SWIG_fail;
4129 {
4130 arg2 = &temp2;
4131 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4132 }
4133 {
4134 PyThreadState* __tstate = wxPyBeginAllowThreads();
4135 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4136
4137 wxPyEndAllowThreads(__tstate);
4138 if (PyErr_Occurred()) SWIG_fail;
4139 }
4140 {
4141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4142 }
4143 return resultobj;
4144 fail:
4145 return NULL;
4146 }
4147
4148
4149 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4150 PyObject *resultobj;
4151 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4152 wxRealPoint *arg2 = 0 ;
4153 wxRealPoint result;
4154 wxRealPoint temp2 ;
4155 PyObject * obj0 = 0 ;
4156 PyObject * obj1 = 0 ;
4157 char *kwnames[] = {
4158 (char *) "self",(char *) "pt", NULL
4159 };
4160
4161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4163 if (SWIG_arg_fail(1)) SWIG_fail;
4164 {
4165 arg2 = &temp2;
4166 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4167 }
4168 {
4169 PyThreadState* __tstate = wxPyBeginAllowThreads();
4170 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4171
4172 wxPyEndAllowThreads(__tstate);
4173 if (PyErr_Occurred()) SWIG_fail;
4174 }
4175 {
4176 wxRealPoint * resultptr;
4177 resultptr = new wxRealPoint((wxRealPoint &)(result));
4178 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4179 }
4180 return resultobj;
4181 fail:
4182 return NULL;
4183 }
4184
4185
4186 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4187 PyObject *resultobj;
4188 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4189 wxRealPoint *arg2 = 0 ;
4190 wxRealPoint result;
4191 wxRealPoint temp2 ;
4192 PyObject * obj0 = 0 ;
4193 PyObject * obj1 = 0 ;
4194 char *kwnames[] = {
4195 (char *) "self",(char *) "pt", NULL
4196 };
4197
4198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4200 if (SWIG_arg_fail(1)) SWIG_fail;
4201 {
4202 arg2 = &temp2;
4203 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4204 }
4205 {
4206 PyThreadState* __tstate = wxPyBeginAllowThreads();
4207 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4208
4209 wxPyEndAllowThreads(__tstate);
4210 if (PyErr_Occurred()) SWIG_fail;
4211 }
4212 {
4213 wxRealPoint * resultptr;
4214 resultptr = new wxRealPoint((wxRealPoint &)(result));
4215 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4216 }
4217 return resultobj;
4218 fail:
4219 return NULL;
4220 }
4221
4222
4223 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4224 PyObject *resultobj;
4225 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4226 double arg2 ;
4227 double arg3 ;
4228 PyObject * obj0 = 0 ;
4229 PyObject * obj1 = 0 ;
4230 PyObject * obj2 = 0 ;
4231 char *kwnames[] = {
4232 (char *) "self",(char *) "x",(char *) "y", NULL
4233 };
4234
4235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4237 if (SWIG_arg_fail(1)) SWIG_fail;
4238 {
4239 arg2 = (double)(SWIG_As_double(obj1));
4240 if (SWIG_arg_fail(2)) SWIG_fail;
4241 }
4242 {
4243 arg3 = (double)(SWIG_As_double(obj2));
4244 if (SWIG_arg_fail(3)) SWIG_fail;
4245 }
4246 {
4247 PyThreadState* __tstate = wxPyBeginAllowThreads();
4248 wxRealPoint_Set(arg1,arg2,arg3);
4249
4250 wxPyEndAllowThreads(__tstate);
4251 if (PyErr_Occurred()) SWIG_fail;
4252 }
4253 Py_INCREF(Py_None); resultobj = Py_None;
4254 return resultobj;
4255 fail:
4256 return NULL;
4257 }
4258
4259
4260 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4261 PyObject *resultobj;
4262 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4263 PyObject *result;
4264 PyObject * obj0 = 0 ;
4265 char *kwnames[] = {
4266 (char *) "self", NULL
4267 };
4268
4269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4271 if (SWIG_arg_fail(1)) SWIG_fail;
4272 {
4273 PyThreadState* __tstate = wxPyBeginAllowThreads();
4274 result = (PyObject *)wxRealPoint_Get(arg1);
4275
4276 wxPyEndAllowThreads(__tstate);
4277 if (PyErr_Occurred()) SWIG_fail;
4278 }
4279 resultobj = result;
4280 return resultobj;
4281 fail:
4282 return NULL;
4283 }
4284
4285
4286 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4287 PyObject *obj;
4288 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4289 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4290 Py_INCREF(obj);
4291 return Py_BuildValue((char *)"");
4292 }
4293 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4294 PyObject *resultobj;
4295 wxPoint *arg1 = (wxPoint *) 0 ;
4296 int arg2 ;
4297 PyObject * obj0 = 0 ;
4298 PyObject * obj1 = 0 ;
4299 char *kwnames[] = {
4300 (char *) "self",(char *) "x", NULL
4301 };
4302
4303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4305 if (SWIG_arg_fail(1)) SWIG_fail;
4306 {
4307 arg2 = (int)(SWIG_As_int(obj1));
4308 if (SWIG_arg_fail(2)) SWIG_fail;
4309 }
4310 if (arg1) (arg1)->x = arg2;
4311
4312 Py_INCREF(Py_None); resultobj = Py_None;
4313 return resultobj;
4314 fail:
4315 return NULL;
4316 }
4317
4318
4319 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4320 PyObject *resultobj;
4321 wxPoint *arg1 = (wxPoint *) 0 ;
4322 int result;
4323 PyObject * obj0 = 0 ;
4324 char *kwnames[] = {
4325 (char *) "self", NULL
4326 };
4327
4328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4330 if (SWIG_arg_fail(1)) SWIG_fail;
4331 result = (int) ((arg1)->x);
4332
4333 {
4334 resultobj = SWIG_From_int((int)(result));
4335 }
4336 return resultobj;
4337 fail:
4338 return NULL;
4339 }
4340
4341
4342 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4343 PyObject *resultobj;
4344 wxPoint *arg1 = (wxPoint *) 0 ;
4345 int arg2 ;
4346 PyObject * obj0 = 0 ;
4347 PyObject * obj1 = 0 ;
4348 char *kwnames[] = {
4349 (char *) "self",(char *) "y", NULL
4350 };
4351
4352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4354 if (SWIG_arg_fail(1)) SWIG_fail;
4355 {
4356 arg2 = (int)(SWIG_As_int(obj1));
4357 if (SWIG_arg_fail(2)) SWIG_fail;
4358 }
4359 if (arg1) (arg1)->y = arg2;
4360
4361 Py_INCREF(Py_None); resultobj = Py_None;
4362 return resultobj;
4363 fail:
4364 return NULL;
4365 }
4366
4367
4368 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4369 PyObject *resultobj;
4370 wxPoint *arg1 = (wxPoint *) 0 ;
4371 int result;
4372 PyObject * obj0 = 0 ;
4373 char *kwnames[] = {
4374 (char *) "self", NULL
4375 };
4376
4377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4379 if (SWIG_arg_fail(1)) SWIG_fail;
4380 result = (int) ((arg1)->y);
4381
4382 {
4383 resultobj = SWIG_From_int((int)(result));
4384 }
4385 return resultobj;
4386 fail:
4387 return NULL;
4388 }
4389
4390
4391 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4392 PyObject *resultobj;
4393 int arg1 = (int) 0 ;
4394 int arg2 = (int) 0 ;
4395 wxPoint *result;
4396 PyObject * obj0 = 0 ;
4397 PyObject * obj1 = 0 ;
4398 char *kwnames[] = {
4399 (char *) "x",(char *) "y", NULL
4400 };
4401
4402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4403 if (obj0) {
4404 {
4405 arg1 = (int)(SWIG_As_int(obj0));
4406 if (SWIG_arg_fail(1)) SWIG_fail;
4407 }
4408 }
4409 if (obj1) {
4410 {
4411 arg2 = (int)(SWIG_As_int(obj1));
4412 if (SWIG_arg_fail(2)) SWIG_fail;
4413 }
4414 }
4415 {
4416 PyThreadState* __tstate = wxPyBeginAllowThreads();
4417 result = (wxPoint *)new wxPoint(arg1,arg2);
4418
4419 wxPyEndAllowThreads(__tstate);
4420 if (PyErr_Occurred()) SWIG_fail;
4421 }
4422 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4423 return resultobj;
4424 fail:
4425 return NULL;
4426 }
4427
4428
4429 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4430 PyObject *resultobj;
4431 wxPoint *arg1 = (wxPoint *) 0 ;
4432 PyObject * obj0 = 0 ;
4433 char *kwnames[] = {
4434 (char *) "self", NULL
4435 };
4436
4437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4439 if (SWIG_arg_fail(1)) SWIG_fail;
4440 {
4441 PyThreadState* __tstate = wxPyBeginAllowThreads();
4442 delete arg1;
4443
4444 wxPyEndAllowThreads(__tstate);
4445 if (PyErr_Occurred()) SWIG_fail;
4446 }
4447 Py_INCREF(Py_None); resultobj = Py_None;
4448 return resultobj;
4449 fail:
4450 return NULL;
4451 }
4452
4453
4454 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4455 PyObject *resultobj;
4456 wxPoint *arg1 = (wxPoint *) 0 ;
4457 wxPoint *arg2 = 0 ;
4458 bool result;
4459 wxPoint temp2 ;
4460 PyObject * obj0 = 0 ;
4461 PyObject * obj1 = 0 ;
4462 char *kwnames[] = {
4463 (char *) "self",(char *) "pt", NULL
4464 };
4465
4466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4468 if (SWIG_arg_fail(1)) SWIG_fail;
4469 {
4470 arg2 = &temp2;
4471 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4472 }
4473 {
4474 PyThreadState* __tstate = wxPyBeginAllowThreads();
4475 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4476
4477 wxPyEndAllowThreads(__tstate);
4478 if (PyErr_Occurred()) SWIG_fail;
4479 }
4480 {
4481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4482 }
4483 return resultobj;
4484 fail:
4485 return NULL;
4486 }
4487
4488
4489 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4490 PyObject *resultobj;
4491 wxPoint *arg1 = (wxPoint *) 0 ;
4492 wxPoint *arg2 = 0 ;
4493 bool result;
4494 wxPoint temp2 ;
4495 PyObject * obj0 = 0 ;
4496 PyObject * obj1 = 0 ;
4497 char *kwnames[] = {
4498 (char *) "self",(char *) "pt", NULL
4499 };
4500
4501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4503 if (SWIG_arg_fail(1)) SWIG_fail;
4504 {
4505 arg2 = &temp2;
4506 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4507 }
4508 {
4509 PyThreadState* __tstate = wxPyBeginAllowThreads();
4510 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4511
4512 wxPyEndAllowThreads(__tstate);
4513 if (PyErr_Occurred()) SWIG_fail;
4514 }
4515 {
4516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4517 }
4518 return resultobj;
4519 fail:
4520 return NULL;
4521 }
4522
4523
4524 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4525 PyObject *resultobj;
4526 wxPoint *arg1 = (wxPoint *) 0 ;
4527 wxPoint *arg2 = 0 ;
4528 wxPoint result;
4529 wxPoint temp2 ;
4530 PyObject * obj0 = 0 ;
4531 PyObject * obj1 = 0 ;
4532 char *kwnames[] = {
4533 (char *) "self",(char *) "pt", NULL
4534 };
4535
4536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4538 if (SWIG_arg_fail(1)) SWIG_fail;
4539 {
4540 arg2 = &temp2;
4541 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4542 }
4543 {
4544 PyThreadState* __tstate = wxPyBeginAllowThreads();
4545 result = (arg1)->operator +((wxPoint const &)*arg2);
4546
4547 wxPyEndAllowThreads(__tstate);
4548 if (PyErr_Occurred()) SWIG_fail;
4549 }
4550 {
4551 wxPoint * resultptr;
4552 resultptr = new wxPoint((wxPoint &)(result));
4553 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4554 }
4555 return resultobj;
4556 fail:
4557 return NULL;
4558 }
4559
4560
4561 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4562 PyObject *resultobj;
4563 wxPoint *arg1 = (wxPoint *) 0 ;
4564 wxPoint *arg2 = 0 ;
4565 wxPoint result;
4566 wxPoint temp2 ;
4567 PyObject * obj0 = 0 ;
4568 PyObject * obj1 = 0 ;
4569 char *kwnames[] = {
4570 (char *) "self",(char *) "pt", NULL
4571 };
4572
4573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4575 if (SWIG_arg_fail(1)) SWIG_fail;
4576 {
4577 arg2 = &temp2;
4578 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4579 }
4580 {
4581 PyThreadState* __tstate = wxPyBeginAllowThreads();
4582 result = (arg1)->operator -((wxPoint const &)*arg2);
4583
4584 wxPyEndAllowThreads(__tstate);
4585 if (PyErr_Occurred()) SWIG_fail;
4586 }
4587 {
4588 wxPoint * resultptr;
4589 resultptr = new wxPoint((wxPoint &)(result));
4590 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4591 }
4592 return resultobj;
4593 fail:
4594 return NULL;
4595 }
4596
4597
4598 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4599 PyObject *resultobj;
4600 wxPoint *arg1 = (wxPoint *) 0 ;
4601 wxPoint *arg2 = 0 ;
4602 wxPoint *result;
4603 wxPoint temp2 ;
4604 PyObject * obj0 = 0 ;
4605 PyObject * obj1 = 0 ;
4606 char *kwnames[] = {
4607 (char *) "self",(char *) "pt", NULL
4608 };
4609
4610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4612 if (SWIG_arg_fail(1)) SWIG_fail;
4613 {
4614 arg2 = &temp2;
4615 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4616 }
4617 {
4618 PyThreadState* __tstate = wxPyBeginAllowThreads();
4619 {
4620 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4621 result = (wxPoint *) &_result_ref;
4622 }
4623
4624 wxPyEndAllowThreads(__tstate);
4625 if (PyErr_Occurred()) SWIG_fail;
4626 }
4627 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4628 return resultobj;
4629 fail:
4630 return NULL;
4631 }
4632
4633
4634 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4635 PyObject *resultobj;
4636 wxPoint *arg1 = (wxPoint *) 0 ;
4637 wxPoint *arg2 = 0 ;
4638 wxPoint *result;
4639 wxPoint temp2 ;
4640 PyObject * obj0 = 0 ;
4641 PyObject * obj1 = 0 ;
4642 char *kwnames[] = {
4643 (char *) "self",(char *) "pt", NULL
4644 };
4645
4646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4648 if (SWIG_arg_fail(1)) SWIG_fail;
4649 {
4650 arg2 = &temp2;
4651 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4652 }
4653 {
4654 PyThreadState* __tstate = wxPyBeginAllowThreads();
4655 {
4656 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4657 result = (wxPoint *) &_result_ref;
4658 }
4659
4660 wxPyEndAllowThreads(__tstate);
4661 if (PyErr_Occurred()) SWIG_fail;
4662 }
4663 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4664 return resultobj;
4665 fail:
4666 return NULL;
4667 }
4668
4669
4670 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4671 PyObject *resultobj;
4672 wxPoint *arg1 = (wxPoint *) 0 ;
4673 long arg2 ;
4674 long arg3 ;
4675 PyObject * obj0 = 0 ;
4676 PyObject * obj1 = 0 ;
4677 PyObject * obj2 = 0 ;
4678 char *kwnames[] = {
4679 (char *) "self",(char *) "x",(char *) "y", NULL
4680 };
4681
4682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4684 if (SWIG_arg_fail(1)) SWIG_fail;
4685 {
4686 arg2 = (long)(SWIG_As_long(obj1));
4687 if (SWIG_arg_fail(2)) SWIG_fail;
4688 }
4689 {
4690 arg3 = (long)(SWIG_As_long(obj2));
4691 if (SWIG_arg_fail(3)) SWIG_fail;
4692 }
4693 {
4694 PyThreadState* __tstate = wxPyBeginAllowThreads();
4695 wxPoint_Set(arg1,arg2,arg3);
4696
4697 wxPyEndAllowThreads(__tstate);
4698 if (PyErr_Occurred()) SWIG_fail;
4699 }
4700 Py_INCREF(Py_None); resultobj = Py_None;
4701 return resultobj;
4702 fail:
4703 return NULL;
4704 }
4705
4706
4707 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4708 PyObject *resultobj;
4709 wxPoint *arg1 = (wxPoint *) 0 ;
4710 PyObject *result;
4711 PyObject * obj0 = 0 ;
4712 char *kwnames[] = {
4713 (char *) "self", NULL
4714 };
4715
4716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4718 if (SWIG_arg_fail(1)) SWIG_fail;
4719 {
4720 PyThreadState* __tstate = wxPyBeginAllowThreads();
4721 result = (PyObject *)wxPoint_Get(arg1);
4722
4723 wxPyEndAllowThreads(__tstate);
4724 if (PyErr_Occurred()) SWIG_fail;
4725 }
4726 resultobj = result;
4727 return resultobj;
4728 fail:
4729 return NULL;
4730 }
4731
4732
4733 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4734 PyObject *obj;
4735 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4736 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4737 Py_INCREF(obj);
4738 return Py_BuildValue((char *)"");
4739 }
4740 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4741 PyObject *resultobj;
4742 int arg1 = (int) 0 ;
4743 int arg2 = (int) 0 ;
4744 int arg3 = (int) 0 ;
4745 int arg4 = (int) 0 ;
4746 wxRect *result;
4747 PyObject * obj0 = 0 ;
4748 PyObject * obj1 = 0 ;
4749 PyObject * obj2 = 0 ;
4750 PyObject * obj3 = 0 ;
4751 char *kwnames[] = {
4752 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4753 };
4754
4755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4756 if (obj0) {
4757 {
4758 arg1 = (int)(SWIG_As_int(obj0));
4759 if (SWIG_arg_fail(1)) SWIG_fail;
4760 }
4761 }
4762 if (obj1) {
4763 {
4764 arg2 = (int)(SWIG_As_int(obj1));
4765 if (SWIG_arg_fail(2)) SWIG_fail;
4766 }
4767 }
4768 if (obj2) {
4769 {
4770 arg3 = (int)(SWIG_As_int(obj2));
4771 if (SWIG_arg_fail(3)) SWIG_fail;
4772 }
4773 }
4774 if (obj3) {
4775 {
4776 arg4 = (int)(SWIG_As_int(obj3));
4777 if (SWIG_arg_fail(4)) SWIG_fail;
4778 }
4779 }
4780 {
4781 PyThreadState* __tstate = wxPyBeginAllowThreads();
4782 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4783
4784 wxPyEndAllowThreads(__tstate);
4785 if (PyErr_Occurred()) SWIG_fail;
4786 }
4787 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4788 return resultobj;
4789 fail:
4790 return NULL;
4791 }
4792
4793
4794 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4795 PyObject *resultobj;
4796 wxPoint *arg1 = 0 ;
4797 wxPoint *arg2 = 0 ;
4798 wxRect *result;
4799 wxPoint temp1 ;
4800 wxPoint temp2 ;
4801 PyObject * obj0 = 0 ;
4802 PyObject * obj1 = 0 ;
4803 char *kwnames[] = {
4804 (char *) "topLeft",(char *) "bottomRight", NULL
4805 };
4806
4807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4808 {
4809 arg1 = &temp1;
4810 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4811 }
4812 {
4813 arg2 = &temp2;
4814 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4815 }
4816 {
4817 PyThreadState* __tstate = wxPyBeginAllowThreads();
4818 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4819
4820 wxPyEndAllowThreads(__tstate);
4821 if (PyErr_Occurred()) SWIG_fail;
4822 }
4823 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4824 return resultobj;
4825 fail:
4826 return NULL;
4827 }
4828
4829
4830 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4831 PyObject *resultobj;
4832 wxPoint *arg1 = 0 ;
4833 wxSize *arg2 = 0 ;
4834 wxRect *result;
4835 wxPoint temp1 ;
4836 wxSize temp2 ;
4837 PyObject * obj0 = 0 ;
4838 PyObject * obj1 = 0 ;
4839 char *kwnames[] = {
4840 (char *) "pos",(char *) "size", NULL
4841 };
4842
4843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4844 {
4845 arg1 = &temp1;
4846 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4847 }
4848 {
4849 arg2 = &temp2;
4850 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4851 }
4852 {
4853 PyThreadState* __tstate = wxPyBeginAllowThreads();
4854 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4855
4856 wxPyEndAllowThreads(__tstate);
4857 if (PyErr_Occurred()) SWIG_fail;
4858 }
4859 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4860 return resultobj;
4861 fail:
4862 return NULL;
4863 }
4864
4865
4866 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4867 PyObject *resultobj;
4868 wxSize *arg1 = 0 ;
4869 wxRect *result;
4870 wxSize temp1 ;
4871 PyObject * obj0 = 0 ;
4872 char *kwnames[] = {
4873 (char *) "size", NULL
4874 };
4875
4876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4877 {
4878 arg1 = &temp1;
4879 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4880 }
4881 {
4882 PyThreadState* __tstate = wxPyBeginAllowThreads();
4883 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4884
4885 wxPyEndAllowThreads(__tstate);
4886 if (PyErr_Occurred()) SWIG_fail;
4887 }
4888 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4889 return resultobj;
4890 fail:
4891 return NULL;
4892 }
4893
4894
4895 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4896 PyObject *resultobj;
4897 wxRect *arg1 = (wxRect *) 0 ;
4898 PyObject * obj0 = 0 ;
4899 char *kwnames[] = {
4900 (char *) "self", NULL
4901 };
4902
4903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4905 if (SWIG_arg_fail(1)) SWIG_fail;
4906 {
4907 PyThreadState* __tstate = wxPyBeginAllowThreads();
4908 delete arg1;
4909
4910 wxPyEndAllowThreads(__tstate);
4911 if (PyErr_Occurred()) SWIG_fail;
4912 }
4913 Py_INCREF(Py_None); resultobj = Py_None;
4914 return resultobj;
4915 fail:
4916 return NULL;
4917 }
4918
4919
4920 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4921 PyObject *resultobj;
4922 wxRect *arg1 = (wxRect *) 0 ;
4923 int result;
4924 PyObject * obj0 = 0 ;
4925 char *kwnames[] = {
4926 (char *) "self", NULL
4927 };
4928
4929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4931 if (SWIG_arg_fail(1)) SWIG_fail;
4932 {
4933 PyThreadState* __tstate = wxPyBeginAllowThreads();
4934 result = (int)((wxRect const *)arg1)->GetX();
4935
4936 wxPyEndAllowThreads(__tstate);
4937 if (PyErr_Occurred()) SWIG_fail;
4938 }
4939 {
4940 resultobj = SWIG_From_int((int)(result));
4941 }
4942 return resultobj;
4943 fail:
4944 return NULL;
4945 }
4946
4947
4948 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4949 PyObject *resultobj;
4950 wxRect *arg1 = (wxRect *) 0 ;
4951 int arg2 ;
4952 PyObject * obj0 = 0 ;
4953 PyObject * obj1 = 0 ;
4954 char *kwnames[] = {
4955 (char *) "self",(char *) "x", NULL
4956 };
4957
4958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4960 if (SWIG_arg_fail(1)) SWIG_fail;
4961 {
4962 arg2 = (int)(SWIG_As_int(obj1));
4963 if (SWIG_arg_fail(2)) SWIG_fail;
4964 }
4965 {
4966 PyThreadState* __tstate = wxPyBeginAllowThreads();
4967 (arg1)->SetX(arg2);
4968
4969 wxPyEndAllowThreads(__tstate);
4970 if (PyErr_Occurred()) SWIG_fail;
4971 }
4972 Py_INCREF(Py_None); resultobj = Py_None;
4973 return resultobj;
4974 fail:
4975 return NULL;
4976 }
4977
4978
4979 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
4980 PyObject *resultobj;
4981 wxRect *arg1 = (wxRect *) 0 ;
4982 int result;
4983 PyObject * obj0 = 0 ;
4984 char *kwnames[] = {
4985 (char *) "self", NULL
4986 };
4987
4988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
4989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4990 if (SWIG_arg_fail(1)) SWIG_fail;
4991 {
4992 PyThreadState* __tstate = wxPyBeginAllowThreads();
4993 result = (int)(arg1)->GetY();
4994
4995 wxPyEndAllowThreads(__tstate);
4996 if (PyErr_Occurred()) SWIG_fail;
4997 }
4998 {
4999 resultobj = SWIG_From_int((int)(result));
5000 }
5001 return resultobj;
5002 fail:
5003 return NULL;
5004 }
5005
5006
5007 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5008 PyObject *resultobj;
5009 wxRect *arg1 = (wxRect *) 0 ;
5010 int arg2 ;
5011 PyObject * obj0 = 0 ;
5012 PyObject * obj1 = 0 ;
5013 char *kwnames[] = {
5014 (char *) "self",(char *) "y", NULL
5015 };
5016
5017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5019 if (SWIG_arg_fail(1)) SWIG_fail;
5020 {
5021 arg2 = (int)(SWIG_As_int(obj1));
5022 if (SWIG_arg_fail(2)) SWIG_fail;
5023 }
5024 {
5025 PyThreadState* __tstate = wxPyBeginAllowThreads();
5026 (arg1)->SetY(arg2);
5027
5028 wxPyEndAllowThreads(__tstate);
5029 if (PyErr_Occurred()) SWIG_fail;
5030 }
5031 Py_INCREF(Py_None); resultobj = Py_None;
5032 return resultobj;
5033 fail:
5034 return NULL;
5035 }
5036
5037
5038 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5039 PyObject *resultobj;
5040 wxRect *arg1 = (wxRect *) 0 ;
5041 int result;
5042 PyObject * obj0 = 0 ;
5043 char *kwnames[] = {
5044 (char *) "self", NULL
5045 };
5046
5047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5049 if (SWIG_arg_fail(1)) SWIG_fail;
5050 {
5051 PyThreadState* __tstate = wxPyBeginAllowThreads();
5052 result = (int)((wxRect const *)arg1)->GetWidth();
5053
5054 wxPyEndAllowThreads(__tstate);
5055 if (PyErr_Occurred()) SWIG_fail;
5056 }
5057 {
5058 resultobj = SWIG_From_int((int)(result));
5059 }
5060 return resultobj;
5061 fail:
5062 return NULL;
5063 }
5064
5065
5066 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5067 PyObject *resultobj;
5068 wxRect *arg1 = (wxRect *) 0 ;
5069 int arg2 ;
5070 PyObject * obj0 = 0 ;
5071 PyObject * obj1 = 0 ;
5072 char *kwnames[] = {
5073 (char *) "self",(char *) "w", NULL
5074 };
5075
5076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5078 if (SWIG_arg_fail(1)) SWIG_fail;
5079 {
5080 arg2 = (int)(SWIG_As_int(obj1));
5081 if (SWIG_arg_fail(2)) SWIG_fail;
5082 }
5083 {
5084 PyThreadState* __tstate = wxPyBeginAllowThreads();
5085 (arg1)->SetWidth(arg2);
5086
5087 wxPyEndAllowThreads(__tstate);
5088 if (PyErr_Occurred()) SWIG_fail;
5089 }
5090 Py_INCREF(Py_None); resultobj = Py_None;
5091 return resultobj;
5092 fail:
5093 return NULL;
5094 }
5095
5096
5097 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5098 PyObject *resultobj;
5099 wxRect *arg1 = (wxRect *) 0 ;
5100 int result;
5101 PyObject * obj0 = 0 ;
5102 char *kwnames[] = {
5103 (char *) "self", NULL
5104 };
5105
5106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5108 if (SWIG_arg_fail(1)) SWIG_fail;
5109 {
5110 PyThreadState* __tstate = wxPyBeginAllowThreads();
5111 result = (int)((wxRect const *)arg1)->GetHeight();
5112
5113 wxPyEndAllowThreads(__tstate);
5114 if (PyErr_Occurred()) SWIG_fail;
5115 }
5116 {
5117 resultobj = SWIG_From_int((int)(result));
5118 }
5119 return resultobj;
5120 fail:
5121 return NULL;
5122 }
5123
5124
5125 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5126 PyObject *resultobj;
5127 wxRect *arg1 = (wxRect *) 0 ;
5128 int arg2 ;
5129 PyObject * obj0 = 0 ;
5130 PyObject * obj1 = 0 ;
5131 char *kwnames[] = {
5132 (char *) "self",(char *) "h", NULL
5133 };
5134
5135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5137 if (SWIG_arg_fail(1)) SWIG_fail;
5138 {
5139 arg2 = (int)(SWIG_As_int(obj1));
5140 if (SWIG_arg_fail(2)) SWIG_fail;
5141 }
5142 {
5143 PyThreadState* __tstate = wxPyBeginAllowThreads();
5144 (arg1)->SetHeight(arg2);
5145
5146 wxPyEndAllowThreads(__tstate);
5147 if (PyErr_Occurred()) SWIG_fail;
5148 }
5149 Py_INCREF(Py_None); resultobj = Py_None;
5150 return resultobj;
5151 fail:
5152 return NULL;
5153 }
5154
5155
5156 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5157 PyObject *resultobj;
5158 wxRect *arg1 = (wxRect *) 0 ;
5159 wxPoint result;
5160 PyObject * obj0 = 0 ;
5161 char *kwnames[] = {
5162 (char *) "self", NULL
5163 };
5164
5165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5167 if (SWIG_arg_fail(1)) SWIG_fail;
5168 {
5169 PyThreadState* __tstate = wxPyBeginAllowThreads();
5170 result = ((wxRect const *)arg1)->GetPosition();
5171
5172 wxPyEndAllowThreads(__tstate);
5173 if (PyErr_Occurred()) SWIG_fail;
5174 }
5175 {
5176 wxPoint * resultptr;
5177 resultptr = new wxPoint((wxPoint &)(result));
5178 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5179 }
5180 return resultobj;
5181 fail:
5182 return NULL;
5183 }
5184
5185
5186 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5187 PyObject *resultobj;
5188 wxRect *arg1 = (wxRect *) 0 ;
5189 wxPoint *arg2 = 0 ;
5190 wxPoint temp2 ;
5191 PyObject * obj0 = 0 ;
5192 PyObject * obj1 = 0 ;
5193 char *kwnames[] = {
5194 (char *) "self",(char *) "p", NULL
5195 };
5196
5197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5199 if (SWIG_arg_fail(1)) SWIG_fail;
5200 {
5201 arg2 = &temp2;
5202 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5203 }
5204 {
5205 PyThreadState* __tstate = wxPyBeginAllowThreads();
5206 (arg1)->SetPosition((wxPoint const &)*arg2);
5207
5208 wxPyEndAllowThreads(__tstate);
5209 if (PyErr_Occurred()) SWIG_fail;
5210 }
5211 Py_INCREF(Py_None); resultobj = Py_None;
5212 return resultobj;
5213 fail:
5214 return NULL;
5215 }
5216
5217
5218 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5219 PyObject *resultobj;
5220 wxRect *arg1 = (wxRect *) 0 ;
5221 wxSize result;
5222 PyObject * obj0 = 0 ;
5223 char *kwnames[] = {
5224 (char *) "self", NULL
5225 };
5226
5227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5229 if (SWIG_arg_fail(1)) SWIG_fail;
5230 {
5231 PyThreadState* __tstate = wxPyBeginAllowThreads();
5232 result = ((wxRect const *)arg1)->GetSize();
5233
5234 wxPyEndAllowThreads(__tstate);
5235 if (PyErr_Occurred()) SWIG_fail;
5236 }
5237 {
5238 wxSize * resultptr;
5239 resultptr = new wxSize((wxSize &)(result));
5240 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5241 }
5242 return resultobj;
5243 fail:
5244 return NULL;
5245 }
5246
5247
5248 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5249 PyObject *resultobj;
5250 wxRect *arg1 = (wxRect *) 0 ;
5251 wxSize *arg2 = 0 ;
5252 wxSize temp2 ;
5253 PyObject * obj0 = 0 ;
5254 PyObject * obj1 = 0 ;
5255 char *kwnames[] = {
5256 (char *) "self",(char *) "s", NULL
5257 };
5258
5259 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5260 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5261 if (SWIG_arg_fail(1)) SWIG_fail;
5262 {
5263 arg2 = &temp2;
5264 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5265 }
5266 {
5267 PyThreadState* __tstate = wxPyBeginAllowThreads();
5268 (arg1)->SetSize((wxSize const &)*arg2);
5269
5270 wxPyEndAllowThreads(__tstate);
5271 if (PyErr_Occurred()) SWIG_fail;
5272 }
5273 Py_INCREF(Py_None); resultobj = Py_None;
5274 return resultobj;
5275 fail:
5276 return NULL;
5277 }
5278
5279
5280 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5281 PyObject *resultobj;
5282 wxRect *arg1 = (wxRect *) 0 ;
5283 wxPoint result;
5284 PyObject * obj0 = 0 ;
5285 char *kwnames[] = {
5286 (char *) "self", NULL
5287 };
5288
5289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5290 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5291 if (SWIG_arg_fail(1)) SWIG_fail;
5292 {
5293 PyThreadState* __tstate = wxPyBeginAllowThreads();
5294 result = ((wxRect const *)arg1)->GetTopLeft();
5295
5296 wxPyEndAllowThreads(__tstate);
5297 if (PyErr_Occurred()) SWIG_fail;
5298 }
5299 {
5300 wxPoint * resultptr;
5301 resultptr = new wxPoint((wxPoint &)(result));
5302 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5303 }
5304 return resultobj;
5305 fail:
5306 return NULL;
5307 }
5308
5309
5310 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5311 PyObject *resultobj;
5312 wxRect *arg1 = (wxRect *) 0 ;
5313 wxPoint *arg2 = 0 ;
5314 wxPoint temp2 ;
5315 PyObject * obj0 = 0 ;
5316 PyObject * obj1 = 0 ;
5317 char *kwnames[] = {
5318 (char *) "self",(char *) "p", NULL
5319 };
5320
5321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5323 if (SWIG_arg_fail(1)) SWIG_fail;
5324 {
5325 arg2 = &temp2;
5326 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5327 }
5328 {
5329 PyThreadState* __tstate = wxPyBeginAllowThreads();
5330 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5331
5332 wxPyEndAllowThreads(__tstate);
5333 if (PyErr_Occurred()) SWIG_fail;
5334 }
5335 Py_INCREF(Py_None); resultobj = Py_None;
5336 return resultobj;
5337 fail:
5338 return NULL;
5339 }
5340
5341
5342 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5343 PyObject *resultobj;
5344 wxRect *arg1 = (wxRect *) 0 ;
5345 wxPoint result;
5346 PyObject * obj0 = 0 ;
5347 char *kwnames[] = {
5348 (char *) "self", NULL
5349 };
5350
5351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5353 if (SWIG_arg_fail(1)) SWIG_fail;
5354 {
5355 PyThreadState* __tstate = wxPyBeginAllowThreads();
5356 result = ((wxRect const *)arg1)->GetBottomRight();
5357
5358 wxPyEndAllowThreads(__tstate);
5359 if (PyErr_Occurred()) SWIG_fail;
5360 }
5361 {
5362 wxPoint * resultptr;
5363 resultptr = new wxPoint((wxPoint &)(result));
5364 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5365 }
5366 return resultobj;
5367 fail:
5368 return NULL;
5369 }
5370
5371
5372 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5373 PyObject *resultobj;
5374 wxRect *arg1 = (wxRect *) 0 ;
5375 wxPoint *arg2 = 0 ;
5376 wxPoint temp2 ;
5377 PyObject * obj0 = 0 ;
5378 PyObject * obj1 = 0 ;
5379 char *kwnames[] = {
5380 (char *) "self",(char *) "p", NULL
5381 };
5382
5383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5385 if (SWIG_arg_fail(1)) SWIG_fail;
5386 {
5387 arg2 = &temp2;
5388 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5389 }
5390 {
5391 PyThreadState* __tstate = wxPyBeginAllowThreads();
5392 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5393
5394 wxPyEndAllowThreads(__tstate);
5395 if (PyErr_Occurred()) SWIG_fail;
5396 }
5397 Py_INCREF(Py_None); resultobj = Py_None;
5398 return resultobj;
5399 fail:
5400 return NULL;
5401 }
5402
5403
5404 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5405 PyObject *resultobj;
5406 wxRect *arg1 = (wxRect *) 0 ;
5407 int result;
5408 PyObject * obj0 = 0 ;
5409 char *kwnames[] = {
5410 (char *) "self", NULL
5411 };
5412
5413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5415 if (SWIG_arg_fail(1)) SWIG_fail;
5416 {
5417 PyThreadState* __tstate = wxPyBeginAllowThreads();
5418 result = (int)((wxRect const *)arg1)->GetLeft();
5419
5420 wxPyEndAllowThreads(__tstate);
5421 if (PyErr_Occurred()) SWIG_fail;
5422 }
5423 {
5424 resultobj = SWIG_From_int((int)(result));
5425 }
5426 return resultobj;
5427 fail:
5428 return NULL;
5429 }
5430
5431
5432 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5433 PyObject *resultobj;
5434 wxRect *arg1 = (wxRect *) 0 ;
5435 int result;
5436 PyObject * obj0 = 0 ;
5437 char *kwnames[] = {
5438 (char *) "self", NULL
5439 };
5440
5441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5443 if (SWIG_arg_fail(1)) SWIG_fail;
5444 {
5445 PyThreadState* __tstate = wxPyBeginAllowThreads();
5446 result = (int)((wxRect const *)arg1)->GetTop();
5447
5448 wxPyEndAllowThreads(__tstate);
5449 if (PyErr_Occurred()) SWIG_fail;
5450 }
5451 {
5452 resultobj = SWIG_From_int((int)(result));
5453 }
5454 return resultobj;
5455 fail:
5456 return NULL;
5457 }
5458
5459
5460 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5461 PyObject *resultobj;
5462 wxRect *arg1 = (wxRect *) 0 ;
5463 int result;
5464 PyObject * obj0 = 0 ;
5465 char *kwnames[] = {
5466 (char *) "self", NULL
5467 };
5468
5469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5471 if (SWIG_arg_fail(1)) SWIG_fail;
5472 {
5473 PyThreadState* __tstate = wxPyBeginAllowThreads();
5474 result = (int)((wxRect const *)arg1)->GetBottom();
5475
5476 wxPyEndAllowThreads(__tstate);
5477 if (PyErr_Occurred()) SWIG_fail;
5478 }
5479 {
5480 resultobj = SWIG_From_int((int)(result));
5481 }
5482 return resultobj;
5483 fail:
5484 return NULL;
5485 }
5486
5487
5488 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5489 PyObject *resultobj;
5490 wxRect *arg1 = (wxRect *) 0 ;
5491 int result;
5492 PyObject * obj0 = 0 ;
5493 char *kwnames[] = {
5494 (char *) "self", NULL
5495 };
5496
5497 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5498 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5499 if (SWIG_arg_fail(1)) SWIG_fail;
5500 {
5501 PyThreadState* __tstate = wxPyBeginAllowThreads();
5502 result = (int)((wxRect const *)arg1)->GetRight();
5503
5504 wxPyEndAllowThreads(__tstate);
5505 if (PyErr_Occurred()) SWIG_fail;
5506 }
5507 {
5508 resultobj = SWIG_From_int((int)(result));
5509 }
5510 return resultobj;
5511 fail:
5512 return NULL;
5513 }
5514
5515
5516 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5517 PyObject *resultobj;
5518 wxRect *arg1 = (wxRect *) 0 ;
5519 int arg2 ;
5520 PyObject * obj0 = 0 ;
5521 PyObject * obj1 = 0 ;
5522 char *kwnames[] = {
5523 (char *) "self",(char *) "left", NULL
5524 };
5525
5526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5528 if (SWIG_arg_fail(1)) SWIG_fail;
5529 {
5530 arg2 = (int)(SWIG_As_int(obj1));
5531 if (SWIG_arg_fail(2)) SWIG_fail;
5532 }
5533 {
5534 PyThreadState* __tstate = wxPyBeginAllowThreads();
5535 (arg1)->SetLeft(arg2);
5536
5537 wxPyEndAllowThreads(__tstate);
5538 if (PyErr_Occurred()) SWIG_fail;
5539 }
5540 Py_INCREF(Py_None); resultobj = Py_None;
5541 return resultobj;
5542 fail:
5543 return NULL;
5544 }
5545
5546
5547 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5548 PyObject *resultobj;
5549 wxRect *arg1 = (wxRect *) 0 ;
5550 int arg2 ;
5551 PyObject * obj0 = 0 ;
5552 PyObject * obj1 = 0 ;
5553 char *kwnames[] = {
5554 (char *) "self",(char *) "right", NULL
5555 };
5556
5557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5559 if (SWIG_arg_fail(1)) SWIG_fail;
5560 {
5561 arg2 = (int)(SWIG_As_int(obj1));
5562 if (SWIG_arg_fail(2)) SWIG_fail;
5563 }
5564 {
5565 PyThreadState* __tstate = wxPyBeginAllowThreads();
5566 (arg1)->SetRight(arg2);
5567
5568 wxPyEndAllowThreads(__tstate);
5569 if (PyErr_Occurred()) SWIG_fail;
5570 }
5571 Py_INCREF(Py_None); resultobj = Py_None;
5572 return resultobj;
5573 fail:
5574 return NULL;
5575 }
5576
5577
5578 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5579 PyObject *resultobj;
5580 wxRect *arg1 = (wxRect *) 0 ;
5581 int arg2 ;
5582 PyObject * obj0 = 0 ;
5583 PyObject * obj1 = 0 ;
5584 char *kwnames[] = {
5585 (char *) "self",(char *) "top", NULL
5586 };
5587
5588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5590 if (SWIG_arg_fail(1)) SWIG_fail;
5591 {
5592 arg2 = (int)(SWIG_As_int(obj1));
5593 if (SWIG_arg_fail(2)) SWIG_fail;
5594 }
5595 {
5596 PyThreadState* __tstate = wxPyBeginAllowThreads();
5597 (arg1)->SetTop(arg2);
5598
5599 wxPyEndAllowThreads(__tstate);
5600 if (PyErr_Occurred()) SWIG_fail;
5601 }
5602 Py_INCREF(Py_None); resultobj = Py_None;
5603 return resultobj;
5604 fail:
5605 return NULL;
5606 }
5607
5608
5609 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5610 PyObject *resultobj;
5611 wxRect *arg1 = (wxRect *) 0 ;
5612 int arg2 ;
5613 PyObject * obj0 = 0 ;
5614 PyObject * obj1 = 0 ;
5615 char *kwnames[] = {
5616 (char *) "self",(char *) "bottom", NULL
5617 };
5618
5619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5621 if (SWIG_arg_fail(1)) SWIG_fail;
5622 {
5623 arg2 = (int)(SWIG_As_int(obj1));
5624 if (SWIG_arg_fail(2)) SWIG_fail;
5625 }
5626 {
5627 PyThreadState* __tstate = wxPyBeginAllowThreads();
5628 (arg1)->SetBottom(arg2);
5629
5630 wxPyEndAllowThreads(__tstate);
5631 if (PyErr_Occurred()) SWIG_fail;
5632 }
5633 Py_INCREF(Py_None); resultobj = Py_None;
5634 return resultobj;
5635 fail:
5636 return NULL;
5637 }
5638
5639
5640 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5641 PyObject *resultobj;
5642 wxRect *arg1 = (wxRect *) 0 ;
5643 int arg2 ;
5644 int arg3 ;
5645 wxRect *result;
5646 PyObject * obj0 = 0 ;
5647 PyObject * obj1 = 0 ;
5648 PyObject * obj2 = 0 ;
5649 char *kwnames[] = {
5650 (char *) "self",(char *) "dx",(char *) "dy", NULL
5651 };
5652
5653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5655 if (SWIG_arg_fail(1)) SWIG_fail;
5656 {
5657 arg2 = (int)(SWIG_As_int(obj1));
5658 if (SWIG_arg_fail(2)) SWIG_fail;
5659 }
5660 {
5661 arg3 = (int)(SWIG_As_int(obj2));
5662 if (SWIG_arg_fail(3)) SWIG_fail;
5663 }
5664 {
5665 PyThreadState* __tstate = wxPyBeginAllowThreads();
5666 {
5667 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5668 result = (wxRect *) &_result_ref;
5669 }
5670
5671 wxPyEndAllowThreads(__tstate);
5672 if (PyErr_Occurred()) SWIG_fail;
5673 }
5674 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5675 return resultobj;
5676 fail:
5677 return NULL;
5678 }
5679
5680
5681 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5682 PyObject *resultobj;
5683 wxRect *arg1 = (wxRect *) 0 ;
5684 int arg2 ;
5685 int arg3 ;
5686 wxRect *result;
5687 PyObject * obj0 = 0 ;
5688 PyObject * obj1 = 0 ;
5689 PyObject * obj2 = 0 ;
5690 char *kwnames[] = {
5691 (char *) "self",(char *) "dx",(char *) "dy", NULL
5692 };
5693
5694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5696 if (SWIG_arg_fail(1)) SWIG_fail;
5697 {
5698 arg2 = (int)(SWIG_As_int(obj1));
5699 if (SWIG_arg_fail(2)) SWIG_fail;
5700 }
5701 {
5702 arg3 = (int)(SWIG_As_int(obj2));
5703 if (SWIG_arg_fail(3)) SWIG_fail;
5704 }
5705 {
5706 PyThreadState* __tstate = wxPyBeginAllowThreads();
5707 {
5708 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5709 result = (wxRect *) &_result_ref;
5710 }
5711
5712 wxPyEndAllowThreads(__tstate);
5713 if (PyErr_Occurred()) SWIG_fail;
5714 }
5715 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5716 return resultobj;
5717 fail:
5718 return NULL;
5719 }
5720
5721
5722 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5723 PyObject *resultobj;
5724 wxRect *arg1 = (wxRect *) 0 ;
5725 int arg2 ;
5726 int arg3 ;
5727 PyObject * obj0 = 0 ;
5728 PyObject * obj1 = 0 ;
5729 PyObject * obj2 = 0 ;
5730 char *kwnames[] = {
5731 (char *) "self",(char *) "dx",(char *) "dy", NULL
5732 };
5733
5734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5736 if (SWIG_arg_fail(1)) SWIG_fail;
5737 {
5738 arg2 = (int)(SWIG_As_int(obj1));
5739 if (SWIG_arg_fail(2)) SWIG_fail;
5740 }
5741 {
5742 arg3 = (int)(SWIG_As_int(obj2));
5743 if (SWIG_arg_fail(3)) SWIG_fail;
5744 }
5745 {
5746 PyThreadState* __tstate = wxPyBeginAllowThreads();
5747 (arg1)->Offset(arg2,arg3);
5748
5749 wxPyEndAllowThreads(__tstate);
5750 if (PyErr_Occurred()) SWIG_fail;
5751 }
5752 Py_INCREF(Py_None); resultobj = Py_None;
5753 return resultobj;
5754 fail:
5755 return NULL;
5756 }
5757
5758
5759 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5760 PyObject *resultobj;
5761 wxRect *arg1 = (wxRect *) 0 ;
5762 wxPoint *arg2 = 0 ;
5763 wxPoint temp2 ;
5764 PyObject * obj0 = 0 ;
5765 PyObject * obj1 = 0 ;
5766 char *kwnames[] = {
5767 (char *) "self",(char *) "pt", NULL
5768 };
5769
5770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5772 if (SWIG_arg_fail(1)) SWIG_fail;
5773 {
5774 arg2 = &temp2;
5775 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5776 }
5777 {
5778 PyThreadState* __tstate = wxPyBeginAllowThreads();
5779 (arg1)->Offset((wxPoint const &)*arg2);
5780
5781 wxPyEndAllowThreads(__tstate);
5782 if (PyErr_Occurred()) SWIG_fail;
5783 }
5784 Py_INCREF(Py_None); resultobj = Py_None;
5785 return resultobj;
5786 fail:
5787 return NULL;
5788 }
5789
5790
5791 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5792 PyObject *resultobj;
5793 wxRect *arg1 = (wxRect *) 0 ;
5794 wxRect *arg2 = 0 ;
5795 wxRect result;
5796 wxRect temp2 ;
5797 PyObject * obj0 = 0 ;
5798 PyObject * obj1 = 0 ;
5799 char *kwnames[] = {
5800 (char *) "self",(char *) "rect", NULL
5801 };
5802
5803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5805 if (SWIG_arg_fail(1)) SWIG_fail;
5806 {
5807 arg2 = &temp2;
5808 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5809 }
5810 {
5811 PyThreadState* __tstate = wxPyBeginAllowThreads();
5812 result = (arg1)->Intersect((wxRect const &)*arg2);
5813
5814 wxPyEndAllowThreads(__tstate);
5815 if (PyErr_Occurred()) SWIG_fail;
5816 }
5817 {
5818 wxRect * resultptr;
5819 resultptr = new wxRect((wxRect &)(result));
5820 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5821 }
5822 return resultobj;
5823 fail:
5824 return NULL;
5825 }
5826
5827
5828 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5829 PyObject *resultobj;
5830 wxRect *arg1 = (wxRect *) 0 ;
5831 wxRect *arg2 = 0 ;
5832 wxRect result;
5833 wxRect temp2 ;
5834 PyObject * obj0 = 0 ;
5835 PyObject * obj1 = 0 ;
5836 char *kwnames[] = {
5837 (char *) "self",(char *) "rect", NULL
5838 };
5839
5840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5842 if (SWIG_arg_fail(1)) SWIG_fail;
5843 {
5844 arg2 = &temp2;
5845 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5846 }
5847 {
5848 PyThreadState* __tstate = wxPyBeginAllowThreads();
5849 result = (arg1)->Union((wxRect const &)*arg2);
5850
5851 wxPyEndAllowThreads(__tstate);
5852 if (PyErr_Occurred()) SWIG_fail;
5853 }
5854 {
5855 wxRect * resultptr;
5856 resultptr = new wxRect((wxRect &)(result));
5857 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5858 }
5859 return resultobj;
5860 fail:
5861 return NULL;
5862 }
5863
5864
5865 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5866 PyObject *resultobj;
5867 wxRect *arg1 = (wxRect *) 0 ;
5868 wxRect *arg2 = 0 ;
5869 wxRect result;
5870 wxRect temp2 ;
5871 PyObject * obj0 = 0 ;
5872 PyObject * obj1 = 0 ;
5873 char *kwnames[] = {
5874 (char *) "self",(char *) "rect", NULL
5875 };
5876
5877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5879 if (SWIG_arg_fail(1)) SWIG_fail;
5880 {
5881 arg2 = &temp2;
5882 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5883 }
5884 {
5885 PyThreadState* __tstate = wxPyBeginAllowThreads();
5886 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5887
5888 wxPyEndAllowThreads(__tstate);
5889 if (PyErr_Occurred()) SWIG_fail;
5890 }
5891 {
5892 wxRect * resultptr;
5893 resultptr = new wxRect((wxRect &)(result));
5894 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5895 }
5896 return resultobj;
5897 fail:
5898 return NULL;
5899 }
5900
5901
5902 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5903 PyObject *resultobj;
5904 wxRect *arg1 = (wxRect *) 0 ;
5905 wxRect *arg2 = 0 ;
5906 wxRect *result;
5907 wxRect temp2 ;
5908 PyObject * obj0 = 0 ;
5909 PyObject * obj1 = 0 ;
5910 char *kwnames[] = {
5911 (char *) "self",(char *) "rect", NULL
5912 };
5913
5914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5916 if (SWIG_arg_fail(1)) SWIG_fail;
5917 {
5918 arg2 = &temp2;
5919 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5920 }
5921 {
5922 PyThreadState* __tstate = wxPyBeginAllowThreads();
5923 {
5924 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5925 result = (wxRect *) &_result_ref;
5926 }
5927
5928 wxPyEndAllowThreads(__tstate);
5929 if (PyErr_Occurred()) SWIG_fail;
5930 }
5931 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5932 return resultobj;
5933 fail:
5934 return NULL;
5935 }
5936
5937
5938 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
5939 PyObject *resultobj;
5940 wxRect *arg1 = (wxRect *) 0 ;
5941 wxRect *arg2 = 0 ;
5942 bool result;
5943 wxRect temp2 ;
5944 PyObject * obj0 = 0 ;
5945 PyObject * obj1 = 0 ;
5946 char *kwnames[] = {
5947 (char *) "self",(char *) "rect", NULL
5948 };
5949
5950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
5951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5952 if (SWIG_arg_fail(1)) SWIG_fail;
5953 {
5954 arg2 = &temp2;
5955 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5956 }
5957 {
5958 PyThreadState* __tstate = wxPyBeginAllowThreads();
5959 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
5960
5961 wxPyEndAllowThreads(__tstate);
5962 if (PyErr_Occurred()) SWIG_fail;
5963 }
5964 {
5965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5966 }
5967 return resultobj;
5968 fail:
5969 return NULL;
5970 }
5971
5972
5973 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
5974 PyObject *resultobj;
5975 wxRect *arg1 = (wxRect *) 0 ;
5976 wxRect *arg2 = 0 ;
5977 bool result;
5978 wxRect temp2 ;
5979 PyObject * obj0 = 0 ;
5980 PyObject * obj1 = 0 ;
5981 char *kwnames[] = {
5982 (char *) "self",(char *) "rect", NULL
5983 };
5984
5985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
5986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5987 if (SWIG_arg_fail(1)) SWIG_fail;
5988 {
5989 arg2 = &temp2;
5990 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5991 }
5992 {
5993 PyThreadState* __tstate = wxPyBeginAllowThreads();
5994 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
5995
5996 wxPyEndAllowThreads(__tstate);
5997 if (PyErr_Occurred()) SWIG_fail;
5998 }
5999 {
6000 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6001 }
6002 return resultobj;
6003 fail:
6004 return NULL;
6005 }
6006
6007
6008 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6009 PyObject *resultobj;
6010 wxRect *arg1 = (wxRect *) 0 ;
6011 int arg2 ;
6012 int arg3 ;
6013 bool result;
6014 PyObject * obj0 = 0 ;
6015 PyObject * obj1 = 0 ;
6016 PyObject * obj2 = 0 ;
6017 char *kwnames[] = {
6018 (char *) "self",(char *) "x",(char *) "y", NULL
6019 };
6020
6021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6023 if (SWIG_arg_fail(1)) SWIG_fail;
6024 {
6025 arg2 = (int)(SWIG_As_int(obj1));
6026 if (SWIG_arg_fail(2)) SWIG_fail;
6027 }
6028 {
6029 arg3 = (int)(SWIG_As_int(obj2));
6030 if (SWIG_arg_fail(3)) SWIG_fail;
6031 }
6032 {
6033 PyThreadState* __tstate = wxPyBeginAllowThreads();
6034 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6035
6036 wxPyEndAllowThreads(__tstate);
6037 if (PyErr_Occurred()) SWIG_fail;
6038 }
6039 {
6040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6041 }
6042 return resultobj;
6043 fail:
6044 return NULL;
6045 }
6046
6047
6048 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6049 PyObject *resultobj;
6050 wxRect *arg1 = (wxRect *) 0 ;
6051 wxPoint *arg2 = 0 ;
6052 bool result;
6053 wxPoint temp2 ;
6054 PyObject * obj0 = 0 ;
6055 PyObject * obj1 = 0 ;
6056 char *kwnames[] = {
6057 (char *) "self",(char *) "pt", NULL
6058 };
6059
6060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6062 if (SWIG_arg_fail(1)) SWIG_fail;
6063 {
6064 arg2 = &temp2;
6065 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6066 }
6067 {
6068 PyThreadState* __tstate = wxPyBeginAllowThreads();
6069 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6070
6071 wxPyEndAllowThreads(__tstate);
6072 if (PyErr_Occurred()) SWIG_fail;
6073 }
6074 {
6075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6076 }
6077 return resultobj;
6078 fail:
6079 return NULL;
6080 }
6081
6082
6083 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6084 PyObject *resultobj;
6085 wxRect *arg1 = (wxRect *) 0 ;
6086 wxRect *arg2 = 0 ;
6087 bool result;
6088 wxRect temp2 ;
6089 PyObject * obj0 = 0 ;
6090 PyObject * obj1 = 0 ;
6091 char *kwnames[] = {
6092 (char *) "self",(char *) "rect", NULL
6093 };
6094
6095 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6096 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6097 if (SWIG_arg_fail(1)) SWIG_fail;
6098 {
6099 arg2 = &temp2;
6100 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6101 }
6102 {
6103 PyThreadState* __tstate = wxPyBeginAllowThreads();
6104 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6105
6106 wxPyEndAllowThreads(__tstate);
6107 if (PyErr_Occurred()) SWIG_fail;
6108 }
6109 {
6110 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6111 }
6112 return resultobj;
6113 fail:
6114 return NULL;
6115 }
6116
6117
6118 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6119 PyObject *resultobj;
6120 wxRect *arg1 = (wxRect *) 0 ;
6121 int arg2 ;
6122 PyObject * obj0 = 0 ;
6123 PyObject * obj1 = 0 ;
6124 char *kwnames[] = {
6125 (char *) "self",(char *) "x", NULL
6126 };
6127
6128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6130 if (SWIG_arg_fail(1)) SWIG_fail;
6131 {
6132 arg2 = (int)(SWIG_As_int(obj1));
6133 if (SWIG_arg_fail(2)) SWIG_fail;
6134 }
6135 if (arg1) (arg1)->x = arg2;
6136
6137 Py_INCREF(Py_None); resultobj = Py_None;
6138 return resultobj;
6139 fail:
6140 return NULL;
6141 }
6142
6143
6144 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6145 PyObject *resultobj;
6146 wxRect *arg1 = (wxRect *) 0 ;
6147 int result;
6148 PyObject * obj0 = 0 ;
6149 char *kwnames[] = {
6150 (char *) "self", NULL
6151 };
6152
6153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6155 if (SWIG_arg_fail(1)) SWIG_fail;
6156 result = (int) ((arg1)->x);
6157
6158 {
6159 resultobj = SWIG_From_int((int)(result));
6160 }
6161 return resultobj;
6162 fail:
6163 return NULL;
6164 }
6165
6166
6167 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6168 PyObject *resultobj;
6169 wxRect *arg1 = (wxRect *) 0 ;
6170 int arg2 ;
6171 PyObject * obj0 = 0 ;
6172 PyObject * obj1 = 0 ;
6173 char *kwnames[] = {
6174 (char *) "self",(char *) "y", NULL
6175 };
6176
6177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6179 if (SWIG_arg_fail(1)) SWIG_fail;
6180 {
6181 arg2 = (int)(SWIG_As_int(obj1));
6182 if (SWIG_arg_fail(2)) SWIG_fail;
6183 }
6184 if (arg1) (arg1)->y = arg2;
6185
6186 Py_INCREF(Py_None); resultobj = Py_None;
6187 return resultobj;
6188 fail:
6189 return NULL;
6190 }
6191
6192
6193 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6194 PyObject *resultobj;
6195 wxRect *arg1 = (wxRect *) 0 ;
6196 int result;
6197 PyObject * obj0 = 0 ;
6198 char *kwnames[] = {
6199 (char *) "self", NULL
6200 };
6201
6202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6203 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6204 if (SWIG_arg_fail(1)) SWIG_fail;
6205 result = (int) ((arg1)->y);
6206
6207 {
6208 resultobj = SWIG_From_int((int)(result));
6209 }
6210 return resultobj;
6211 fail:
6212 return NULL;
6213 }
6214
6215
6216 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6217 PyObject *resultobj;
6218 wxRect *arg1 = (wxRect *) 0 ;
6219 int arg2 ;
6220 PyObject * obj0 = 0 ;
6221 PyObject * obj1 = 0 ;
6222 char *kwnames[] = {
6223 (char *) "self",(char *) "width", NULL
6224 };
6225
6226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6228 if (SWIG_arg_fail(1)) SWIG_fail;
6229 {
6230 arg2 = (int)(SWIG_As_int(obj1));
6231 if (SWIG_arg_fail(2)) SWIG_fail;
6232 }
6233 if (arg1) (arg1)->width = arg2;
6234
6235 Py_INCREF(Py_None); resultobj = Py_None;
6236 return resultobj;
6237 fail:
6238 return NULL;
6239 }
6240
6241
6242 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6243 PyObject *resultobj;
6244 wxRect *arg1 = (wxRect *) 0 ;
6245 int result;
6246 PyObject * obj0 = 0 ;
6247 char *kwnames[] = {
6248 (char *) "self", NULL
6249 };
6250
6251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6252 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6253 if (SWIG_arg_fail(1)) SWIG_fail;
6254 result = (int) ((arg1)->width);
6255
6256 {
6257 resultobj = SWIG_From_int((int)(result));
6258 }
6259 return resultobj;
6260 fail:
6261 return NULL;
6262 }
6263
6264
6265 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6266 PyObject *resultobj;
6267 wxRect *arg1 = (wxRect *) 0 ;
6268 int arg2 ;
6269 PyObject * obj0 = 0 ;
6270 PyObject * obj1 = 0 ;
6271 char *kwnames[] = {
6272 (char *) "self",(char *) "height", NULL
6273 };
6274
6275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6277 if (SWIG_arg_fail(1)) SWIG_fail;
6278 {
6279 arg2 = (int)(SWIG_As_int(obj1));
6280 if (SWIG_arg_fail(2)) SWIG_fail;
6281 }
6282 if (arg1) (arg1)->height = arg2;
6283
6284 Py_INCREF(Py_None); resultobj = Py_None;
6285 return resultobj;
6286 fail:
6287 return NULL;
6288 }
6289
6290
6291 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6292 PyObject *resultobj;
6293 wxRect *arg1 = (wxRect *) 0 ;
6294 int result;
6295 PyObject * obj0 = 0 ;
6296 char *kwnames[] = {
6297 (char *) "self", NULL
6298 };
6299
6300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6302 if (SWIG_arg_fail(1)) SWIG_fail;
6303 result = (int) ((arg1)->height);
6304
6305 {
6306 resultobj = SWIG_From_int((int)(result));
6307 }
6308 return resultobj;
6309 fail:
6310 return NULL;
6311 }
6312
6313
6314 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6315 PyObject *resultobj;
6316 wxRect *arg1 = (wxRect *) 0 ;
6317 int arg2 = (int) 0 ;
6318 int arg3 = (int) 0 ;
6319 int arg4 = (int) 0 ;
6320 int arg5 = (int) 0 ;
6321 PyObject * obj0 = 0 ;
6322 PyObject * obj1 = 0 ;
6323 PyObject * obj2 = 0 ;
6324 PyObject * obj3 = 0 ;
6325 PyObject * obj4 = 0 ;
6326 char *kwnames[] = {
6327 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6328 };
6329
6330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6332 if (SWIG_arg_fail(1)) SWIG_fail;
6333 if (obj1) {
6334 {
6335 arg2 = (int)(SWIG_As_int(obj1));
6336 if (SWIG_arg_fail(2)) SWIG_fail;
6337 }
6338 }
6339 if (obj2) {
6340 {
6341 arg3 = (int)(SWIG_As_int(obj2));
6342 if (SWIG_arg_fail(3)) SWIG_fail;
6343 }
6344 }
6345 if (obj3) {
6346 {
6347 arg4 = (int)(SWIG_As_int(obj3));
6348 if (SWIG_arg_fail(4)) SWIG_fail;
6349 }
6350 }
6351 if (obj4) {
6352 {
6353 arg5 = (int)(SWIG_As_int(obj4));
6354 if (SWIG_arg_fail(5)) SWIG_fail;
6355 }
6356 }
6357 {
6358 PyThreadState* __tstate = wxPyBeginAllowThreads();
6359 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6360
6361 wxPyEndAllowThreads(__tstate);
6362 if (PyErr_Occurred()) SWIG_fail;
6363 }
6364 Py_INCREF(Py_None); resultobj = Py_None;
6365 return resultobj;
6366 fail:
6367 return NULL;
6368 }
6369
6370
6371 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6372 PyObject *resultobj;
6373 wxRect *arg1 = (wxRect *) 0 ;
6374 PyObject *result;
6375 PyObject * obj0 = 0 ;
6376 char *kwnames[] = {
6377 (char *) "self", NULL
6378 };
6379
6380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6382 if (SWIG_arg_fail(1)) SWIG_fail;
6383 {
6384 PyThreadState* __tstate = wxPyBeginAllowThreads();
6385 result = (PyObject *)wxRect_Get(arg1);
6386
6387 wxPyEndAllowThreads(__tstate);
6388 if (PyErr_Occurred()) SWIG_fail;
6389 }
6390 resultobj = result;
6391 return resultobj;
6392 fail:
6393 return NULL;
6394 }
6395
6396
6397 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6398 PyObject *obj;
6399 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6400 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6401 Py_INCREF(obj);
6402 return Py_BuildValue((char *)"");
6403 }
6404 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6405 PyObject *resultobj;
6406 wxRect *arg1 = (wxRect *) 0 ;
6407 wxRect *arg2 = (wxRect *) 0 ;
6408 PyObject *result;
6409 PyObject * obj0 = 0 ;
6410 PyObject * obj1 = 0 ;
6411 char *kwnames[] = {
6412 (char *) "r1",(char *) "r2", NULL
6413 };
6414
6415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6417 if (SWIG_arg_fail(1)) SWIG_fail;
6418 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6419 if (SWIG_arg_fail(2)) SWIG_fail;
6420 {
6421 if (!wxPyCheckForApp()) SWIG_fail;
6422 PyThreadState* __tstate = wxPyBeginAllowThreads();
6423 result = (PyObject *)wxIntersectRect(arg1,arg2);
6424
6425 wxPyEndAllowThreads(__tstate);
6426 if (PyErr_Occurred()) SWIG_fail;
6427 }
6428 resultobj = result;
6429 return resultobj;
6430 fail:
6431 return NULL;
6432 }
6433
6434
6435 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6436 PyObject *resultobj;
6437 double arg1 = (double) 0.0 ;
6438 double arg2 = (double) 0.0 ;
6439 wxPoint2D *result;
6440 PyObject * obj0 = 0 ;
6441 PyObject * obj1 = 0 ;
6442 char *kwnames[] = {
6443 (char *) "x",(char *) "y", NULL
6444 };
6445
6446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6447 if (obj0) {
6448 {
6449 arg1 = (double)(SWIG_As_double(obj0));
6450 if (SWIG_arg_fail(1)) SWIG_fail;
6451 }
6452 }
6453 if (obj1) {
6454 {
6455 arg2 = (double)(SWIG_As_double(obj1));
6456 if (SWIG_arg_fail(2)) SWIG_fail;
6457 }
6458 }
6459 {
6460 PyThreadState* __tstate = wxPyBeginAllowThreads();
6461 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6462
6463 wxPyEndAllowThreads(__tstate);
6464 if (PyErr_Occurred()) SWIG_fail;
6465 }
6466 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6467 return resultobj;
6468 fail:
6469 return NULL;
6470 }
6471
6472
6473 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6474 PyObject *resultobj;
6475 wxPoint2D *arg1 = 0 ;
6476 wxPoint2D *result;
6477 wxPoint2D temp1 ;
6478 PyObject * obj0 = 0 ;
6479 char *kwnames[] = {
6480 (char *) "pt", NULL
6481 };
6482
6483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6484 {
6485 arg1 = &temp1;
6486 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6487 }
6488 {
6489 PyThreadState* __tstate = wxPyBeginAllowThreads();
6490 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6491
6492 wxPyEndAllowThreads(__tstate);
6493 if (PyErr_Occurred()) SWIG_fail;
6494 }
6495 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6496 return resultobj;
6497 fail:
6498 return NULL;
6499 }
6500
6501
6502 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6503 PyObject *resultobj;
6504 wxPoint *arg1 = 0 ;
6505 wxPoint2D *result;
6506 wxPoint temp1 ;
6507 PyObject * obj0 = 0 ;
6508 char *kwnames[] = {
6509 (char *) "pt", NULL
6510 };
6511
6512 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6513 {
6514 arg1 = &temp1;
6515 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6516 }
6517 {
6518 PyThreadState* __tstate = wxPyBeginAllowThreads();
6519 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6520
6521 wxPyEndAllowThreads(__tstate);
6522 if (PyErr_Occurred()) SWIG_fail;
6523 }
6524 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6525 return resultobj;
6526 fail:
6527 return NULL;
6528 }
6529
6530
6531 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6532 PyObject *resultobj;
6533 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6534 int *arg2 = (int *) 0 ;
6535 int *arg3 = (int *) 0 ;
6536 int temp2 ;
6537 int res2 = 0 ;
6538 int temp3 ;
6539 int res3 = 0 ;
6540 PyObject * obj0 = 0 ;
6541 char *kwnames[] = {
6542 (char *) "self", NULL
6543 };
6544
6545 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6546 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6549 if (SWIG_arg_fail(1)) SWIG_fail;
6550 {
6551 PyThreadState* __tstate = wxPyBeginAllowThreads();
6552 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6553
6554 wxPyEndAllowThreads(__tstate);
6555 if (PyErr_Occurred()) SWIG_fail;
6556 }
6557 Py_INCREF(Py_None); resultobj = Py_None;
6558 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6559 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6560 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6561 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6562 return resultobj;
6563 fail:
6564 return NULL;
6565 }
6566
6567
6568 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6569 PyObject *resultobj;
6570 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6571 int *arg2 = (int *) 0 ;
6572 int *arg3 = (int *) 0 ;
6573 int temp2 ;
6574 int res2 = 0 ;
6575 int temp3 ;
6576 int res3 = 0 ;
6577 PyObject * obj0 = 0 ;
6578 char *kwnames[] = {
6579 (char *) "self", NULL
6580 };
6581
6582 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6583 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6585 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6586 if (SWIG_arg_fail(1)) SWIG_fail;
6587 {
6588 PyThreadState* __tstate = wxPyBeginAllowThreads();
6589 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6590
6591 wxPyEndAllowThreads(__tstate);
6592 if (PyErr_Occurred()) SWIG_fail;
6593 }
6594 Py_INCREF(Py_None); resultobj = Py_None;
6595 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6596 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6597 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6598 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6599 return resultobj;
6600 fail:
6601 return NULL;
6602 }
6603
6604
6605 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6606 PyObject *resultobj;
6607 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6608 double result;
6609 PyObject * obj0 = 0 ;
6610 char *kwnames[] = {
6611 (char *) "self", NULL
6612 };
6613
6614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6616 if (SWIG_arg_fail(1)) SWIG_fail;
6617 {
6618 PyThreadState* __tstate = wxPyBeginAllowThreads();
6619 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6620
6621 wxPyEndAllowThreads(__tstate);
6622 if (PyErr_Occurred()) SWIG_fail;
6623 }
6624 {
6625 resultobj = SWIG_From_double((double)(result));
6626 }
6627 return resultobj;
6628 fail:
6629 return NULL;
6630 }
6631
6632
6633 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6634 PyObject *resultobj;
6635 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6636 double result;
6637 PyObject * obj0 = 0 ;
6638 char *kwnames[] = {
6639 (char *) "self", NULL
6640 };
6641
6642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6644 if (SWIG_arg_fail(1)) SWIG_fail;
6645 {
6646 PyThreadState* __tstate = wxPyBeginAllowThreads();
6647 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6648
6649 wxPyEndAllowThreads(__tstate);
6650 if (PyErr_Occurred()) SWIG_fail;
6651 }
6652 {
6653 resultobj = SWIG_From_double((double)(result));
6654 }
6655 return resultobj;
6656 fail:
6657 return NULL;
6658 }
6659
6660
6661 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6662 PyObject *resultobj;
6663 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6664 double arg2 ;
6665 PyObject * obj0 = 0 ;
6666 PyObject * obj1 = 0 ;
6667 char *kwnames[] = {
6668 (char *) "self",(char *) "length", NULL
6669 };
6670
6671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6673 if (SWIG_arg_fail(1)) SWIG_fail;
6674 {
6675 arg2 = (double)(SWIG_As_double(obj1));
6676 if (SWIG_arg_fail(2)) SWIG_fail;
6677 }
6678 {
6679 PyThreadState* __tstate = wxPyBeginAllowThreads();
6680 (arg1)->SetVectorLength(arg2);
6681
6682 wxPyEndAllowThreads(__tstate);
6683 if (PyErr_Occurred()) SWIG_fail;
6684 }
6685 Py_INCREF(Py_None); resultobj = Py_None;
6686 return resultobj;
6687 fail:
6688 return NULL;
6689 }
6690
6691
6692 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6693 PyObject *resultobj;
6694 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6695 double arg2 ;
6696 PyObject * obj0 = 0 ;
6697 PyObject * obj1 = 0 ;
6698 char *kwnames[] = {
6699 (char *) "self",(char *) "degrees", NULL
6700 };
6701
6702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6704 if (SWIG_arg_fail(1)) SWIG_fail;
6705 {
6706 arg2 = (double)(SWIG_As_double(obj1));
6707 if (SWIG_arg_fail(2)) SWIG_fail;
6708 }
6709 {
6710 PyThreadState* __tstate = wxPyBeginAllowThreads();
6711 (arg1)->SetVectorAngle(arg2);
6712
6713 wxPyEndAllowThreads(__tstate);
6714 if (PyErr_Occurred()) SWIG_fail;
6715 }
6716 Py_INCREF(Py_None); resultobj = Py_None;
6717 return resultobj;
6718 fail:
6719 return NULL;
6720 }
6721
6722
6723 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6724 PyObject *resultobj;
6725 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6726 wxPoint2D *arg2 = 0 ;
6727 double result;
6728 wxPoint2D temp2 ;
6729 PyObject * obj0 = 0 ;
6730 PyObject * obj1 = 0 ;
6731 char *kwnames[] = {
6732 (char *) "self",(char *) "pt", NULL
6733 };
6734
6735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6737 if (SWIG_arg_fail(1)) SWIG_fail;
6738 {
6739 arg2 = &temp2;
6740 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6741 }
6742 {
6743 PyThreadState* __tstate = wxPyBeginAllowThreads();
6744 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6745
6746 wxPyEndAllowThreads(__tstate);
6747 if (PyErr_Occurred()) SWIG_fail;
6748 }
6749 {
6750 resultobj = SWIG_From_double((double)(result));
6751 }
6752 return resultobj;
6753 fail:
6754 return NULL;
6755 }
6756
6757
6758 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6759 PyObject *resultobj;
6760 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6761 wxPoint2D *arg2 = 0 ;
6762 double result;
6763 wxPoint2D temp2 ;
6764 PyObject * obj0 = 0 ;
6765 PyObject * obj1 = 0 ;
6766 char *kwnames[] = {
6767 (char *) "self",(char *) "pt", NULL
6768 };
6769
6770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6772 if (SWIG_arg_fail(1)) SWIG_fail;
6773 {
6774 arg2 = &temp2;
6775 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6776 }
6777 {
6778 PyThreadState* __tstate = wxPyBeginAllowThreads();
6779 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6780
6781 wxPyEndAllowThreads(__tstate);
6782 if (PyErr_Occurred()) SWIG_fail;
6783 }
6784 {
6785 resultobj = SWIG_From_double((double)(result));
6786 }
6787 return resultobj;
6788 fail:
6789 return NULL;
6790 }
6791
6792
6793 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6794 PyObject *resultobj;
6795 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6796 wxPoint2D *arg2 = 0 ;
6797 double result;
6798 wxPoint2D temp2 ;
6799 PyObject * obj0 = 0 ;
6800 PyObject * obj1 = 0 ;
6801 char *kwnames[] = {
6802 (char *) "self",(char *) "vec", NULL
6803 };
6804
6805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6807 if (SWIG_arg_fail(1)) SWIG_fail;
6808 {
6809 arg2 = &temp2;
6810 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6811 }
6812 {
6813 PyThreadState* __tstate = wxPyBeginAllowThreads();
6814 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6815
6816 wxPyEndAllowThreads(__tstate);
6817 if (PyErr_Occurred()) SWIG_fail;
6818 }
6819 {
6820 resultobj = SWIG_From_double((double)(result));
6821 }
6822 return resultobj;
6823 fail:
6824 return NULL;
6825 }
6826
6827
6828 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6829 PyObject *resultobj;
6830 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6831 wxPoint2D *arg2 = 0 ;
6832 double result;
6833 wxPoint2D temp2 ;
6834 PyObject * obj0 = 0 ;
6835 PyObject * obj1 = 0 ;
6836 char *kwnames[] = {
6837 (char *) "self",(char *) "vec", NULL
6838 };
6839
6840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6842 if (SWIG_arg_fail(1)) SWIG_fail;
6843 {
6844 arg2 = &temp2;
6845 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6846 }
6847 {
6848 PyThreadState* __tstate = wxPyBeginAllowThreads();
6849 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6850
6851 wxPyEndAllowThreads(__tstate);
6852 if (PyErr_Occurred()) SWIG_fail;
6853 }
6854 {
6855 resultobj = SWIG_From_double((double)(result));
6856 }
6857 return resultobj;
6858 fail:
6859 return NULL;
6860 }
6861
6862
6863 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6864 PyObject *resultobj;
6865 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6866 wxPoint2D result;
6867 PyObject * obj0 = 0 ;
6868 char *kwnames[] = {
6869 (char *) "self", NULL
6870 };
6871
6872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6874 if (SWIG_arg_fail(1)) SWIG_fail;
6875 {
6876 PyThreadState* __tstate = wxPyBeginAllowThreads();
6877 result = (arg1)->operator -();
6878
6879 wxPyEndAllowThreads(__tstate);
6880 if (PyErr_Occurred()) SWIG_fail;
6881 }
6882 {
6883 wxPoint2D * resultptr;
6884 resultptr = new wxPoint2D((wxPoint2D &)(result));
6885 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6886 }
6887 return resultobj;
6888 fail:
6889 return NULL;
6890 }
6891
6892
6893 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6894 PyObject *resultobj;
6895 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6896 wxPoint2D *arg2 = 0 ;
6897 wxPoint2D *result;
6898 wxPoint2D temp2 ;
6899 PyObject * obj0 = 0 ;
6900 PyObject * obj1 = 0 ;
6901 char *kwnames[] = {
6902 (char *) "self",(char *) "pt", NULL
6903 };
6904
6905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6907 if (SWIG_arg_fail(1)) SWIG_fail;
6908 {
6909 arg2 = &temp2;
6910 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6911 }
6912 {
6913 PyThreadState* __tstate = wxPyBeginAllowThreads();
6914 {
6915 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6916 result = (wxPoint2D *) &_result_ref;
6917 }
6918
6919 wxPyEndAllowThreads(__tstate);
6920 if (PyErr_Occurred()) SWIG_fail;
6921 }
6922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6923 return resultobj;
6924 fail:
6925 return NULL;
6926 }
6927
6928
6929 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6930 PyObject *resultobj;
6931 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6932 wxPoint2D *arg2 = 0 ;
6933 wxPoint2D *result;
6934 wxPoint2D temp2 ;
6935 PyObject * obj0 = 0 ;
6936 PyObject * obj1 = 0 ;
6937 char *kwnames[] = {
6938 (char *) "self",(char *) "pt", NULL
6939 };
6940
6941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
6942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6943 if (SWIG_arg_fail(1)) SWIG_fail;
6944 {
6945 arg2 = &temp2;
6946 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6947 }
6948 {
6949 PyThreadState* __tstate = wxPyBeginAllowThreads();
6950 {
6951 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
6952 result = (wxPoint2D *) &_result_ref;
6953 }
6954
6955 wxPyEndAllowThreads(__tstate);
6956 if (PyErr_Occurred()) SWIG_fail;
6957 }
6958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6959 return resultobj;
6960 fail:
6961 return NULL;
6962 }
6963
6964
6965 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
6966 PyObject *resultobj;
6967 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6968 wxPoint2D *arg2 = 0 ;
6969 wxPoint2D *result;
6970 wxPoint2D temp2 ;
6971 PyObject * obj0 = 0 ;
6972 PyObject * obj1 = 0 ;
6973 char *kwnames[] = {
6974 (char *) "self",(char *) "pt", NULL
6975 };
6976
6977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
6978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6979 if (SWIG_arg_fail(1)) SWIG_fail;
6980 {
6981 arg2 = &temp2;
6982 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6983 }
6984 {
6985 PyThreadState* __tstate = wxPyBeginAllowThreads();
6986 {
6987 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
6988 result = (wxPoint2D *) &_result_ref;
6989 }
6990
6991 wxPyEndAllowThreads(__tstate);
6992 if (PyErr_Occurred()) SWIG_fail;
6993 }
6994 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6995 return resultobj;
6996 fail:
6997 return NULL;
6998 }
6999
7000
7001 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7002 PyObject *resultobj;
7003 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7004 wxPoint2D *arg2 = 0 ;
7005 wxPoint2D *result;
7006 wxPoint2D temp2 ;
7007 PyObject * obj0 = 0 ;
7008 PyObject * obj1 = 0 ;
7009 char *kwnames[] = {
7010 (char *) "self",(char *) "pt", NULL
7011 };
7012
7013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7015 if (SWIG_arg_fail(1)) SWIG_fail;
7016 {
7017 arg2 = &temp2;
7018 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7019 }
7020 {
7021 PyThreadState* __tstate = wxPyBeginAllowThreads();
7022 {
7023 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7024 result = (wxPoint2D *) &_result_ref;
7025 }
7026
7027 wxPyEndAllowThreads(__tstate);
7028 if (PyErr_Occurred()) SWIG_fail;
7029 }
7030 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7031 return resultobj;
7032 fail:
7033 return NULL;
7034 }
7035
7036
7037 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7038 PyObject *resultobj;
7039 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7040 wxPoint2D *arg2 = 0 ;
7041 bool result;
7042 wxPoint2D temp2 ;
7043 PyObject * obj0 = 0 ;
7044 PyObject * obj1 = 0 ;
7045 char *kwnames[] = {
7046 (char *) "self",(char *) "pt", NULL
7047 };
7048
7049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7051 if (SWIG_arg_fail(1)) SWIG_fail;
7052 {
7053 arg2 = &temp2;
7054 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7055 }
7056 {
7057 PyThreadState* __tstate = wxPyBeginAllowThreads();
7058 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7059
7060 wxPyEndAllowThreads(__tstate);
7061 if (PyErr_Occurred()) SWIG_fail;
7062 }
7063 {
7064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7065 }
7066 return resultobj;
7067 fail:
7068 return NULL;
7069 }
7070
7071
7072 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7073 PyObject *resultobj;
7074 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7075 wxPoint2D *arg2 = 0 ;
7076 bool result;
7077 wxPoint2D temp2 ;
7078 PyObject * obj0 = 0 ;
7079 PyObject * obj1 = 0 ;
7080 char *kwnames[] = {
7081 (char *) "self",(char *) "pt", NULL
7082 };
7083
7084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7086 if (SWIG_arg_fail(1)) SWIG_fail;
7087 {
7088 arg2 = &temp2;
7089 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7090 }
7091 {
7092 PyThreadState* __tstate = wxPyBeginAllowThreads();
7093 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7094
7095 wxPyEndAllowThreads(__tstate);
7096 if (PyErr_Occurred()) SWIG_fail;
7097 }
7098 {
7099 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7100 }
7101 return resultobj;
7102 fail:
7103 return NULL;
7104 }
7105
7106
7107 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7108 PyObject *resultobj;
7109 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7110 double arg2 ;
7111 PyObject * obj0 = 0 ;
7112 PyObject * obj1 = 0 ;
7113 char *kwnames[] = {
7114 (char *) "self",(char *) "m_x", NULL
7115 };
7116
7117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7119 if (SWIG_arg_fail(1)) SWIG_fail;
7120 {
7121 arg2 = (double)(SWIG_As_double(obj1));
7122 if (SWIG_arg_fail(2)) SWIG_fail;
7123 }
7124 if (arg1) (arg1)->m_x = arg2;
7125
7126 Py_INCREF(Py_None); resultobj = Py_None;
7127 return resultobj;
7128 fail:
7129 return NULL;
7130 }
7131
7132
7133 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7134 PyObject *resultobj;
7135 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7136 double result;
7137 PyObject * obj0 = 0 ;
7138 char *kwnames[] = {
7139 (char *) "self", NULL
7140 };
7141
7142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7144 if (SWIG_arg_fail(1)) SWIG_fail;
7145 result = (double) ((arg1)->m_x);
7146
7147 {
7148 resultobj = SWIG_From_double((double)(result));
7149 }
7150 return resultobj;
7151 fail:
7152 return NULL;
7153 }
7154
7155
7156 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7157 PyObject *resultobj;
7158 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7159 double arg2 ;
7160 PyObject * obj0 = 0 ;
7161 PyObject * obj1 = 0 ;
7162 char *kwnames[] = {
7163 (char *) "self",(char *) "m_y", NULL
7164 };
7165
7166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7168 if (SWIG_arg_fail(1)) SWIG_fail;
7169 {
7170 arg2 = (double)(SWIG_As_double(obj1));
7171 if (SWIG_arg_fail(2)) SWIG_fail;
7172 }
7173 if (arg1) (arg1)->m_y = arg2;
7174
7175 Py_INCREF(Py_None); resultobj = Py_None;
7176 return resultobj;
7177 fail:
7178 return NULL;
7179 }
7180
7181
7182 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7183 PyObject *resultobj;
7184 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7185 double result;
7186 PyObject * obj0 = 0 ;
7187 char *kwnames[] = {
7188 (char *) "self", NULL
7189 };
7190
7191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7193 if (SWIG_arg_fail(1)) SWIG_fail;
7194 result = (double) ((arg1)->m_y);
7195
7196 {
7197 resultobj = SWIG_From_double((double)(result));
7198 }
7199 return resultobj;
7200 fail:
7201 return NULL;
7202 }
7203
7204
7205 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7206 PyObject *resultobj;
7207 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7208 double arg2 = (double) 0 ;
7209 double arg3 = (double) 0 ;
7210 PyObject * obj0 = 0 ;
7211 PyObject * obj1 = 0 ;
7212 PyObject * obj2 = 0 ;
7213 char *kwnames[] = {
7214 (char *) "self",(char *) "x",(char *) "y", NULL
7215 };
7216
7217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7219 if (SWIG_arg_fail(1)) SWIG_fail;
7220 if (obj1) {
7221 {
7222 arg2 = (double)(SWIG_As_double(obj1));
7223 if (SWIG_arg_fail(2)) SWIG_fail;
7224 }
7225 }
7226 if (obj2) {
7227 {
7228 arg3 = (double)(SWIG_As_double(obj2));
7229 if (SWIG_arg_fail(3)) SWIG_fail;
7230 }
7231 }
7232 {
7233 PyThreadState* __tstate = wxPyBeginAllowThreads();
7234 wxPoint2D_Set(arg1,arg2,arg3);
7235
7236 wxPyEndAllowThreads(__tstate);
7237 if (PyErr_Occurred()) SWIG_fail;
7238 }
7239 Py_INCREF(Py_None); resultobj = Py_None;
7240 return resultobj;
7241 fail:
7242 return NULL;
7243 }
7244
7245
7246 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7247 PyObject *resultobj;
7248 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7249 PyObject *result;
7250 PyObject * obj0 = 0 ;
7251 char *kwnames[] = {
7252 (char *) "self", NULL
7253 };
7254
7255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7257 if (SWIG_arg_fail(1)) SWIG_fail;
7258 {
7259 PyThreadState* __tstate = wxPyBeginAllowThreads();
7260 result = (PyObject *)wxPoint2D_Get(arg1);
7261
7262 wxPyEndAllowThreads(__tstate);
7263 if (PyErr_Occurred()) SWIG_fail;
7264 }
7265 resultobj = result;
7266 return resultobj;
7267 fail:
7268 return NULL;
7269 }
7270
7271
7272 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7273 PyObject *obj;
7274 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7275 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7276 Py_INCREF(obj);
7277 return Py_BuildValue((char *)"");
7278 }
7279 static int _wrap_DefaultPosition_set(PyObject *) {
7280 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7281 return 1;
7282 }
7283
7284
7285 static PyObject *_wrap_DefaultPosition_get(void) {
7286 PyObject *pyobj;
7287
7288 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7289 return pyobj;
7290 }
7291
7292
7293 static int _wrap_DefaultSize_set(PyObject *) {
7294 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7295 return 1;
7296 }
7297
7298
7299 static PyObject *_wrap_DefaultSize_get(void) {
7300 PyObject *pyobj;
7301
7302 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7303 return pyobj;
7304 }
7305
7306
7307 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7308 PyObject *resultobj;
7309 PyObject *arg1 = (PyObject *) 0 ;
7310 wxPyInputStream *result;
7311 PyObject * obj0 = 0 ;
7312 char *kwnames[] = {
7313 (char *) "p", NULL
7314 };
7315
7316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7317 arg1 = obj0;
7318 {
7319 PyThreadState* __tstate = wxPyBeginAllowThreads();
7320 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7321
7322 wxPyEndAllowThreads(__tstate);
7323 if (PyErr_Occurred()) SWIG_fail;
7324 }
7325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7326 return resultobj;
7327 fail:
7328 return NULL;
7329 }
7330
7331
7332 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7333 PyObject *resultobj;
7334 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7335 PyObject * obj0 = 0 ;
7336 char *kwnames[] = {
7337 (char *) "self", NULL
7338 };
7339
7340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7342 if (SWIG_arg_fail(1)) SWIG_fail;
7343 {
7344 PyThreadState* __tstate = wxPyBeginAllowThreads();
7345 delete arg1;
7346
7347 wxPyEndAllowThreads(__tstate);
7348 if (PyErr_Occurred()) SWIG_fail;
7349 }
7350 Py_INCREF(Py_None); resultobj = Py_None;
7351 return resultobj;
7352 fail:
7353 return NULL;
7354 }
7355
7356
7357 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7358 PyObject *resultobj;
7359 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7360 PyObject * obj0 = 0 ;
7361 char *kwnames[] = {
7362 (char *) "self", NULL
7363 };
7364
7365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7367 if (SWIG_arg_fail(1)) SWIG_fail;
7368 {
7369 PyThreadState* __tstate = wxPyBeginAllowThreads();
7370 (arg1)->close();
7371
7372 wxPyEndAllowThreads(__tstate);
7373 if (PyErr_Occurred()) SWIG_fail;
7374 }
7375 Py_INCREF(Py_None); resultobj = Py_None;
7376 return resultobj;
7377 fail:
7378 return NULL;
7379 }
7380
7381
7382 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7383 PyObject *resultobj;
7384 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7385 PyObject * obj0 = 0 ;
7386 char *kwnames[] = {
7387 (char *) "self", NULL
7388 };
7389
7390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7392 if (SWIG_arg_fail(1)) SWIG_fail;
7393 {
7394 PyThreadState* __tstate = wxPyBeginAllowThreads();
7395 (arg1)->flush();
7396
7397 wxPyEndAllowThreads(__tstate);
7398 if (PyErr_Occurred()) SWIG_fail;
7399 }
7400 Py_INCREF(Py_None); resultobj = Py_None;
7401 return resultobj;
7402 fail:
7403 return NULL;
7404 }
7405
7406
7407 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7408 PyObject *resultobj;
7409 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7410 bool result;
7411 PyObject * obj0 = 0 ;
7412 char *kwnames[] = {
7413 (char *) "self", NULL
7414 };
7415
7416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7418 if (SWIG_arg_fail(1)) SWIG_fail;
7419 {
7420 PyThreadState* __tstate = wxPyBeginAllowThreads();
7421 result = (bool)(arg1)->eof();
7422
7423 wxPyEndAllowThreads(__tstate);
7424 if (PyErr_Occurred()) SWIG_fail;
7425 }
7426 {
7427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7428 }
7429 return resultobj;
7430 fail:
7431 return NULL;
7432 }
7433
7434
7435 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7436 PyObject *resultobj;
7437 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7438 int arg2 = (int) -1 ;
7439 PyObject *result;
7440 PyObject * obj0 = 0 ;
7441 PyObject * obj1 = 0 ;
7442 char *kwnames[] = {
7443 (char *) "self",(char *) "size", NULL
7444 };
7445
7446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7448 if (SWIG_arg_fail(1)) SWIG_fail;
7449 if (obj1) {
7450 {
7451 arg2 = (int)(SWIG_As_int(obj1));
7452 if (SWIG_arg_fail(2)) SWIG_fail;
7453 }
7454 }
7455 {
7456 PyThreadState* __tstate = wxPyBeginAllowThreads();
7457 result = (PyObject *)(arg1)->read(arg2);
7458
7459 wxPyEndAllowThreads(__tstate);
7460 if (PyErr_Occurred()) SWIG_fail;
7461 }
7462 resultobj = result;
7463 return resultobj;
7464 fail:
7465 return NULL;
7466 }
7467
7468
7469 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7470 PyObject *resultobj;
7471 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7472 int arg2 = (int) -1 ;
7473 PyObject *result;
7474 PyObject * obj0 = 0 ;
7475 PyObject * obj1 = 0 ;
7476 char *kwnames[] = {
7477 (char *) "self",(char *) "size", NULL
7478 };
7479
7480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7482 if (SWIG_arg_fail(1)) SWIG_fail;
7483 if (obj1) {
7484 {
7485 arg2 = (int)(SWIG_As_int(obj1));
7486 if (SWIG_arg_fail(2)) SWIG_fail;
7487 }
7488 }
7489 {
7490 PyThreadState* __tstate = wxPyBeginAllowThreads();
7491 result = (PyObject *)(arg1)->readline(arg2);
7492
7493 wxPyEndAllowThreads(__tstate);
7494 if (PyErr_Occurred()) SWIG_fail;
7495 }
7496 resultobj = result;
7497 return resultobj;
7498 fail:
7499 return NULL;
7500 }
7501
7502
7503 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7504 PyObject *resultobj;
7505 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7506 int arg2 = (int) -1 ;
7507 PyObject *result;
7508 PyObject * obj0 = 0 ;
7509 PyObject * obj1 = 0 ;
7510 char *kwnames[] = {
7511 (char *) "self",(char *) "sizehint", NULL
7512 };
7513
7514 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7515 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7516 if (SWIG_arg_fail(1)) SWIG_fail;
7517 if (obj1) {
7518 {
7519 arg2 = (int)(SWIG_As_int(obj1));
7520 if (SWIG_arg_fail(2)) SWIG_fail;
7521 }
7522 }
7523 {
7524 PyThreadState* __tstate = wxPyBeginAllowThreads();
7525 result = (PyObject *)(arg1)->readlines(arg2);
7526
7527 wxPyEndAllowThreads(__tstate);
7528 if (PyErr_Occurred()) SWIG_fail;
7529 }
7530 resultobj = result;
7531 return resultobj;
7532 fail:
7533 return NULL;
7534 }
7535
7536
7537 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7538 PyObject *resultobj;
7539 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7540 int arg2 ;
7541 int arg3 = (int) 0 ;
7542 PyObject * obj0 = 0 ;
7543 PyObject * obj1 = 0 ;
7544 PyObject * obj2 = 0 ;
7545 char *kwnames[] = {
7546 (char *) "self",(char *) "offset",(char *) "whence", NULL
7547 };
7548
7549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7551 if (SWIG_arg_fail(1)) SWIG_fail;
7552 {
7553 arg2 = (int)(SWIG_As_int(obj1));
7554 if (SWIG_arg_fail(2)) SWIG_fail;
7555 }
7556 if (obj2) {
7557 {
7558 arg3 = (int)(SWIG_As_int(obj2));
7559 if (SWIG_arg_fail(3)) SWIG_fail;
7560 }
7561 }
7562 {
7563 PyThreadState* __tstate = wxPyBeginAllowThreads();
7564 (arg1)->seek(arg2,arg3);
7565
7566 wxPyEndAllowThreads(__tstate);
7567 if (PyErr_Occurred()) SWIG_fail;
7568 }
7569 Py_INCREF(Py_None); resultobj = Py_None;
7570 return resultobj;
7571 fail:
7572 return NULL;
7573 }
7574
7575
7576 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7577 PyObject *resultobj;
7578 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7579 int result;
7580 PyObject * obj0 = 0 ;
7581 char *kwnames[] = {
7582 (char *) "self", NULL
7583 };
7584
7585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7587 if (SWIG_arg_fail(1)) SWIG_fail;
7588 {
7589 PyThreadState* __tstate = wxPyBeginAllowThreads();
7590 result = (int)(arg1)->tell();
7591
7592 wxPyEndAllowThreads(__tstate);
7593 if (PyErr_Occurred()) SWIG_fail;
7594 }
7595 {
7596 resultobj = SWIG_From_int((int)(result));
7597 }
7598 return resultobj;
7599 fail:
7600 return NULL;
7601 }
7602
7603
7604 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7605 PyObject *resultobj;
7606 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7607 char result;
7608 PyObject * obj0 = 0 ;
7609 char *kwnames[] = {
7610 (char *) "self", NULL
7611 };
7612
7613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7615 if (SWIG_arg_fail(1)) SWIG_fail;
7616 {
7617 PyThreadState* __tstate = wxPyBeginAllowThreads();
7618 result = (char)(arg1)->Peek();
7619
7620 wxPyEndAllowThreads(__tstate);
7621 if (PyErr_Occurred()) SWIG_fail;
7622 }
7623 {
7624 resultobj = SWIG_From_char((char)(result));
7625 }
7626 return resultobj;
7627 fail:
7628 return NULL;
7629 }
7630
7631
7632 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7633 PyObject *resultobj;
7634 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7635 char result;
7636 PyObject * obj0 = 0 ;
7637 char *kwnames[] = {
7638 (char *) "self", NULL
7639 };
7640
7641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7643 if (SWIG_arg_fail(1)) SWIG_fail;
7644 {
7645 PyThreadState* __tstate = wxPyBeginAllowThreads();
7646 result = (char)(arg1)->GetC();
7647
7648 wxPyEndAllowThreads(__tstate);
7649 if (PyErr_Occurred()) SWIG_fail;
7650 }
7651 {
7652 resultobj = SWIG_From_char((char)(result));
7653 }
7654 return resultobj;
7655 fail:
7656 return NULL;
7657 }
7658
7659
7660 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7661 PyObject *resultobj;
7662 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7663 size_t result;
7664 PyObject * obj0 = 0 ;
7665 char *kwnames[] = {
7666 (char *) "self", NULL
7667 };
7668
7669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7671 if (SWIG_arg_fail(1)) SWIG_fail;
7672 {
7673 PyThreadState* __tstate = wxPyBeginAllowThreads();
7674 result = (size_t)(arg1)->LastRead();
7675
7676 wxPyEndAllowThreads(__tstate);
7677 if (PyErr_Occurred()) SWIG_fail;
7678 }
7679 {
7680 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7681 }
7682 return resultobj;
7683 fail:
7684 return NULL;
7685 }
7686
7687
7688 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7689 PyObject *resultobj;
7690 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7691 bool result;
7692 PyObject * obj0 = 0 ;
7693 char *kwnames[] = {
7694 (char *) "self", NULL
7695 };
7696
7697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7699 if (SWIG_arg_fail(1)) SWIG_fail;
7700 {
7701 PyThreadState* __tstate = wxPyBeginAllowThreads();
7702 result = (bool)(arg1)->CanRead();
7703
7704 wxPyEndAllowThreads(__tstate);
7705 if (PyErr_Occurred()) SWIG_fail;
7706 }
7707 {
7708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7709 }
7710 return resultobj;
7711 fail:
7712 return NULL;
7713 }
7714
7715
7716 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7717 PyObject *resultobj;
7718 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7719 bool result;
7720 PyObject * obj0 = 0 ;
7721 char *kwnames[] = {
7722 (char *) "self", NULL
7723 };
7724
7725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7727 if (SWIG_arg_fail(1)) SWIG_fail;
7728 {
7729 PyThreadState* __tstate = wxPyBeginAllowThreads();
7730 result = (bool)(arg1)->Eof();
7731
7732 wxPyEndAllowThreads(__tstate);
7733 if (PyErr_Occurred()) SWIG_fail;
7734 }
7735 {
7736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7737 }
7738 return resultobj;
7739 fail:
7740 return NULL;
7741 }
7742
7743
7744 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7745 PyObject *resultobj;
7746 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7747 char arg2 ;
7748 bool result;
7749 PyObject * obj0 = 0 ;
7750 PyObject * obj1 = 0 ;
7751 char *kwnames[] = {
7752 (char *) "self",(char *) "c", NULL
7753 };
7754
7755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7757 if (SWIG_arg_fail(1)) SWIG_fail;
7758 {
7759 arg2 = (char)(SWIG_As_char(obj1));
7760 if (SWIG_arg_fail(2)) SWIG_fail;
7761 }
7762 {
7763 PyThreadState* __tstate = wxPyBeginAllowThreads();
7764 result = (bool)(arg1)->Ungetch(arg2);
7765
7766 wxPyEndAllowThreads(__tstate);
7767 if (PyErr_Occurred()) SWIG_fail;
7768 }
7769 {
7770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7771 }
7772 return resultobj;
7773 fail:
7774 return NULL;
7775 }
7776
7777
7778 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7779 PyObject *resultobj;
7780 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7781 long arg2 ;
7782 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7783 long result;
7784 PyObject * obj0 = 0 ;
7785 PyObject * obj1 = 0 ;
7786 PyObject * obj2 = 0 ;
7787 char *kwnames[] = {
7788 (char *) "self",(char *) "pos",(char *) "mode", NULL
7789 };
7790
7791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7793 if (SWIG_arg_fail(1)) SWIG_fail;
7794 {
7795 arg2 = (long)(SWIG_As_long(obj1));
7796 if (SWIG_arg_fail(2)) SWIG_fail;
7797 }
7798 if (obj2) {
7799 {
7800 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7801 if (SWIG_arg_fail(3)) SWIG_fail;
7802 }
7803 }
7804 {
7805 PyThreadState* __tstate = wxPyBeginAllowThreads();
7806 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7807
7808 wxPyEndAllowThreads(__tstate);
7809 if (PyErr_Occurred()) SWIG_fail;
7810 }
7811 {
7812 resultobj = SWIG_From_long((long)(result));
7813 }
7814 return resultobj;
7815 fail:
7816 return NULL;
7817 }
7818
7819
7820 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7821 PyObject *resultobj;
7822 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7823 long result;
7824 PyObject * obj0 = 0 ;
7825 char *kwnames[] = {
7826 (char *) "self", NULL
7827 };
7828
7829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7831 if (SWIG_arg_fail(1)) SWIG_fail;
7832 {
7833 PyThreadState* __tstate = wxPyBeginAllowThreads();
7834 result = (long)(arg1)->TellI();
7835
7836 wxPyEndAllowThreads(__tstate);
7837 if (PyErr_Occurred()) SWIG_fail;
7838 }
7839 {
7840 resultobj = SWIG_From_long((long)(result));
7841 }
7842 return resultobj;
7843 fail:
7844 return NULL;
7845 }
7846
7847
7848 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7849 PyObject *obj;
7850 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7851 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7852 Py_INCREF(obj);
7853 return Py_BuildValue((char *)"");
7854 }
7855 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7856 PyObject *resultobj;
7857 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7858 PyObject *arg2 = (PyObject *) 0 ;
7859 PyObject * obj0 = 0 ;
7860 PyObject * obj1 = 0 ;
7861 char *kwnames[] = {
7862 (char *) "self",(char *) "obj", NULL
7863 };
7864
7865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7867 if (SWIG_arg_fail(1)) SWIG_fail;
7868 arg2 = obj1;
7869 {
7870 PyThreadState* __tstate = wxPyBeginAllowThreads();
7871 wxOutputStream_write(arg1,arg2);
7872
7873 wxPyEndAllowThreads(__tstate);
7874 if (PyErr_Occurred()) SWIG_fail;
7875 }
7876 Py_INCREF(Py_None); resultobj = Py_None;
7877 return resultobj;
7878 fail:
7879 return NULL;
7880 }
7881
7882
7883 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7884 PyObject *obj;
7885 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7886 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7887 Py_INCREF(obj);
7888 return Py_BuildValue((char *)"");
7889 }
7890 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7891 PyObject *resultobj;
7892 wxInputStream *arg1 = (wxInputStream *) 0 ;
7893 wxString *arg2 = 0 ;
7894 wxString *arg3 = 0 ;
7895 wxString *arg4 = 0 ;
7896 wxDateTime arg5 ;
7897 wxFSFile *result;
7898 wxPyInputStream *temp1 ;
7899 bool created1 ;
7900 bool temp2 = false ;
7901 bool temp3 = false ;
7902 bool temp4 = false ;
7903 PyObject * obj0 = 0 ;
7904 PyObject * obj1 = 0 ;
7905 PyObject * obj2 = 0 ;
7906 PyObject * obj3 = 0 ;
7907 PyObject * obj4 = 0 ;
7908 char *kwnames[] = {
7909 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7910 };
7911
7912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7913 {
7914 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7915 arg1 = temp1->m_wxis;
7916 created1 = false;
7917 } else {
7918 PyErr_Clear(); // clear the failure of the wxPyConvert above
7919 arg1 = wxPyCBInputStream_create(obj0, false);
7920 if (arg1 == NULL) {
7921 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
7922 SWIG_fail;
7923 }
7924 created1 = true;
7925 }
7926 }
7927 {
7928 arg2 = wxString_in_helper(obj1);
7929 if (arg2 == NULL) SWIG_fail;
7930 temp2 = true;
7931 }
7932 {
7933 arg3 = wxString_in_helper(obj2);
7934 if (arg3 == NULL) SWIG_fail;
7935 temp3 = true;
7936 }
7937 {
7938 arg4 = wxString_in_helper(obj3);
7939 if (arg4 == NULL) SWIG_fail;
7940 temp4 = true;
7941 }
7942 {
7943 wxDateTime * argp;
7944 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
7945 if (SWIG_arg_fail(5)) SWIG_fail;
7946 if (argp == NULL) {
7947 SWIG_null_ref("wxDateTime");
7948 }
7949 if (SWIG_arg_fail(5)) SWIG_fail;
7950 arg5 = *argp;
7951 }
7952 {
7953 PyThreadState* __tstate = wxPyBeginAllowThreads();
7954 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
7955
7956 wxPyEndAllowThreads(__tstate);
7957 if (PyErr_Occurred()) SWIG_fail;
7958 }
7959 {
7960 resultobj = wxPyMake_wxObject(result, 1);
7961 }
7962 {
7963 if (created1)
7964 delete arg1;
7965 }
7966 {
7967 if (temp2)
7968 delete arg2;
7969 }
7970 {
7971 if (temp3)
7972 delete arg3;
7973 }
7974 {
7975 if (temp4)
7976 delete arg4;
7977 }
7978 return resultobj;
7979 fail:
7980 {
7981 if (created1)
7982 delete arg1;
7983 }
7984 {
7985 if (temp2)
7986 delete arg2;
7987 }
7988 {
7989 if (temp3)
7990 delete arg3;
7991 }
7992 {
7993 if (temp4)
7994 delete arg4;
7995 }
7996 return NULL;
7997 }
7998
7999
8000 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8001 PyObject *resultobj;
8002 wxFSFile *arg1 = (wxFSFile *) 0 ;
8003 PyObject * obj0 = 0 ;
8004 char *kwnames[] = {
8005 (char *) "self", NULL
8006 };
8007
8008 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8009 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8010 if (SWIG_arg_fail(1)) SWIG_fail;
8011 {
8012 PyThreadState* __tstate = wxPyBeginAllowThreads();
8013 delete arg1;
8014
8015 wxPyEndAllowThreads(__tstate);
8016 if (PyErr_Occurred()) SWIG_fail;
8017 }
8018 Py_INCREF(Py_None); resultobj = Py_None;
8019 return resultobj;
8020 fail:
8021 return NULL;
8022 }
8023
8024
8025 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8026 PyObject *resultobj;
8027 wxFSFile *arg1 = (wxFSFile *) 0 ;
8028 wxInputStream *result;
8029 PyObject * obj0 = 0 ;
8030 char *kwnames[] = {
8031 (char *) "self", NULL
8032 };
8033
8034 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8035 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8036 if (SWIG_arg_fail(1)) SWIG_fail;
8037 {
8038 PyThreadState* __tstate = wxPyBeginAllowThreads();
8039 result = (wxInputStream *)(arg1)->GetStream();
8040
8041 wxPyEndAllowThreads(__tstate);
8042 if (PyErr_Occurred()) SWIG_fail;
8043 }
8044 {
8045 wxPyInputStream * _ptr = NULL;
8046
8047 if (result) {
8048 _ptr = new wxPyInputStream(result);
8049 }
8050 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8051 }
8052 return resultobj;
8053 fail:
8054 return NULL;
8055 }
8056
8057
8058 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8059 PyObject *resultobj;
8060 wxFSFile *arg1 = (wxFSFile *) 0 ;
8061 wxString *result;
8062 PyObject * obj0 = 0 ;
8063 char *kwnames[] = {
8064 (char *) "self", NULL
8065 };
8066
8067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8069 if (SWIG_arg_fail(1)) SWIG_fail;
8070 {
8071 PyThreadState* __tstate = wxPyBeginAllowThreads();
8072 {
8073 wxString const &_result_ref = (arg1)->GetMimeType();
8074 result = (wxString *) &_result_ref;
8075 }
8076
8077 wxPyEndAllowThreads(__tstate);
8078 if (PyErr_Occurred()) SWIG_fail;
8079 }
8080 {
8081 #if wxUSE_UNICODE
8082 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8083 #else
8084 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8085 #endif
8086 }
8087 return resultobj;
8088 fail:
8089 return NULL;
8090 }
8091
8092
8093 static PyObject *_wrap_FSFile_GetLocation(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_GetLocation",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)->GetLocation();
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_GetAnchor(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_GetAnchor",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)->GetAnchor();
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_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8164 PyObject *resultobj;
8165 wxFSFile *arg1 = (wxFSFile *) 0 ;
8166 wxDateTime result;
8167 PyObject * obj0 = 0 ;
8168 char *kwnames[] = {
8169 (char *) "self", NULL
8170 };
8171
8172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",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 result = (arg1)->GetModificationTime();
8178
8179 wxPyEndAllowThreads(__tstate);
8180 if (PyErr_Occurred()) SWIG_fail;
8181 }
8182 {
8183 wxDateTime * resultptr;
8184 resultptr = new wxDateTime((wxDateTime &)(result));
8185 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8186 }
8187 return resultobj;
8188 fail:
8189 return NULL;
8190 }
8191
8192
8193 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8194 PyObject *obj;
8195 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8196 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8197 Py_INCREF(obj);
8198 return Py_BuildValue((char *)"");
8199 }
8200 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8201 PyObject *obj;
8202 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8203 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8204 Py_INCREF(obj);
8205 return Py_BuildValue((char *)"");
8206 }
8207 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8208 PyObject *resultobj;
8209 wxPyFileSystemHandler *result;
8210 char *kwnames[] = {
8211 NULL
8212 };
8213
8214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8215 {
8216 PyThreadState* __tstate = wxPyBeginAllowThreads();
8217 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8218
8219 wxPyEndAllowThreads(__tstate);
8220 if (PyErr_Occurred()) SWIG_fail;
8221 }
8222 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8223 return resultobj;
8224 fail:
8225 return NULL;
8226 }
8227
8228
8229 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8230 PyObject *resultobj;
8231 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8232 PyObject *arg2 = (PyObject *) 0 ;
8233 PyObject *arg3 = (PyObject *) 0 ;
8234 PyObject * obj0 = 0 ;
8235 PyObject * obj1 = 0 ;
8236 PyObject * obj2 = 0 ;
8237 char *kwnames[] = {
8238 (char *) "self",(char *) "self",(char *) "_class", NULL
8239 };
8240
8241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8243 if (SWIG_arg_fail(1)) SWIG_fail;
8244 arg2 = obj1;
8245 arg3 = obj2;
8246 {
8247 PyThreadState* __tstate = wxPyBeginAllowThreads();
8248 (arg1)->_setCallbackInfo(arg2,arg3);
8249
8250 wxPyEndAllowThreads(__tstate);
8251 if (PyErr_Occurred()) SWIG_fail;
8252 }
8253 Py_INCREF(Py_None); resultobj = Py_None;
8254 return resultobj;
8255 fail:
8256 return NULL;
8257 }
8258
8259
8260 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8261 PyObject *resultobj;
8262 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8263 wxString *arg2 = 0 ;
8264 bool result;
8265 bool temp2 = false ;
8266 PyObject * obj0 = 0 ;
8267 PyObject * obj1 = 0 ;
8268 char *kwnames[] = {
8269 (char *) "self",(char *) "location", NULL
8270 };
8271
8272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8274 if (SWIG_arg_fail(1)) SWIG_fail;
8275 {
8276 arg2 = wxString_in_helper(obj1);
8277 if (arg2 == NULL) SWIG_fail;
8278 temp2 = true;
8279 }
8280 {
8281 PyThreadState* __tstate = wxPyBeginAllowThreads();
8282 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8283
8284 wxPyEndAllowThreads(__tstate);
8285 if (PyErr_Occurred()) SWIG_fail;
8286 }
8287 {
8288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8289 }
8290 {
8291 if (temp2)
8292 delete arg2;
8293 }
8294 return resultobj;
8295 fail:
8296 {
8297 if (temp2)
8298 delete arg2;
8299 }
8300 return NULL;
8301 }
8302
8303
8304 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8305 PyObject *resultobj;
8306 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8307 wxFileSystem *arg2 = 0 ;
8308 wxString *arg3 = 0 ;
8309 wxFSFile *result;
8310 bool temp3 = false ;
8311 PyObject * obj0 = 0 ;
8312 PyObject * obj1 = 0 ;
8313 PyObject * obj2 = 0 ;
8314 char *kwnames[] = {
8315 (char *) "self",(char *) "fs",(char *) "location", NULL
8316 };
8317
8318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8319 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8320 if (SWIG_arg_fail(1)) SWIG_fail;
8321 {
8322 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8323 if (SWIG_arg_fail(2)) SWIG_fail;
8324 if (arg2 == NULL) {
8325 SWIG_null_ref("wxFileSystem");
8326 }
8327 if (SWIG_arg_fail(2)) SWIG_fail;
8328 }
8329 {
8330 arg3 = wxString_in_helper(obj2);
8331 if (arg3 == NULL) SWIG_fail;
8332 temp3 = true;
8333 }
8334 {
8335 PyThreadState* __tstate = wxPyBeginAllowThreads();
8336 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8337
8338 wxPyEndAllowThreads(__tstate);
8339 if (PyErr_Occurred()) SWIG_fail;
8340 }
8341 {
8342 resultobj = wxPyMake_wxObject(result, 1);
8343 }
8344 {
8345 if (temp3)
8346 delete arg3;
8347 }
8348 return resultobj;
8349 fail:
8350 {
8351 if (temp3)
8352 delete arg3;
8353 }
8354 return NULL;
8355 }
8356
8357
8358 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8359 PyObject *resultobj;
8360 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8361 wxString *arg2 = 0 ;
8362 int arg3 = (int) 0 ;
8363 wxString result;
8364 bool temp2 = false ;
8365 PyObject * obj0 = 0 ;
8366 PyObject * obj1 = 0 ;
8367 PyObject * obj2 = 0 ;
8368 char *kwnames[] = {
8369 (char *) "self",(char *) "spec",(char *) "flags", NULL
8370 };
8371
8372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8374 if (SWIG_arg_fail(1)) SWIG_fail;
8375 {
8376 arg2 = wxString_in_helper(obj1);
8377 if (arg2 == NULL) SWIG_fail;
8378 temp2 = true;
8379 }
8380 if (obj2) {
8381 {
8382 arg3 = (int)(SWIG_As_int(obj2));
8383 if (SWIG_arg_fail(3)) SWIG_fail;
8384 }
8385 }
8386 {
8387 PyThreadState* __tstate = wxPyBeginAllowThreads();
8388 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8389
8390 wxPyEndAllowThreads(__tstate);
8391 if (PyErr_Occurred()) SWIG_fail;
8392 }
8393 {
8394 #if wxUSE_UNICODE
8395 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8396 #else
8397 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8398 #endif
8399 }
8400 {
8401 if (temp2)
8402 delete arg2;
8403 }
8404 return resultobj;
8405 fail:
8406 {
8407 if (temp2)
8408 delete arg2;
8409 }
8410 return NULL;
8411 }
8412
8413
8414 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8415 PyObject *resultobj;
8416 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8417 wxString result;
8418 PyObject * obj0 = 0 ;
8419 char *kwnames[] = {
8420 (char *) "self", NULL
8421 };
8422
8423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8425 if (SWIG_arg_fail(1)) SWIG_fail;
8426 {
8427 PyThreadState* __tstate = wxPyBeginAllowThreads();
8428 result = (arg1)->FindNext();
8429
8430 wxPyEndAllowThreads(__tstate);
8431 if (PyErr_Occurred()) SWIG_fail;
8432 }
8433 {
8434 #if wxUSE_UNICODE
8435 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8436 #else
8437 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8438 #endif
8439 }
8440 return resultobj;
8441 fail:
8442 return NULL;
8443 }
8444
8445
8446 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8447 PyObject *resultobj;
8448 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8449 wxString *arg2 = 0 ;
8450 wxString result;
8451 bool temp2 = false ;
8452 PyObject * obj0 = 0 ;
8453 PyObject * obj1 = 0 ;
8454 char *kwnames[] = {
8455 (char *) "self",(char *) "location", NULL
8456 };
8457
8458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) 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 arg2 = wxString_in_helper(obj1);
8463 if (arg2 == NULL) SWIG_fail;
8464 temp2 = true;
8465 }
8466 {
8467 PyThreadState* __tstate = wxPyBeginAllowThreads();
8468 result = (arg1)->GetProtocol((wxString const &)*arg2);
8469
8470 wxPyEndAllowThreads(__tstate);
8471 if (PyErr_Occurred()) SWIG_fail;
8472 }
8473 {
8474 #if wxUSE_UNICODE
8475 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8476 #else
8477 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8478 #endif
8479 }
8480 {
8481 if (temp2)
8482 delete arg2;
8483 }
8484 return resultobj;
8485 fail:
8486 {
8487 if (temp2)
8488 delete arg2;
8489 }
8490 return NULL;
8491 }
8492
8493
8494 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8495 PyObject *resultobj;
8496 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8497 wxString *arg2 = 0 ;
8498 wxString result;
8499 bool temp2 = false ;
8500 PyObject * obj0 = 0 ;
8501 PyObject * obj1 = 0 ;
8502 char *kwnames[] = {
8503 (char *) "self",(char *) "location", NULL
8504 };
8505
8506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8508 if (SWIG_arg_fail(1)) SWIG_fail;
8509 {
8510 arg2 = wxString_in_helper(obj1);
8511 if (arg2 == NULL) SWIG_fail;
8512 temp2 = true;
8513 }
8514 {
8515 PyThreadState* __tstate = wxPyBeginAllowThreads();
8516 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8517
8518 wxPyEndAllowThreads(__tstate);
8519 if (PyErr_Occurred()) SWIG_fail;
8520 }
8521 {
8522 #if wxUSE_UNICODE
8523 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8524 #else
8525 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8526 #endif
8527 }
8528 {
8529 if (temp2)
8530 delete arg2;
8531 }
8532 return resultobj;
8533 fail:
8534 {
8535 if (temp2)
8536 delete arg2;
8537 }
8538 return NULL;
8539 }
8540
8541
8542 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8543 PyObject *resultobj;
8544 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8545 wxString *arg2 = 0 ;
8546 wxString result;
8547 bool temp2 = false ;
8548 PyObject * obj0 = 0 ;
8549 PyObject * obj1 = 0 ;
8550 char *kwnames[] = {
8551 (char *) "self",(char *) "location", NULL
8552 };
8553
8554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8556 if (SWIG_arg_fail(1)) SWIG_fail;
8557 {
8558 arg2 = wxString_in_helper(obj1);
8559 if (arg2 == NULL) SWIG_fail;
8560 temp2 = true;
8561 }
8562 {
8563 PyThreadState* __tstate = wxPyBeginAllowThreads();
8564 result = (arg1)->GetAnchor((wxString const &)*arg2);
8565
8566 wxPyEndAllowThreads(__tstate);
8567 if (PyErr_Occurred()) SWIG_fail;
8568 }
8569 {
8570 #if wxUSE_UNICODE
8571 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8572 #else
8573 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8574 #endif
8575 }
8576 {
8577 if (temp2)
8578 delete arg2;
8579 }
8580 return resultobj;
8581 fail:
8582 {
8583 if (temp2)
8584 delete arg2;
8585 }
8586 return NULL;
8587 }
8588
8589
8590 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8591 PyObject *resultobj;
8592 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8593 wxString *arg2 = 0 ;
8594 wxString result;
8595 bool temp2 = false ;
8596 PyObject * obj0 = 0 ;
8597 PyObject * obj1 = 0 ;
8598 char *kwnames[] = {
8599 (char *) "self",(char *) "location", NULL
8600 };
8601
8602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8604 if (SWIG_arg_fail(1)) SWIG_fail;
8605 {
8606 arg2 = wxString_in_helper(obj1);
8607 if (arg2 == NULL) SWIG_fail;
8608 temp2 = true;
8609 }
8610 {
8611 PyThreadState* __tstate = wxPyBeginAllowThreads();
8612 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8613
8614 wxPyEndAllowThreads(__tstate);
8615 if (PyErr_Occurred()) SWIG_fail;
8616 }
8617 {
8618 #if wxUSE_UNICODE
8619 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8620 #else
8621 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8622 #endif
8623 }
8624 {
8625 if (temp2)
8626 delete arg2;
8627 }
8628 return resultobj;
8629 fail:
8630 {
8631 if (temp2)
8632 delete arg2;
8633 }
8634 return NULL;
8635 }
8636
8637
8638 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8639 PyObject *resultobj;
8640 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8641 wxString *arg2 = 0 ;
8642 wxString result;
8643 bool temp2 = false ;
8644 PyObject * obj0 = 0 ;
8645 PyObject * obj1 = 0 ;
8646 char *kwnames[] = {
8647 (char *) "self",(char *) "location", NULL
8648 };
8649
8650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8652 if (SWIG_arg_fail(1)) SWIG_fail;
8653 {
8654 arg2 = wxString_in_helper(obj1);
8655 if (arg2 == NULL) SWIG_fail;
8656 temp2 = true;
8657 }
8658 {
8659 PyThreadState* __tstate = wxPyBeginAllowThreads();
8660 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8661
8662 wxPyEndAllowThreads(__tstate);
8663 if (PyErr_Occurred()) SWIG_fail;
8664 }
8665 {
8666 #if wxUSE_UNICODE
8667 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8668 #else
8669 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8670 #endif
8671 }
8672 {
8673 if (temp2)
8674 delete arg2;
8675 }
8676 return resultobj;
8677 fail:
8678 {
8679 if (temp2)
8680 delete arg2;
8681 }
8682 return NULL;
8683 }
8684
8685
8686 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8687 PyObject *obj;
8688 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8689 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8690 Py_INCREF(obj);
8691 return Py_BuildValue((char *)"");
8692 }
8693 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8694 PyObject *resultobj;
8695 wxFileSystem *result;
8696 char *kwnames[] = {
8697 NULL
8698 };
8699
8700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8701 {
8702 PyThreadState* __tstate = wxPyBeginAllowThreads();
8703 result = (wxFileSystem *)new wxFileSystem();
8704
8705 wxPyEndAllowThreads(__tstate);
8706 if (PyErr_Occurred()) SWIG_fail;
8707 }
8708 {
8709 resultobj = wxPyMake_wxObject(result, 1);
8710 }
8711 return resultobj;
8712 fail:
8713 return NULL;
8714 }
8715
8716
8717 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8718 PyObject *resultobj;
8719 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8720 PyObject * obj0 = 0 ;
8721 char *kwnames[] = {
8722 (char *) "self", NULL
8723 };
8724
8725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8727 if (SWIG_arg_fail(1)) SWIG_fail;
8728 {
8729 PyThreadState* __tstate = wxPyBeginAllowThreads();
8730 delete arg1;
8731
8732 wxPyEndAllowThreads(__tstate);
8733 if (PyErr_Occurred()) SWIG_fail;
8734 }
8735 Py_INCREF(Py_None); resultobj = Py_None;
8736 return resultobj;
8737 fail:
8738 return NULL;
8739 }
8740
8741
8742 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8743 PyObject *resultobj;
8744 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8745 wxString *arg2 = 0 ;
8746 bool arg3 = (bool) false ;
8747 bool temp2 = false ;
8748 PyObject * obj0 = 0 ;
8749 PyObject * obj1 = 0 ;
8750 PyObject * obj2 = 0 ;
8751 char *kwnames[] = {
8752 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8753 };
8754
8755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8757 if (SWIG_arg_fail(1)) SWIG_fail;
8758 {
8759 arg2 = wxString_in_helper(obj1);
8760 if (arg2 == NULL) SWIG_fail;
8761 temp2 = true;
8762 }
8763 if (obj2) {
8764 {
8765 arg3 = (bool)(SWIG_As_bool(obj2));
8766 if (SWIG_arg_fail(3)) SWIG_fail;
8767 }
8768 }
8769 {
8770 PyThreadState* __tstate = wxPyBeginAllowThreads();
8771 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8772
8773 wxPyEndAllowThreads(__tstate);
8774 if (PyErr_Occurred()) SWIG_fail;
8775 }
8776 Py_INCREF(Py_None); resultobj = Py_None;
8777 {
8778 if (temp2)
8779 delete arg2;
8780 }
8781 return resultobj;
8782 fail:
8783 {
8784 if (temp2)
8785 delete arg2;
8786 }
8787 return NULL;
8788 }
8789
8790
8791 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8792 PyObject *resultobj;
8793 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8794 wxString result;
8795 PyObject * obj0 = 0 ;
8796 char *kwnames[] = {
8797 (char *) "self", NULL
8798 };
8799
8800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8802 if (SWIG_arg_fail(1)) SWIG_fail;
8803 {
8804 PyThreadState* __tstate = wxPyBeginAllowThreads();
8805 result = (arg1)->GetPath();
8806
8807 wxPyEndAllowThreads(__tstate);
8808 if (PyErr_Occurred()) SWIG_fail;
8809 }
8810 {
8811 #if wxUSE_UNICODE
8812 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8813 #else
8814 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8815 #endif
8816 }
8817 return resultobj;
8818 fail:
8819 return NULL;
8820 }
8821
8822
8823 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8824 PyObject *resultobj;
8825 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8826 wxString *arg2 = 0 ;
8827 wxFSFile *result;
8828 bool temp2 = false ;
8829 PyObject * obj0 = 0 ;
8830 PyObject * obj1 = 0 ;
8831 char *kwnames[] = {
8832 (char *) "self",(char *) "location", NULL
8833 };
8834
8835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) 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 arg2 = wxString_in_helper(obj1);
8840 if (arg2 == NULL) SWIG_fail;
8841 temp2 = true;
8842 }
8843 {
8844 PyThreadState* __tstate = wxPyBeginAllowThreads();
8845 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8846
8847 wxPyEndAllowThreads(__tstate);
8848 if (PyErr_Occurred()) SWIG_fail;
8849 }
8850 {
8851 resultobj = wxPyMake_wxObject(result, 1);
8852 }
8853 {
8854 if (temp2)
8855 delete arg2;
8856 }
8857 return resultobj;
8858 fail:
8859 {
8860 if (temp2)
8861 delete arg2;
8862 }
8863 return NULL;
8864 }
8865
8866
8867 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8868 PyObject *resultobj;
8869 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8870 wxString *arg2 = 0 ;
8871 int arg3 = (int) 0 ;
8872 wxString result;
8873 bool temp2 = false ;
8874 PyObject * obj0 = 0 ;
8875 PyObject * obj1 = 0 ;
8876 PyObject * obj2 = 0 ;
8877 char *kwnames[] = {
8878 (char *) "self",(char *) "spec",(char *) "flags", NULL
8879 };
8880
8881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8883 if (SWIG_arg_fail(1)) SWIG_fail;
8884 {
8885 arg2 = wxString_in_helper(obj1);
8886 if (arg2 == NULL) SWIG_fail;
8887 temp2 = true;
8888 }
8889 if (obj2) {
8890 {
8891 arg3 = (int)(SWIG_As_int(obj2));
8892 if (SWIG_arg_fail(3)) SWIG_fail;
8893 }
8894 }
8895 {
8896 PyThreadState* __tstate = wxPyBeginAllowThreads();
8897 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8898
8899 wxPyEndAllowThreads(__tstate);
8900 if (PyErr_Occurred()) SWIG_fail;
8901 }
8902 {
8903 #if wxUSE_UNICODE
8904 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8905 #else
8906 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8907 #endif
8908 }
8909 {
8910 if (temp2)
8911 delete arg2;
8912 }
8913 return resultobj;
8914 fail:
8915 {
8916 if (temp2)
8917 delete arg2;
8918 }
8919 return NULL;
8920 }
8921
8922
8923 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8924 PyObject *resultobj;
8925 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8926 wxString result;
8927 PyObject * obj0 = 0 ;
8928 char *kwnames[] = {
8929 (char *) "self", NULL
8930 };
8931
8932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8934 if (SWIG_arg_fail(1)) SWIG_fail;
8935 {
8936 PyThreadState* __tstate = wxPyBeginAllowThreads();
8937 result = (arg1)->FindNext();
8938
8939 wxPyEndAllowThreads(__tstate);
8940 if (PyErr_Occurred()) SWIG_fail;
8941 }
8942 {
8943 #if wxUSE_UNICODE
8944 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8945 #else
8946 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8947 #endif
8948 }
8949 return resultobj;
8950 fail:
8951 return NULL;
8952 }
8953
8954
8955 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8956 PyObject *resultobj;
8957 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
8958 PyObject * obj0 = 0 ;
8959 char *kwnames[] = {
8960 (char *) "handler", NULL
8961 };
8962
8963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
8964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8965 if (SWIG_arg_fail(1)) SWIG_fail;
8966 {
8967 PyThreadState* __tstate = wxPyBeginAllowThreads();
8968 wxFileSystem::AddHandler(arg1);
8969
8970 wxPyEndAllowThreads(__tstate);
8971 if (PyErr_Occurred()) SWIG_fail;
8972 }
8973 Py_INCREF(Py_None); resultobj = Py_None;
8974 return resultobj;
8975 fail:
8976 return NULL;
8977 }
8978
8979
8980 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
8981 PyObject *resultobj;
8982 char *kwnames[] = {
8983 NULL
8984 };
8985
8986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
8987 {
8988 PyThreadState* __tstate = wxPyBeginAllowThreads();
8989 wxFileSystem::CleanUpHandlers();
8990
8991 wxPyEndAllowThreads(__tstate);
8992 if (PyErr_Occurred()) SWIG_fail;
8993 }
8994 Py_INCREF(Py_None); resultobj = Py_None;
8995 return resultobj;
8996 fail:
8997 return NULL;
8998 }
8999
9000
9001 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9002 PyObject *resultobj;
9003 wxString *arg1 = 0 ;
9004 wxString result;
9005 bool temp1 = false ;
9006 PyObject * obj0 = 0 ;
9007 char *kwnames[] = {
9008 (char *) "filename", NULL
9009 };
9010
9011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9012 {
9013 arg1 = wxString_in_helper(obj0);
9014 if (arg1 == NULL) SWIG_fail;
9015 temp1 = true;
9016 }
9017 {
9018 PyThreadState* __tstate = wxPyBeginAllowThreads();
9019 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9020
9021 wxPyEndAllowThreads(__tstate);
9022 if (PyErr_Occurred()) SWIG_fail;
9023 }
9024 {
9025 #if wxUSE_UNICODE
9026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9027 #else
9028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9029 #endif
9030 }
9031 {
9032 if (temp1)
9033 delete arg1;
9034 }
9035 return resultobj;
9036 fail:
9037 {
9038 if (temp1)
9039 delete arg1;
9040 }
9041 return NULL;
9042 }
9043
9044
9045 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9046 PyObject *resultobj;
9047 wxString *arg1 = 0 ;
9048 wxString result;
9049 bool temp1 = false ;
9050 PyObject * obj0 = 0 ;
9051 char *kwnames[] = {
9052 (char *) "url", NULL
9053 };
9054
9055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9056 {
9057 arg1 = wxString_in_helper(obj0);
9058 if (arg1 == NULL) SWIG_fail;
9059 temp1 = true;
9060 }
9061 {
9062 PyThreadState* __tstate = wxPyBeginAllowThreads();
9063 result = FileSystem_URLToFileName((wxString const &)*arg1);
9064
9065 wxPyEndAllowThreads(__tstate);
9066 if (PyErr_Occurred()) SWIG_fail;
9067 }
9068 {
9069 #if wxUSE_UNICODE
9070 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9071 #else
9072 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9073 #endif
9074 }
9075 {
9076 if (temp1)
9077 delete arg1;
9078 }
9079 return resultobj;
9080 fail:
9081 {
9082 if (temp1)
9083 delete arg1;
9084 }
9085 return NULL;
9086 }
9087
9088
9089 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9090 PyObject *obj;
9091 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9092 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9093 Py_INCREF(obj);
9094 return Py_BuildValue((char *)"");
9095 }
9096 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9097 PyObject *resultobj;
9098 wxInternetFSHandler *result;
9099 char *kwnames[] = {
9100 NULL
9101 };
9102
9103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9104 {
9105 PyThreadState* __tstate = wxPyBeginAllowThreads();
9106 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9107
9108 wxPyEndAllowThreads(__tstate);
9109 if (PyErr_Occurred()) SWIG_fail;
9110 }
9111 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9112 return resultobj;
9113 fail:
9114 return NULL;
9115 }
9116
9117
9118 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9119 PyObject *resultobj;
9120 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9121 wxString *arg2 = 0 ;
9122 bool result;
9123 bool temp2 = false ;
9124 PyObject * obj0 = 0 ;
9125 PyObject * obj1 = 0 ;
9126 char *kwnames[] = {
9127 (char *) "self",(char *) "location", NULL
9128 };
9129
9130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9132 if (SWIG_arg_fail(1)) SWIG_fail;
9133 {
9134 arg2 = wxString_in_helper(obj1);
9135 if (arg2 == NULL) SWIG_fail;
9136 temp2 = true;
9137 }
9138 {
9139 PyThreadState* __tstate = wxPyBeginAllowThreads();
9140 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9141
9142 wxPyEndAllowThreads(__tstate);
9143 if (PyErr_Occurred()) SWIG_fail;
9144 }
9145 {
9146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9147 }
9148 {
9149 if (temp2)
9150 delete arg2;
9151 }
9152 return resultobj;
9153 fail:
9154 {
9155 if (temp2)
9156 delete arg2;
9157 }
9158 return NULL;
9159 }
9160
9161
9162 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9163 PyObject *resultobj;
9164 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9165 wxFileSystem *arg2 = 0 ;
9166 wxString *arg3 = 0 ;
9167 wxFSFile *result;
9168 bool temp3 = false ;
9169 PyObject * obj0 = 0 ;
9170 PyObject * obj1 = 0 ;
9171 PyObject * obj2 = 0 ;
9172 char *kwnames[] = {
9173 (char *) "self",(char *) "fs",(char *) "location", NULL
9174 };
9175
9176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9178 if (SWIG_arg_fail(1)) SWIG_fail;
9179 {
9180 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9181 if (SWIG_arg_fail(2)) SWIG_fail;
9182 if (arg2 == NULL) {
9183 SWIG_null_ref("wxFileSystem");
9184 }
9185 if (SWIG_arg_fail(2)) SWIG_fail;
9186 }
9187 {
9188 arg3 = wxString_in_helper(obj2);
9189 if (arg3 == NULL) SWIG_fail;
9190 temp3 = true;
9191 }
9192 {
9193 PyThreadState* __tstate = wxPyBeginAllowThreads();
9194 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9195
9196 wxPyEndAllowThreads(__tstate);
9197 if (PyErr_Occurred()) SWIG_fail;
9198 }
9199 {
9200 resultobj = wxPyMake_wxObject(result, 1);
9201 }
9202 {
9203 if (temp3)
9204 delete arg3;
9205 }
9206 return resultobj;
9207 fail:
9208 {
9209 if (temp3)
9210 delete arg3;
9211 }
9212 return NULL;
9213 }
9214
9215
9216 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9217 PyObject *obj;
9218 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9219 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9220 Py_INCREF(obj);
9221 return Py_BuildValue((char *)"");
9222 }
9223 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9224 PyObject *resultobj;
9225 wxZipFSHandler *result;
9226 char *kwnames[] = {
9227 NULL
9228 };
9229
9230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9231 {
9232 PyThreadState* __tstate = wxPyBeginAllowThreads();
9233 result = (wxZipFSHandler *)new wxZipFSHandler();
9234
9235 wxPyEndAllowThreads(__tstate);
9236 if (PyErr_Occurred()) SWIG_fail;
9237 }
9238 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9239 return resultobj;
9240 fail:
9241 return NULL;
9242 }
9243
9244
9245 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9246 PyObject *resultobj;
9247 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9248 wxString *arg2 = 0 ;
9249 bool result;
9250 bool temp2 = false ;
9251 PyObject * obj0 = 0 ;
9252 PyObject * obj1 = 0 ;
9253 char *kwnames[] = {
9254 (char *) "self",(char *) "location", NULL
9255 };
9256
9257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9259 if (SWIG_arg_fail(1)) SWIG_fail;
9260 {
9261 arg2 = wxString_in_helper(obj1);
9262 if (arg2 == NULL) SWIG_fail;
9263 temp2 = true;
9264 }
9265 {
9266 PyThreadState* __tstate = wxPyBeginAllowThreads();
9267 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9268
9269 wxPyEndAllowThreads(__tstate);
9270 if (PyErr_Occurred()) SWIG_fail;
9271 }
9272 {
9273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9274 }
9275 {
9276 if (temp2)
9277 delete arg2;
9278 }
9279 return resultobj;
9280 fail:
9281 {
9282 if (temp2)
9283 delete arg2;
9284 }
9285 return NULL;
9286 }
9287
9288
9289 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9290 PyObject *resultobj;
9291 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9292 wxFileSystem *arg2 = 0 ;
9293 wxString *arg3 = 0 ;
9294 wxFSFile *result;
9295 bool temp3 = false ;
9296 PyObject * obj0 = 0 ;
9297 PyObject * obj1 = 0 ;
9298 PyObject * obj2 = 0 ;
9299 char *kwnames[] = {
9300 (char *) "self",(char *) "fs",(char *) "location", NULL
9301 };
9302
9303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9305 if (SWIG_arg_fail(1)) SWIG_fail;
9306 {
9307 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9308 if (SWIG_arg_fail(2)) SWIG_fail;
9309 if (arg2 == NULL) {
9310 SWIG_null_ref("wxFileSystem");
9311 }
9312 if (SWIG_arg_fail(2)) SWIG_fail;
9313 }
9314 {
9315 arg3 = wxString_in_helper(obj2);
9316 if (arg3 == NULL) SWIG_fail;
9317 temp3 = true;
9318 }
9319 {
9320 PyThreadState* __tstate = wxPyBeginAllowThreads();
9321 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9322
9323 wxPyEndAllowThreads(__tstate);
9324 if (PyErr_Occurred()) SWIG_fail;
9325 }
9326 {
9327 resultobj = wxPyMake_wxObject(result, 1);
9328 }
9329 {
9330 if (temp3)
9331 delete arg3;
9332 }
9333 return resultobj;
9334 fail:
9335 {
9336 if (temp3)
9337 delete arg3;
9338 }
9339 return NULL;
9340 }
9341
9342
9343 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9344 PyObject *resultobj;
9345 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9346 wxString *arg2 = 0 ;
9347 int arg3 = (int) 0 ;
9348 wxString result;
9349 bool temp2 = false ;
9350 PyObject * obj0 = 0 ;
9351 PyObject * obj1 = 0 ;
9352 PyObject * obj2 = 0 ;
9353 char *kwnames[] = {
9354 (char *) "self",(char *) "spec",(char *) "flags", NULL
9355 };
9356
9357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9359 if (SWIG_arg_fail(1)) SWIG_fail;
9360 {
9361 arg2 = wxString_in_helper(obj1);
9362 if (arg2 == NULL) SWIG_fail;
9363 temp2 = true;
9364 }
9365 if (obj2) {
9366 {
9367 arg3 = (int)(SWIG_As_int(obj2));
9368 if (SWIG_arg_fail(3)) SWIG_fail;
9369 }
9370 }
9371 {
9372 PyThreadState* __tstate = wxPyBeginAllowThreads();
9373 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9374
9375 wxPyEndAllowThreads(__tstate);
9376 if (PyErr_Occurred()) SWIG_fail;
9377 }
9378 {
9379 #if wxUSE_UNICODE
9380 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9381 #else
9382 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9383 #endif
9384 }
9385 {
9386 if (temp2)
9387 delete arg2;
9388 }
9389 return resultobj;
9390 fail:
9391 {
9392 if (temp2)
9393 delete arg2;
9394 }
9395 return NULL;
9396 }
9397
9398
9399 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9400 PyObject *resultobj;
9401 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9402 wxString result;
9403 PyObject * obj0 = 0 ;
9404 char *kwnames[] = {
9405 (char *) "self", NULL
9406 };
9407
9408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9410 if (SWIG_arg_fail(1)) SWIG_fail;
9411 {
9412 PyThreadState* __tstate = wxPyBeginAllowThreads();
9413 result = (arg1)->FindNext();
9414
9415 wxPyEndAllowThreads(__tstate);
9416 if (PyErr_Occurred()) SWIG_fail;
9417 }
9418 {
9419 #if wxUSE_UNICODE
9420 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9421 #else
9422 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9423 #endif
9424 }
9425 return resultobj;
9426 fail:
9427 return NULL;
9428 }
9429
9430
9431 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9432 PyObject *obj;
9433 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9434 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9435 Py_INCREF(obj);
9436 return Py_BuildValue((char *)"");
9437 }
9438 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9439 PyObject *resultobj;
9440 wxString *arg1 = 0 ;
9441 wxImage *arg2 = 0 ;
9442 long arg3 ;
9443 bool temp1 = false ;
9444 PyObject * obj0 = 0 ;
9445 PyObject * obj1 = 0 ;
9446 PyObject * obj2 = 0 ;
9447 char *kwnames[] = {
9448 (char *) "filename",(char *) "image",(char *) "type", NULL
9449 };
9450
9451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9452 {
9453 arg1 = wxString_in_helper(obj0);
9454 if (arg1 == NULL) SWIG_fail;
9455 temp1 = true;
9456 }
9457 {
9458 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9459 if (SWIG_arg_fail(2)) SWIG_fail;
9460 if (arg2 == NULL) {
9461 SWIG_null_ref("wxImage");
9462 }
9463 if (SWIG_arg_fail(2)) SWIG_fail;
9464 }
9465 {
9466 arg3 = (long)(SWIG_As_long(obj2));
9467 if (SWIG_arg_fail(3)) SWIG_fail;
9468 }
9469 {
9470 PyThreadState* __tstate = wxPyBeginAllowThreads();
9471 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9472
9473 wxPyEndAllowThreads(__tstate);
9474 if (PyErr_Occurred()) SWIG_fail;
9475 }
9476 Py_INCREF(Py_None); resultobj = Py_None;
9477 {
9478 if (temp1)
9479 delete arg1;
9480 }
9481 return resultobj;
9482 fail:
9483 {
9484 if (temp1)
9485 delete arg1;
9486 }
9487 return NULL;
9488 }
9489
9490
9491 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9492 PyObject *resultobj;
9493 wxString *arg1 = 0 ;
9494 wxBitmap *arg2 = 0 ;
9495 long arg3 ;
9496 bool temp1 = false ;
9497 PyObject * obj0 = 0 ;
9498 PyObject * obj1 = 0 ;
9499 PyObject * obj2 = 0 ;
9500 char *kwnames[] = {
9501 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9502 };
9503
9504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9505 {
9506 arg1 = wxString_in_helper(obj0);
9507 if (arg1 == NULL) SWIG_fail;
9508 temp1 = true;
9509 }
9510 {
9511 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9512 if (SWIG_arg_fail(2)) SWIG_fail;
9513 if (arg2 == NULL) {
9514 SWIG_null_ref("wxBitmap");
9515 }
9516 if (SWIG_arg_fail(2)) SWIG_fail;
9517 }
9518 {
9519 arg3 = (long)(SWIG_As_long(obj2));
9520 if (SWIG_arg_fail(3)) SWIG_fail;
9521 }
9522 {
9523 PyThreadState* __tstate = wxPyBeginAllowThreads();
9524 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9525
9526 wxPyEndAllowThreads(__tstate);
9527 if (PyErr_Occurred()) SWIG_fail;
9528 }
9529 Py_INCREF(Py_None); resultobj = Py_None;
9530 {
9531 if (temp1)
9532 delete arg1;
9533 }
9534 return resultobj;
9535 fail:
9536 {
9537 if (temp1)
9538 delete arg1;
9539 }
9540 return NULL;
9541 }
9542
9543
9544 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9545 PyObject *resultobj;
9546 wxString *arg1 = 0 ;
9547 PyObject *arg2 = (PyObject *) 0 ;
9548 bool temp1 = false ;
9549 PyObject * obj0 = 0 ;
9550 PyObject * obj1 = 0 ;
9551 char *kwnames[] = {
9552 (char *) "filename",(char *) "data", NULL
9553 };
9554
9555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9556 {
9557 arg1 = wxString_in_helper(obj0);
9558 if (arg1 == NULL) SWIG_fail;
9559 temp1 = true;
9560 }
9561 arg2 = obj1;
9562 {
9563 PyThreadState* __tstate = wxPyBeginAllowThreads();
9564 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9565
9566 wxPyEndAllowThreads(__tstate);
9567 if (PyErr_Occurred()) SWIG_fail;
9568 }
9569 Py_INCREF(Py_None); resultobj = Py_None;
9570 {
9571 if (temp1)
9572 delete arg1;
9573 }
9574 return resultobj;
9575 fail:
9576 {
9577 if (temp1)
9578 delete arg1;
9579 }
9580 return NULL;
9581 }
9582
9583
9584 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9585 PyObject *resultobj;
9586 wxMemoryFSHandler *result;
9587 char *kwnames[] = {
9588 NULL
9589 };
9590
9591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9592 {
9593 PyThreadState* __tstate = wxPyBeginAllowThreads();
9594 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9595
9596 wxPyEndAllowThreads(__tstate);
9597 if (PyErr_Occurred()) SWIG_fail;
9598 }
9599 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9600 return resultobj;
9601 fail:
9602 return NULL;
9603 }
9604
9605
9606 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9607 PyObject *resultobj;
9608 wxString *arg1 = 0 ;
9609 bool temp1 = false ;
9610 PyObject * obj0 = 0 ;
9611 char *kwnames[] = {
9612 (char *) "filename", NULL
9613 };
9614
9615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9616 {
9617 arg1 = wxString_in_helper(obj0);
9618 if (arg1 == NULL) SWIG_fail;
9619 temp1 = true;
9620 }
9621 {
9622 PyThreadState* __tstate = wxPyBeginAllowThreads();
9623 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9624
9625 wxPyEndAllowThreads(__tstate);
9626 if (PyErr_Occurred()) SWIG_fail;
9627 }
9628 Py_INCREF(Py_None); resultobj = Py_None;
9629 {
9630 if (temp1)
9631 delete arg1;
9632 }
9633 return resultobj;
9634 fail:
9635 {
9636 if (temp1)
9637 delete arg1;
9638 }
9639 return NULL;
9640 }
9641
9642
9643 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9644 PyObject *resultobj;
9645 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9646 wxString *arg2 = 0 ;
9647 bool result;
9648 bool temp2 = false ;
9649 PyObject * obj0 = 0 ;
9650 PyObject * obj1 = 0 ;
9651 char *kwnames[] = {
9652 (char *) "self",(char *) "location", NULL
9653 };
9654
9655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9657 if (SWIG_arg_fail(1)) SWIG_fail;
9658 {
9659 arg2 = wxString_in_helper(obj1);
9660 if (arg2 == NULL) SWIG_fail;
9661 temp2 = true;
9662 }
9663 {
9664 PyThreadState* __tstate = wxPyBeginAllowThreads();
9665 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9666
9667 wxPyEndAllowThreads(__tstate);
9668 if (PyErr_Occurred()) SWIG_fail;
9669 }
9670 {
9671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9672 }
9673 {
9674 if (temp2)
9675 delete arg2;
9676 }
9677 return resultobj;
9678 fail:
9679 {
9680 if (temp2)
9681 delete arg2;
9682 }
9683 return NULL;
9684 }
9685
9686
9687 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9688 PyObject *resultobj;
9689 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9690 wxFileSystem *arg2 = 0 ;
9691 wxString *arg3 = 0 ;
9692 wxFSFile *result;
9693 bool temp3 = false ;
9694 PyObject * obj0 = 0 ;
9695 PyObject * obj1 = 0 ;
9696 PyObject * obj2 = 0 ;
9697 char *kwnames[] = {
9698 (char *) "self",(char *) "fs",(char *) "location", NULL
9699 };
9700
9701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9703 if (SWIG_arg_fail(1)) SWIG_fail;
9704 {
9705 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9706 if (SWIG_arg_fail(2)) SWIG_fail;
9707 if (arg2 == NULL) {
9708 SWIG_null_ref("wxFileSystem");
9709 }
9710 if (SWIG_arg_fail(2)) SWIG_fail;
9711 }
9712 {
9713 arg3 = wxString_in_helper(obj2);
9714 if (arg3 == NULL) SWIG_fail;
9715 temp3 = true;
9716 }
9717 {
9718 PyThreadState* __tstate = wxPyBeginAllowThreads();
9719 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9720
9721 wxPyEndAllowThreads(__tstate);
9722 if (PyErr_Occurred()) SWIG_fail;
9723 }
9724 {
9725 resultobj = wxPyMake_wxObject(result, 1);
9726 }
9727 {
9728 if (temp3)
9729 delete arg3;
9730 }
9731 return resultobj;
9732 fail:
9733 {
9734 if (temp3)
9735 delete arg3;
9736 }
9737 return NULL;
9738 }
9739
9740
9741 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9742 PyObject *resultobj;
9743 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9744 wxString *arg2 = 0 ;
9745 int arg3 = (int) 0 ;
9746 wxString result;
9747 bool temp2 = false ;
9748 PyObject * obj0 = 0 ;
9749 PyObject * obj1 = 0 ;
9750 PyObject * obj2 = 0 ;
9751 char *kwnames[] = {
9752 (char *) "self",(char *) "spec",(char *) "flags", NULL
9753 };
9754
9755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9757 if (SWIG_arg_fail(1)) SWIG_fail;
9758 {
9759 arg2 = wxString_in_helper(obj1);
9760 if (arg2 == NULL) SWIG_fail;
9761 temp2 = true;
9762 }
9763 if (obj2) {
9764 {
9765 arg3 = (int)(SWIG_As_int(obj2));
9766 if (SWIG_arg_fail(3)) SWIG_fail;
9767 }
9768 }
9769 {
9770 PyThreadState* __tstate = wxPyBeginAllowThreads();
9771 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9772
9773 wxPyEndAllowThreads(__tstate);
9774 if (PyErr_Occurred()) SWIG_fail;
9775 }
9776 {
9777 #if wxUSE_UNICODE
9778 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9779 #else
9780 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9781 #endif
9782 }
9783 {
9784 if (temp2)
9785 delete arg2;
9786 }
9787 return resultobj;
9788 fail:
9789 {
9790 if (temp2)
9791 delete arg2;
9792 }
9793 return NULL;
9794 }
9795
9796
9797 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9798 PyObject *resultobj;
9799 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9800 wxString result;
9801 PyObject * obj0 = 0 ;
9802 char *kwnames[] = {
9803 (char *) "self", NULL
9804 };
9805
9806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9808 if (SWIG_arg_fail(1)) SWIG_fail;
9809 {
9810 PyThreadState* __tstate = wxPyBeginAllowThreads();
9811 result = (arg1)->FindNext();
9812
9813 wxPyEndAllowThreads(__tstate);
9814 if (PyErr_Occurred()) SWIG_fail;
9815 }
9816 {
9817 #if wxUSE_UNICODE
9818 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9819 #else
9820 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9821 #endif
9822 }
9823 return resultobj;
9824 fail:
9825 return NULL;
9826 }
9827
9828
9829 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9830 PyObject *obj;
9831 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9832 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9833 Py_INCREF(obj);
9834 return Py_BuildValue((char *)"");
9835 }
9836 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9837 PyObject *resultobj;
9838 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9839 wxString result;
9840 PyObject * obj0 = 0 ;
9841 char *kwnames[] = {
9842 (char *) "self", NULL
9843 };
9844
9845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9847 if (SWIG_arg_fail(1)) SWIG_fail;
9848 {
9849 PyThreadState* __tstate = wxPyBeginAllowThreads();
9850 result = (arg1)->GetName();
9851
9852 wxPyEndAllowThreads(__tstate);
9853 if (PyErr_Occurred()) SWIG_fail;
9854 }
9855 {
9856 #if wxUSE_UNICODE
9857 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9858 #else
9859 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9860 #endif
9861 }
9862 return resultobj;
9863 fail:
9864 return NULL;
9865 }
9866
9867
9868 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9869 PyObject *resultobj;
9870 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9871 wxString result;
9872 PyObject * obj0 = 0 ;
9873 char *kwnames[] = {
9874 (char *) "self", NULL
9875 };
9876
9877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9879 if (SWIG_arg_fail(1)) SWIG_fail;
9880 {
9881 PyThreadState* __tstate = wxPyBeginAllowThreads();
9882 result = (arg1)->GetExtension();
9883
9884 wxPyEndAllowThreads(__tstate);
9885 if (PyErr_Occurred()) SWIG_fail;
9886 }
9887 {
9888 #if wxUSE_UNICODE
9889 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9890 #else
9891 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9892 #endif
9893 }
9894 return resultobj;
9895 fail:
9896 return NULL;
9897 }
9898
9899
9900 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9901 PyObject *resultobj;
9902 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9903 long result;
9904 PyObject * obj0 = 0 ;
9905 char *kwnames[] = {
9906 (char *) "self", NULL
9907 };
9908
9909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9911 if (SWIG_arg_fail(1)) SWIG_fail;
9912 {
9913 PyThreadState* __tstate = wxPyBeginAllowThreads();
9914 result = (long)(arg1)->GetType();
9915
9916 wxPyEndAllowThreads(__tstate);
9917 if (PyErr_Occurred()) SWIG_fail;
9918 }
9919 {
9920 resultobj = SWIG_From_long((long)(result));
9921 }
9922 return resultobj;
9923 fail:
9924 return NULL;
9925 }
9926
9927
9928 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9929 PyObject *resultobj;
9930 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9931 wxString result;
9932 PyObject * obj0 = 0 ;
9933 char *kwnames[] = {
9934 (char *) "self", NULL
9935 };
9936
9937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9939 if (SWIG_arg_fail(1)) SWIG_fail;
9940 {
9941 PyThreadState* __tstate = wxPyBeginAllowThreads();
9942 result = (arg1)->GetMimeType();
9943
9944 wxPyEndAllowThreads(__tstate);
9945 if (PyErr_Occurred()) SWIG_fail;
9946 }
9947 {
9948 #if wxUSE_UNICODE
9949 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9950 #else
9951 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9952 #endif
9953 }
9954 return resultobj;
9955 fail:
9956 return NULL;
9957 }
9958
9959
9960 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
9961 PyObject *resultobj;
9962 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9963 wxString *arg2 = 0 ;
9964 bool result;
9965 bool temp2 = false ;
9966 PyObject * obj0 = 0 ;
9967 PyObject * obj1 = 0 ;
9968 char *kwnames[] = {
9969 (char *) "self",(char *) "name", NULL
9970 };
9971
9972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) 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 arg2 = wxString_in_helper(obj1);
9977 if (arg2 == NULL) SWIG_fail;
9978 temp2 = true;
9979 }
9980 {
9981 PyThreadState* __tstate = wxPyBeginAllowThreads();
9982 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
9983
9984 wxPyEndAllowThreads(__tstate);
9985 if (PyErr_Occurred()) SWIG_fail;
9986 }
9987 {
9988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9989 }
9990 {
9991 if (temp2)
9992 delete arg2;
9993 }
9994 return resultobj;
9995 fail:
9996 {
9997 if (temp2)
9998 delete arg2;
9999 }
10000 return NULL;
10001 }
10002
10003
10004 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10005 PyObject *resultobj;
10006 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10007 wxString *arg2 = 0 ;
10008 bool temp2 = false ;
10009 PyObject * obj0 = 0 ;
10010 PyObject * obj1 = 0 ;
10011 char *kwnames[] = {
10012 (char *) "self",(char *) "name", NULL
10013 };
10014
10015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10017 if (SWIG_arg_fail(1)) SWIG_fail;
10018 {
10019 arg2 = wxString_in_helper(obj1);
10020 if (arg2 == NULL) SWIG_fail;
10021 temp2 = true;
10022 }
10023 {
10024 PyThreadState* __tstate = wxPyBeginAllowThreads();
10025 (arg1)->SetName((wxString const &)*arg2);
10026
10027 wxPyEndAllowThreads(__tstate);
10028 if (PyErr_Occurred()) SWIG_fail;
10029 }
10030 Py_INCREF(Py_None); resultobj = Py_None;
10031 {
10032 if (temp2)
10033 delete arg2;
10034 }
10035 return resultobj;
10036 fail:
10037 {
10038 if (temp2)
10039 delete arg2;
10040 }
10041 return NULL;
10042 }
10043
10044
10045 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10046 PyObject *resultobj;
10047 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10048 wxString *arg2 = 0 ;
10049 bool temp2 = false ;
10050 PyObject * obj0 = 0 ;
10051 PyObject * obj1 = 0 ;
10052 char *kwnames[] = {
10053 (char *) "self",(char *) "extension", NULL
10054 };
10055
10056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10058 if (SWIG_arg_fail(1)) SWIG_fail;
10059 {
10060 arg2 = wxString_in_helper(obj1);
10061 if (arg2 == NULL) SWIG_fail;
10062 temp2 = true;
10063 }
10064 {
10065 PyThreadState* __tstate = wxPyBeginAllowThreads();
10066 (arg1)->SetExtension((wxString const &)*arg2);
10067
10068 wxPyEndAllowThreads(__tstate);
10069 if (PyErr_Occurred()) SWIG_fail;
10070 }
10071 Py_INCREF(Py_None); resultobj = Py_None;
10072 {
10073 if (temp2)
10074 delete arg2;
10075 }
10076 return resultobj;
10077 fail:
10078 {
10079 if (temp2)
10080 delete arg2;
10081 }
10082 return NULL;
10083 }
10084
10085
10086 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10087 PyObject *resultobj;
10088 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10089 long arg2 ;
10090 PyObject * obj0 = 0 ;
10091 PyObject * obj1 = 0 ;
10092 char *kwnames[] = {
10093 (char *) "self",(char *) "type", NULL
10094 };
10095
10096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10098 if (SWIG_arg_fail(1)) SWIG_fail;
10099 {
10100 arg2 = (long)(SWIG_As_long(obj1));
10101 if (SWIG_arg_fail(2)) SWIG_fail;
10102 }
10103 {
10104 PyThreadState* __tstate = wxPyBeginAllowThreads();
10105 (arg1)->SetType(arg2);
10106
10107 wxPyEndAllowThreads(__tstate);
10108 if (PyErr_Occurred()) SWIG_fail;
10109 }
10110 Py_INCREF(Py_None); resultobj = Py_None;
10111 return resultobj;
10112 fail:
10113 return NULL;
10114 }
10115
10116
10117 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10118 PyObject *resultobj;
10119 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10120 wxString *arg2 = 0 ;
10121 bool temp2 = false ;
10122 PyObject * obj0 = 0 ;
10123 PyObject * obj1 = 0 ;
10124 char *kwnames[] = {
10125 (char *) "self",(char *) "mimetype", NULL
10126 };
10127
10128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10130 if (SWIG_arg_fail(1)) SWIG_fail;
10131 {
10132 arg2 = wxString_in_helper(obj1);
10133 if (arg2 == NULL) SWIG_fail;
10134 temp2 = true;
10135 }
10136 {
10137 PyThreadState* __tstate = wxPyBeginAllowThreads();
10138 (arg1)->SetMimeType((wxString const &)*arg2);
10139
10140 wxPyEndAllowThreads(__tstate);
10141 if (PyErr_Occurred()) SWIG_fail;
10142 }
10143 Py_INCREF(Py_None); resultobj = Py_None;
10144 {
10145 if (temp2)
10146 delete arg2;
10147 }
10148 return resultobj;
10149 fail:
10150 {
10151 if (temp2)
10152 delete arg2;
10153 }
10154 return NULL;
10155 }
10156
10157
10158 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10159 PyObject *obj;
10160 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10161 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10162 Py_INCREF(obj);
10163 return Py_BuildValue((char *)"");
10164 }
10165 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10166 PyObject *resultobj;
10167 wxImageHistogram *result;
10168 char *kwnames[] = {
10169 NULL
10170 };
10171
10172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10173 {
10174 PyThreadState* __tstate = wxPyBeginAllowThreads();
10175 result = (wxImageHistogram *)new wxImageHistogram();
10176
10177 wxPyEndAllowThreads(__tstate);
10178 if (PyErr_Occurred()) SWIG_fail;
10179 }
10180 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10181 return resultobj;
10182 fail:
10183 return NULL;
10184 }
10185
10186
10187 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10188 PyObject *resultobj;
10189 unsigned char arg1 ;
10190 unsigned char arg2 ;
10191 unsigned char arg3 ;
10192 unsigned long result;
10193 PyObject * obj0 = 0 ;
10194 PyObject * obj1 = 0 ;
10195 PyObject * obj2 = 0 ;
10196 char *kwnames[] = {
10197 (char *) "r",(char *) "g",(char *) "b", NULL
10198 };
10199
10200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10201 {
10202 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10203 if (SWIG_arg_fail(1)) SWIG_fail;
10204 }
10205 {
10206 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10207 if (SWIG_arg_fail(2)) SWIG_fail;
10208 }
10209 {
10210 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10211 if (SWIG_arg_fail(3)) SWIG_fail;
10212 }
10213 {
10214 PyThreadState* __tstate = wxPyBeginAllowThreads();
10215 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10216
10217 wxPyEndAllowThreads(__tstate);
10218 if (PyErr_Occurred()) SWIG_fail;
10219 }
10220 {
10221 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10222 }
10223 return resultobj;
10224 fail:
10225 return NULL;
10226 }
10227
10228
10229 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10230 PyObject *resultobj;
10231 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10232 unsigned char *arg2 = (unsigned char *) 0 ;
10233 unsigned char *arg3 = (unsigned char *) 0 ;
10234 unsigned char *arg4 = (unsigned char *) 0 ;
10235 unsigned char arg5 = (unsigned char) 1 ;
10236 unsigned char arg6 = (unsigned char) 0 ;
10237 unsigned char arg7 = (unsigned char) 0 ;
10238 bool result;
10239 unsigned char temp2 ;
10240 int res2 = 0 ;
10241 unsigned char temp3 ;
10242 int res3 = 0 ;
10243 unsigned char temp4 ;
10244 int res4 = 0 ;
10245 PyObject * obj0 = 0 ;
10246 PyObject * obj1 = 0 ;
10247 PyObject * obj2 = 0 ;
10248 PyObject * obj3 = 0 ;
10249 char *kwnames[] = {
10250 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10251 };
10252
10253 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10254 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10255 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10258 if (SWIG_arg_fail(1)) SWIG_fail;
10259 if (obj1) {
10260 {
10261 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10262 if (SWIG_arg_fail(5)) SWIG_fail;
10263 }
10264 }
10265 if (obj2) {
10266 {
10267 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10268 if (SWIG_arg_fail(6)) SWIG_fail;
10269 }
10270 }
10271 if (obj3) {
10272 {
10273 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10274 if (SWIG_arg_fail(7)) SWIG_fail;
10275 }
10276 }
10277 {
10278 PyThreadState* __tstate = wxPyBeginAllowThreads();
10279 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10280
10281 wxPyEndAllowThreads(__tstate);
10282 if (PyErr_Occurred()) SWIG_fail;
10283 }
10284 {
10285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10286 }
10287 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10288 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10289 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10290 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10291 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10292 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10293 return resultobj;
10294 fail:
10295 return NULL;
10296 }
10297
10298
10299 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10300 PyObject *obj;
10301 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10302 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10303 Py_INCREF(obj);
10304 return Py_BuildValue((char *)"");
10305 }
10306 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10307 PyObject *resultobj;
10308 wxString *arg1 = 0 ;
10309 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10310 int arg3 = (int) -1 ;
10311 wxImage *result;
10312 bool temp1 = false ;
10313 PyObject * obj0 = 0 ;
10314 PyObject * obj1 = 0 ;
10315 PyObject * obj2 = 0 ;
10316 char *kwnames[] = {
10317 (char *) "name",(char *) "type",(char *) "index", NULL
10318 };
10319
10320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10321 {
10322 arg1 = wxString_in_helper(obj0);
10323 if (arg1 == NULL) SWIG_fail;
10324 temp1 = true;
10325 }
10326 if (obj1) {
10327 {
10328 arg2 = (long)(SWIG_As_long(obj1));
10329 if (SWIG_arg_fail(2)) SWIG_fail;
10330 }
10331 }
10332 if (obj2) {
10333 {
10334 arg3 = (int)(SWIG_As_int(obj2));
10335 if (SWIG_arg_fail(3)) SWIG_fail;
10336 }
10337 }
10338 {
10339 PyThreadState* __tstate = wxPyBeginAllowThreads();
10340 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10341
10342 wxPyEndAllowThreads(__tstate);
10343 if (PyErr_Occurred()) SWIG_fail;
10344 }
10345 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10346 {
10347 if (temp1)
10348 delete arg1;
10349 }
10350 return resultobj;
10351 fail:
10352 {
10353 if (temp1)
10354 delete arg1;
10355 }
10356 return NULL;
10357 }
10358
10359
10360 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10361 PyObject *resultobj;
10362 wxImage *arg1 = (wxImage *) 0 ;
10363 PyObject * obj0 = 0 ;
10364 char *kwnames[] = {
10365 (char *) "self", NULL
10366 };
10367
10368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10370 if (SWIG_arg_fail(1)) SWIG_fail;
10371 {
10372 PyThreadState* __tstate = wxPyBeginAllowThreads();
10373 delete arg1;
10374
10375 wxPyEndAllowThreads(__tstate);
10376 if (PyErr_Occurred()) SWIG_fail;
10377 }
10378 Py_INCREF(Py_None); resultobj = Py_None;
10379 return resultobj;
10380 fail:
10381 return NULL;
10382 }
10383
10384
10385 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10386 PyObject *resultobj;
10387 wxString *arg1 = 0 ;
10388 wxString *arg2 = 0 ;
10389 int arg3 = (int) -1 ;
10390 wxImage *result;
10391 bool temp1 = false ;
10392 bool temp2 = false ;
10393 PyObject * obj0 = 0 ;
10394 PyObject * obj1 = 0 ;
10395 PyObject * obj2 = 0 ;
10396 char *kwnames[] = {
10397 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10398 };
10399
10400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10401 {
10402 arg1 = wxString_in_helper(obj0);
10403 if (arg1 == NULL) SWIG_fail;
10404 temp1 = true;
10405 }
10406 {
10407 arg2 = wxString_in_helper(obj1);
10408 if (arg2 == NULL) SWIG_fail;
10409 temp2 = true;
10410 }
10411 if (obj2) {
10412 {
10413 arg3 = (int)(SWIG_As_int(obj2));
10414 if (SWIG_arg_fail(3)) SWIG_fail;
10415 }
10416 }
10417 {
10418 PyThreadState* __tstate = wxPyBeginAllowThreads();
10419 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10420
10421 wxPyEndAllowThreads(__tstate);
10422 if (PyErr_Occurred()) SWIG_fail;
10423 }
10424 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10425 {
10426 if (temp1)
10427 delete arg1;
10428 }
10429 {
10430 if (temp2)
10431 delete arg2;
10432 }
10433 return resultobj;
10434 fail:
10435 {
10436 if (temp1)
10437 delete arg1;
10438 }
10439 {
10440 if (temp2)
10441 delete arg2;
10442 }
10443 return NULL;
10444 }
10445
10446
10447 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10448 PyObject *resultobj;
10449 wxInputStream *arg1 = 0 ;
10450 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10451 int arg3 = (int) -1 ;
10452 wxImage *result;
10453 wxPyInputStream *temp1 ;
10454 bool created1 ;
10455 PyObject * obj0 = 0 ;
10456 PyObject * obj1 = 0 ;
10457 PyObject * obj2 = 0 ;
10458 char *kwnames[] = {
10459 (char *) "stream",(char *) "type",(char *) "index", NULL
10460 };
10461
10462 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10463 {
10464 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10465 arg1 = temp1->m_wxis;
10466 created1 = false;
10467 } else {
10468 PyErr_Clear(); // clear the failure of the wxPyConvert above
10469 arg1 = wxPyCBInputStream_create(obj0, false);
10470 if (arg1 == NULL) {
10471 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10472 SWIG_fail;
10473 }
10474 created1 = true;
10475 }
10476 }
10477 if (obj1) {
10478 {
10479 arg2 = (long)(SWIG_As_long(obj1));
10480 if (SWIG_arg_fail(2)) SWIG_fail;
10481 }
10482 }
10483 if (obj2) {
10484 {
10485 arg3 = (int)(SWIG_As_int(obj2));
10486 if (SWIG_arg_fail(3)) SWIG_fail;
10487 }
10488 }
10489 {
10490 PyThreadState* __tstate = wxPyBeginAllowThreads();
10491 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10492
10493 wxPyEndAllowThreads(__tstate);
10494 if (PyErr_Occurred()) SWIG_fail;
10495 }
10496 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10497 {
10498 if (created1)
10499 delete arg1;
10500 }
10501 return resultobj;
10502 fail:
10503 {
10504 if (created1)
10505 delete arg1;
10506 }
10507 return NULL;
10508 }
10509
10510
10511 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10512 PyObject *resultobj;
10513 wxInputStream *arg1 = 0 ;
10514 wxString *arg2 = 0 ;
10515 int arg3 = (int) -1 ;
10516 wxImage *result;
10517 wxPyInputStream *temp1 ;
10518 bool created1 ;
10519 bool temp2 = false ;
10520 PyObject * obj0 = 0 ;
10521 PyObject * obj1 = 0 ;
10522 PyObject * obj2 = 0 ;
10523 char *kwnames[] = {
10524 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10525 };
10526
10527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10528 {
10529 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10530 arg1 = temp1->m_wxis;
10531 created1 = false;
10532 } else {
10533 PyErr_Clear(); // clear the failure of the wxPyConvert above
10534 arg1 = wxPyCBInputStream_create(obj0, false);
10535 if (arg1 == NULL) {
10536 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
10537 SWIG_fail;
10538 }
10539 created1 = true;
10540 }
10541 }
10542 {
10543 arg2 = wxString_in_helper(obj1);
10544 if (arg2 == NULL) SWIG_fail;
10545 temp2 = true;
10546 }
10547 if (obj2) {
10548 {
10549 arg3 = (int)(SWIG_As_int(obj2));
10550 if (SWIG_arg_fail(3)) SWIG_fail;
10551 }
10552 }
10553 {
10554 PyThreadState* __tstate = wxPyBeginAllowThreads();
10555 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10556
10557 wxPyEndAllowThreads(__tstate);
10558 if (PyErr_Occurred()) SWIG_fail;
10559 }
10560 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10561 {
10562 if (created1)
10563 delete arg1;
10564 }
10565 {
10566 if (temp2)
10567 delete arg2;
10568 }
10569 return resultobj;
10570 fail:
10571 {
10572 if (created1)
10573 delete arg1;
10574 }
10575 {
10576 if (temp2)
10577 delete arg2;
10578 }
10579 return NULL;
10580 }
10581
10582
10583 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10584 PyObject *resultobj;
10585 int arg1 = (int) 0 ;
10586 int arg2 = (int) 0 ;
10587 bool arg3 = (bool) true ;
10588 wxImage *result;
10589 PyObject * obj0 = 0 ;
10590 PyObject * obj1 = 0 ;
10591 PyObject * obj2 = 0 ;
10592 char *kwnames[] = {
10593 (char *) "width",(char *) "height",(char *) "clear", NULL
10594 };
10595
10596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10597 if (obj0) {
10598 {
10599 arg1 = (int)(SWIG_As_int(obj0));
10600 if (SWIG_arg_fail(1)) SWIG_fail;
10601 }
10602 }
10603 if (obj1) {
10604 {
10605 arg2 = (int)(SWIG_As_int(obj1));
10606 if (SWIG_arg_fail(2)) SWIG_fail;
10607 }
10608 }
10609 if (obj2) {
10610 {
10611 arg3 = (bool)(SWIG_As_bool(obj2));
10612 if (SWIG_arg_fail(3)) SWIG_fail;
10613 }
10614 }
10615 {
10616 PyThreadState* __tstate = wxPyBeginAllowThreads();
10617 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10618
10619 wxPyEndAllowThreads(__tstate);
10620 if (PyErr_Occurred()) SWIG_fail;
10621 }
10622 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10623 return resultobj;
10624 fail:
10625 return NULL;
10626 }
10627
10628
10629 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10630 PyObject *resultobj;
10631 wxBitmap *arg1 = 0 ;
10632 wxImage *result;
10633 PyObject * obj0 = 0 ;
10634 char *kwnames[] = {
10635 (char *) "bitmap", NULL
10636 };
10637
10638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10639 {
10640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10641 if (SWIG_arg_fail(1)) SWIG_fail;
10642 if (arg1 == NULL) {
10643 SWIG_null_ref("wxBitmap");
10644 }
10645 if (SWIG_arg_fail(1)) SWIG_fail;
10646 }
10647 {
10648 if (!wxPyCheckForApp()) SWIG_fail;
10649 PyThreadState* __tstate = wxPyBeginAllowThreads();
10650 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10651
10652 wxPyEndAllowThreads(__tstate);
10653 if (PyErr_Occurred()) SWIG_fail;
10654 }
10655 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10656 return resultobj;
10657 fail:
10658 return NULL;
10659 }
10660
10661
10662 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10663 PyObject *resultobj;
10664 int arg1 ;
10665 int arg2 ;
10666 unsigned char *arg3 = (unsigned char *) 0 ;
10667 wxImage *result;
10668 PyObject * obj0 = 0 ;
10669 PyObject * obj1 = 0 ;
10670 PyObject * obj2 = 0 ;
10671 char *kwnames[] = {
10672 (char *) "width",(char *) "height",(char *) "data", NULL
10673 };
10674
10675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10676 {
10677 arg1 = (int)(SWIG_As_int(obj0));
10678 if (SWIG_arg_fail(1)) SWIG_fail;
10679 }
10680 {
10681 arg2 = (int)(SWIG_As_int(obj1));
10682 if (SWIG_arg_fail(2)) SWIG_fail;
10683 }
10684 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10685 if (SWIG_arg_fail(3)) SWIG_fail;
10686 {
10687 PyThreadState* __tstate = wxPyBeginAllowThreads();
10688 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10689
10690 wxPyEndAllowThreads(__tstate);
10691 if (PyErr_Occurred()) SWIG_fail;
10692 }
10693 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10694 return resultobj;
10695 fail:
10696 return NULL;
10697 }
10698
10699
10700 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10701 PyObject *resultobj;
10702 int arg1 ;
10703 int arg2 ;
10704 unsigned char *arg3 = (unsigned char *) 0 ;
10705 unsigned char *arg4 = (unsigned char *) 0 ;
10706 wxImage *result;
10707 PyObject * obj0 = 0 ;
10708 PyObject * obj1 = 0 ;
10709 PyObject * obj2 = 0 ;
10710 PyObject * obj3 = 0 ;
10711 char *kwnames[] = {
10712 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10713 };
10714
10715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10716 {
10717 arg1 = (int)(SWIG_As_int(obj0));
10718 if (SWIG_arg_fail(1)) SWIG_fail;
10719 }
10720 {
10721 arg2 = (int)(SWIG_As_int(obj1));
10722 if (SWIG_arg_fail(2)) SWIG_fail;
10723 }
10724 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10725 if (SWIG_arg_fail(3)) SWIG_fail;
10726 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_unsigned_char, SWIG_POINTER_EXCEPTION | 0);
10727 if (SWIG_arg_fail(4)) SWIG_fail;
10728 {
10729 PyThreadState* __tstate = wxPyBeginAllowThreads();
10730 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10731
10732 wxPyEndAllowThreads(__tstate);
10733 if (PyErr_Occurred()) SWIG_fail;
10734 }
10735 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10736 return resultobj;
10737 fail:
10738 return NULL;
10739 }
10740
10741
10742 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10743 PyObject *resultobj;
10744 wxImage *arg1 = (wxImage *) 0 ;
10745 int arg2 ;
10746 int arg3 ;
10747 PyObject * obj0 = 0 ;
10748 PyObject * obj1 = 0 ;
10749 PyObject * obj2 = 0 ;
10750 char *kwnames[] = {
10751 (char *) "self",(char *) "width",(char *) "height", NULL
10752 };
10753
10754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10756 if (SWIG_arg_fail(1)) SWIG_fail;
10757 {
10758 arg2 = (int)(SWIG_As_int(obj1));
10759 if (SWIG_arg_fail(2)) SWIG_fail;
10760 }
10761 {
10762 arg3 = (int)(SWIG_As_int(obj2));
10763 if (SWIG_arg_fail(3)) SWIG_fail;
10764 }
10765 {
10766 PyThreadState* __tstate = wxPyBeginAllowThreads();
10767 (arg1)->Create(arg2,arg3);
10768
10769 wxPyEndAllowThreads(__tstate);
10770 if (PyErr_Occurred()) SWIG_fail;
10771 }
10772 Py_INCREF(Py_None); resultobj = Py_None;
10773 return resultobj;
10774 fail:
10775 return NULL;
10776 }
10777
10778
10779 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10780 PyObject *resultobj;
10781 wxImage *arg1 = (wxImage *) 0 ;
10782 PyObject * obj0 = 0 ;
10783 char *kwnames[] = {
10784 (char *) "self", NULL
10785 };
10786
10787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10789 if (SWIG_arg_fail(1)) SWIG_fail;
10790 {
10791 PyThreadState* __tstate = wxPyBeginAllowThreads();
10792 (arg1)->Destroy();
10793
10794 wxPyEndAllowThreads(__tstate);
10795 if (PyErr_Occurred()) SWIG_fail;
10796 }
10797 Py_INCREF(Py_None); resultobj = Py_None;
10798 return resultobj;
10799 fail:
10800 return NULL;
10801 }
10802
10803
10804 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10805 PyObject *resultobj;
10806 wxImage *arg1 = (wxImage *) 0 ;
10807 int arg2 ;
10808 int arg3 ;
10809 SwigValueWrapper<wxImage > result;
10810 PyObject * obj0 = 0 ;
10811 PyObject * obj1 = 0 ;
10812 PyObject * obj2 = 0 ;
10813 char *kwnames[] = {
10814 (char *) "self",(char *) "width",(char *) "height", NULL
10815 };
10816
10817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10819 if (SWIG_arg_fail(1)) SWIG_fail;
10820 {
10821 arg2 = (int)(SWIG_As_int(obj1));
10822 if (SWIG_arg_fail(2)) SWIG_fail;
10823 }
10824 {
10825 arg3 = (int)(SWIG_As_int(obj2));
10826 if (SWIG_arg_fail(3)) SWIG_fail;
10827 }
10828 {
10829 PyThreadState* __tstate = wxPyBeginAllowThreads();
10830 result = (arg1)->Scale(arg2,arg3);
10831
10832 wxPyEndAllowThreads(__tstate);
10833 if (PyErr_Occurred()) SWIG_fail;
10834 }
10835 {
10836 wxImage * resultptr;
10837 resultptr = new wxImage((wxImage &)(result));
10838 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10839 }
10840 return resultobj;
10841 fail:
10842 return NULL;
10843 }
10844
10845
10846 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
10847 PyObject *resultobj;
10848 wxImage *arg1 = (wxImage *) 0 ;
10849 int arg2 ;
10850 int arg3 ;
10851 SwigValueWrapper<wxImage > result;
10852 PyObject * obj0 = 0 ;
10853 PyObject * obj1 = 0 ;
10854 PyObject * obj2 = 0 ;
10855 char *kwnames[] = {
10856 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
10857 };
10858
10859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
10860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10861 if (SWIG_arg_fail(1)) SWIG_fail;
10862 {
10863 arg2 = (int)(SWIG_As_int(obj1));
10864 if (SWIG_arg_fail(2)) SWIG_fail;
10865 }
10866 {
10867 arg3 = (int)(SWIG_As_int(obj2));
10868 if (SWIG_arg_fail(3)) SWIG_fail;
10869 }
10870 {
10871 PyThreadState* __tstate = wxPyBeginAllowThreads();
10872 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
10873
10874 wxPyEndAllowThreads(__tstate);
10875 if (PyErr_Occurred()) SWIG_fail;
10876 }
10877 {
10878 wxImage * resultptr;
10879 resultptr = new wxImage((wxImage &)(result));
10880 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
10881 }
10882 return resultobj;
10883 fail:
10884 return NULL;
10885 }
10886
10887
10888 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
10889 PyObject *resultobj;
10890 wxImage *arg1 = (wxImage *) 0 ;
10891 int arg2 ;
10892 int arg3 ;
10893 wxImage *result;
10894 PyObject * obj0 = 0 ;
10895 PyObject * obj1 = 0 ;
10896 PyObject * obj2 = 0 ;
10897 char *kwnames[] = {
10898 (char *) "self",(char *) "width",(char *) "height", NULL
10899 };
10900
10901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10903 if (SWIG_arg_fail(1)) SWIG_fail;
10904 {
10905 arg2 = (int)(SWIG_As_int(obj1));
10906 if (SWIG_arg_fail(2)) SWIG_fail;
10907 }
10908 {
10909 arg3 = (int)(SWIG_As_int(obj2));
10910 if (SWIG_arg_fail(3)) SWIG_fail;
10911 }
10912 {
10913 PyThreadState* __tstate = wxPyBeginAllowThreads();
10914 {
10915 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
10916 result = (wxImage *) &_result_ref;
10917 }
10918
10919 wxPyEndAllowThreads(__tstate);
10920 if (PyErr_Occurred()) SWIG_fail;
10921 }
10922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
10923 return resultobj;
10924 fail:
10925 return NULL;
10926 }
10927
10928
10929 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10930 PyObject *resultobj;
10931 wxImage *arg1 = (wxImage *) 0 ;
10932 int arg2 ;
10933 int arg3 ;
10934 unsigned char arg4 ;
10935 unsigned char arg5 ;
10936 unsigned char arg6 ;
10937 PyObject * obj0 = 0 ;
10938 PyObject * obj1 = 0 ;
10939 PyObject * obj2 = 0 ;
10940 PyObject * obj3 = 0 ;
10941 PyObject * obj4 = 0 ;
10942 PyObject * obj5 = 0 ;
10943 char *kwnames[] = {
10944 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
10945 };
10946
10947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
10948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10949 if (SWIG_arg_fail(1)) SWIG_fail;
10950 {
10951 arg2 = (int)(SWIG_As_int(obj1));
10952 if (SWIG_arg_fail(2)) SWIG_fail;
10953 }
10954 {
10955 arg3 = (int)(SWIG_As_int(obj2));
10956 if (SWIG_arg_fail(3)) SWIG_fail;
10957 }
10958 {
10959 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10960 if (SWIG_arg_fail(4)) SWIG_fail;
10961 }
10962 {
10963 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
10964 if (SWIG_arg_fail(5)) SWIG_fail;
10965 }
10966 {
10967 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
10968 if (SWIG_arg_fail(6)) SWIG_fail;
10969 }
10970 {
10971 PyThreadState* __tstate = wxPyBeginAllowThreads();
10972 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
10973
10974 wxPyEndAllowThreads(__tstate);
10975 if (PyErr_Occurred()) SWIG_fail;
10976 }
10977 Py_INCREF(Py_None); resultobj = Py_None;
10978 return resultobj;
10979 fail:
10980 return NULL;
10981 }
10982
10983
10984 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
10985 PyObject *resultobj;
10986 wxImage *arg1 = (wxImage *) 0 ;
10987 int arg2 ;
10988 int arg3 ;
10989 unsigned char result;
10990 PyObject * obj0 = 0 ;
10991 PyObject * obj1 = 0 ;
10992 PyObject * obj2 = 0 ;
10993 char *kwnames[] = {
10994 (char *) "self",(char *) "x",(char *) "y", NULL
10995 };
10996
10997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
10998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10999 if (SWIG_arg_fail(1)) SWIG_fail;
11000 {
11001 arg2 = (int)(SWIG_As_int(obj1));
11002 if (SWIG_arg_fail(2)) SWIG_fail;
11003 }
11004 {
11005 arg3 = (int)(SWIG_As_int(obj2));
11006 if (SWIG_arg_fail(3)) SWIG_fail;
11007 }
11008 {
11009 PyThreadState* __tstate = wxPyBeginAllowThreads();
11010 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11011
11012 wxPyEndAllowThreads(__tstate);
11013 if (PyErr_Occurred()) SWIG_fail;
11014 }
11015 {
11016 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11017 }
11018 return resultobj;
11019 fail:
11020 return NULL;
11021 }
11022
11023
11024 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11025 PyObject *resultobj;
11026 wxImage *arg1 = (wxImage *) 0 ;
11027 int arg2 ;
11028 int arg3 ;
11029 unsigned char result;
11030 PyObject * obj0 = 0 ;
11031 PyObject * obj1 = 0 ;
11032 PyObject * obj2 = 0 ;
11033 char *kwnames[] = {
11034 (char *) "self",(char *) "x",(char *) "y", NULL
11035 };
11036
11037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11039 if (SWIG_arg_fail(1)) SWIG_fail;
11040 {
11041 arg2 = (int)(SWIG_As_int(obj1));
11042 if (SWIG_arg_fail(2)) SWIG_fail;
11043 }
11044 {
11045 arg3 = (int)(SWIG_As_int(obj2));
11046 if (SWIG_arg_fail(3)) SWIG_fail;
11047 }
11048 {
11049 PyThreadState* __tstate = wxPyBeginAllowThreads();
11050 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11051
11052 wxPyEndAllowThreads(__tstate);
11053 if (PyErr_Occurred()) SWIG_fail;
11054 }
11055 {
11056 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11057 }
11058 return resultobj;
11059 fail:
11060 return NULL;
11061 }
11062
11063
11064 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11065 PyObject *resultobj;
11066 wxImage *arg1 = (wxImage *) 0 ;
11067 int arg2 ;
11068 int arg3 ;
11069 unsigned char result;
11070 PyObject * obj0 = 0 ;
11071 PyObject * obj1 = 0 ;
11072 PyObject * obj2 = 0 ;
11073 char *kwnames[] = {
11074 (char *) "self",(char *) "x",(char *) "y", NULL
11075 };
11076
11077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11079 if (SWIG_arg_fail(1)) SWIG_fail;
11080 {
11081 arg2 = (int)(SWIG_As_int(obj1));
11082 if (SWIG_arg_fail(2)) SWIG_fail;
11083 }
11084 {
11085 arg3 = (int)(SWIG_As_int(obj2));
11086 if (SWIG_arg_fail(3)) SWIG_fail;
11087 }
11088 {
11089 PyThreadState* __tstate = wxPyBeginAllowThreads();
11090 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11091
11092 wxPyEndAllowThreads(__tstate);
11093 if (PyErr_Occurred()) SWIG_fail;
11094 }
11095 {
11096 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11097 }
11098 return resultobj;
11099 fail:
11100 return NULL;
11101 }
11102
11103
11104 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11105 PyObject *resultobj;
11106 wxImage *arg1 = (wxImage *) 0 ;
11107 int arg2 ;
11108 int arg3 ;
11109 unsigned char arg4 ;
11110 PyObject * obj0 = 0 ;
11111 PyObject * obj1 = 0 ;
11112 PyObject * obj2 = 0 ;
11113 PyObject * obj3 = 0 ;
11114 char *kwnames[] = {
11115 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11116 };
11117
11118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11120 if (SWIG_arg_fail(1)) SWIG_fail;
11121 {
11122 arg2 = (int)(SWIG_As_int(obj1));
11123 if (SWIG_arg_fail(2)) SWIG_fail;
11124 }
11125 {
11126 arg3 = (int)(SWIG_As_int(obj2));
11127 if (SWIG_arg_fail(3)) SWIG_fail;
11128 }
11129 {
11130 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11131 if (SWIG_arg_fail(4)) SWIG_fail;
11132 }
11133 {
11134 PyThreadState* __tstate = wxPyBeginAllowThreads();
11135 (arg1)->SetAlpha(arg2,arg3,arg4);
11136
11137 wxPyEndAllowThreads(__tstate);
11138 if (PyErr_Occurred()) SWIG_fail;
11139 }
11140 Py_INCREF(Py_None); resultobj = Py_None;
11141 return resultobj;
11142 fail:
11143 return NULL;
11144 }
11145
11146
11147 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11148 PyObject *resultobj;
11149 wxImage *arg1 = (wxImage *) 0 ;
11150 int arg2 ;
11151 int arg3 ;
11152 unsigned char result;
11153 PyObject * obj0 = 0 ;
11154 PyObject * obj1 = 0 ;
11155 PyObject * obj2 = 0 ;
11156 char *kwnames[] = {
11157 (char *) "self",(char *) "x",(char *) "y", NULL
11158 };
11159
11160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11162 if (SWIG_arg_fail(1)) SWIG_fail;
11163 {
11164 arg2 = (int)(SWIG_As_int(obj1));
11165 if (SWIG_arg_fail(2)) SWIG_fail;
11166 }
11167 {
11168 arg3 = (int)(SWIG_As_int(obj2));
11169 if (SWIG_arg_fail(3)) SWIG_fail;
11170 }
11171 {
11172 PyThreadState* __tstate = wxPyBeginAllowThreads();
11173 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11174
11175 wxPyEndAllowThreads(__tstate);
11176 if (PyErr_Occurred()) SWIG_fail;
11177 }
11178 {
11179 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11180 }
11181 return resultobj;
11182 fail:
11183 return NULL;
11184 }
11185
11186
11187 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11188 PyObject *resultobj;
11189 wxImage *arg1 = (wxImage *) 0 ;
11190 bool result;
11191 PyObject * obj0 = 0 ;
11192 char *kwnames[] = {
11193 (char *) "self", NULL
11194 };
11195
11196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11198 if (SWIG_arg_fail(1)) SWIG_fail;
11199 {
11200 PyThreadState* __tstate = wxPyBeginAllowThreads();
11201 result = (bool)(arg1)->HasAlpha();
11202
11203 wxPyEndAllowThreads(__tstate);
11204 if (PyErr_Occurred()) SWIG_fail;
11205 }
11206 {
11207 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11208 }
11209 return resultobj;
11210 fail:
11211 return NULL;
11212 }
11213
11214
11215 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11216 PyObject *resultobj;
11217 wxImage *arg1 = (wxImage *) 0 ;
11218 byte *arg2 = (byte *) 0 ;
11219 byte *arg3 = (byte *) 0 ;
11220 byte *arg4 = (byte *) 0 ;
11221 byte arg5 = (byte) 0 ;
11222 byte arg6 = (byte) 0 ;
11223 byte arg7 = (byte) 0 ;
11224 bool result;
11225 byte temp2 ;
11226 int res2 = 0 ;
11227 byte temp3 ;
11228 int res3 = 0 ;
11229 byte temp4 ;
11230 int res4 = 0 ;
11231 PyObject * obj0 = 0 ;
11232 PyObject * obj1 = 0 ;
11233 PyObject * obj2 = 0 ;
11234 PyObject * obj3 = 0 ;
11235 char *kwnames[] = {
11236 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11237 };
11238
11239 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11240 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11241 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11244 if (SWIG_arg_fail(1)) SWIG_fail;
11245 if (obj1) {
11246 {
11247 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11248 if (SWIG_arg_fail(5)) SWIG_fail;
11249 }
11250 }
11251 if (obj2) {
11252 {
11253 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11254 if (SWIG_arg_fail(6)) SWIG_fail;
11255 }
11256 }
11257 if (obj3) {
11258 {
11259 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11260 if (SWIG_arg_fail(7)) SWIG_fail;
11261 }
11262 }
11263 {
11264 PyThreadState* __tstate = wxPyBeginAllowThreads();
11265 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11266
11267 wxPyEndAllowThreads(__tstate);
11268 if (PyErr_Occurred()) SWIG_fail;
11269 }
11270 {
11271 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11272 }
11273 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11274 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11275 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11276 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11277 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11278 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11279 return resultobj;
11280 fail:
11281 return NULL;
11282 }
11283
11284
11285 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11286 PyObject *resultobj;
11287 wxImage *arg1 = (wxImage *) 0 ;
11288 byte arg2 = (byte) 128 ;
11289 bool result;
11290 PyObject * obj0 = 0 ;
11291 PyObject * obj1 = 0 ;
11292 char *kwnames[] = {
11293 (char *) "self",(char *) "threshold", NULL
11294 };
11295
11296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11298 if (SWIG_arg_fail(1)) SWIG_fail;
11299 if (obj1) {
11300 {
11301 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11302 if (SWIG_arg_fail(2)) SWIG_fail;
11303 }
11304 }
11305 {
11306 PyThreadState* __tstate = wxPyBeginAllowThreads();
11307 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11308
11309 wxPyEndAllowThreads(__tstate);
11310 if (PyErr_Occurred()) SWIG_fail;
11311 }
11312 {
11313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11314 }
11315 return resultobj;
11316 fail:
11317 return NULL;
11318 }
11319
11320
11321 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11322 PyObject *resultobj;
11323 wxImage *arg1 = (wxImage *) 0 ;
11324 unsigned char arg2 ;
11325 unsigned char arg3 ;
11326 unsigned char arg4 ;
11327 bool result;
11328 PyObject * obj0 = 0 ;
11329 PyObject * obj1 = 0 ;
11330 PyObject * obj2 = 0 ;
11331 PyObject * obj3 = 0 ;
11332 char *kwnames[] = {
11333 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11334 };
11335
11336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11338 if (SWIG_arg_fail(1)) SWIG_fail;
11339 {
11340 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11341 if (SWIG_arg_fail(2)) SWIG_fail;
11342 }
11343 {
11344 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11345 if (SWIG_arg_fail(3)) SWIG_fail;
11346 }
11347 {
11348 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11349 if (SWIG_arg_fail(4)) SWIG_fail;
11350 }
11351 {
11352 PyThreadState* __tstate = wxPyBeginAllowThreads();
11353 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11354
11355 wxPyEndAllowThreads(__tstate);
11356 if (PyErr_Occurred()) SWIG_fail;
11357 }
11358 {
11359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11360 }
11361 return resultobj;
11362 fail:
11363 return NULL;
11364 }
11365
11366
11367 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11368 PyObject *resultobj;
11369 wxImage *arg1 = (wxImage *) 0 ;
11370 wxImage *arg2 = 0 ;
11371 byte arg3 ;
11372 byte arg4 ;
11373 byte arg5 ;
11374 bool result;
11375 PyObject * obj0 = 0 ;
11376 PyObject * obj1 = 0 ;
11377 PyObject * obj2 = 0 ;
11378 PyObject * obj3 = 0 ;
11379 PyObject * obj4 = 0 ;
11380 char *kwnames[] = {
11381 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11382 };
11383
11384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11386 if (SWIG_arg_fail(1)) SWIG_fail;
11387 {
11388 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11389 if (SWIG_arg_fail(2)) SWIG_fail;
11390 if (arg2 == NULL) {
11391 SWIG_null_ref("wxImage");
11392 }
11393 if (SWIG_arg_fail(2)) SWIG_fail;
11394 }
11395 {
11396 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11397 if (SWIG_arg_fail(3)) SWIG_fail;
11398 }
11399 {
11400 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11401 if (SWIG_arg_fail(4)) SWIG_fail;
11402 }
11403 {
11404 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11405 if (SWIG_arg_fail(5)) SWIG_fail;
11406 }
11407 {
11408 PyThreadState* __tstate = wxPyBeginAllowThreads();
11409 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11410
11411 wxPyEndAllowThreads(__tstate);
11412 if (PyErr_Occurred()) SWIG_fail;
11413 }
11414 {
11415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11416 }
11417 return resultobj;
11418 fail:
11419 return NULL;
11420 }
11421
11422
11423 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11424 PyObject *resultobj;
11425 wxString *arg1 = 0 ;
11426 bool result;
11427 bool temp1 = false ;
11428 PyObject * obj0 = 0 ;
11429 char *kwnames[] = {
11430 (char *) "name", NULL
11431 };
11432
11433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11434 {
11435 arg1 = wxString_in_helper(obj0);
11436 if (arg1 == NULL) SWIG_fail;
11437 temp1 = true;
11438 }
11439 {
11440 PyThreadState* __tstate = wxPyBeginAllowThreads();
11441 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11442
11443 wxPyEndAllowThreads(__tstate);
11444 if (PyErr_Occurred()) SWIG_fail;
11445 }
11446 {
11447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11448 }
11449 {
11450 if (temp1)
11451 delete arg1;
11452 }
11453 return resultobj;
11454 fail:
11455 {
11456 if (temp1)
11457 delete arg1;
11458 }
11459 return NULL;
11460 }
11461
11462
11463 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11464 PyObject *resultobj;
11465 wxString *arg1 = 0 ;
11466 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11467 int result;
11468 bool temp1 = false ;
11469 PyObject * obj0 = 0 ;
11470 PyObject * obj1 = 0 ;
11471 char *kwnames[] = {
11472 (char *) "name",(char *) "type", NULL
11473 };
11474
11475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11476 {
11477 arg1 = wxString_in_helper(obj0);
11478 if (arg1 == NULL) SWIG_fail;
11479 temp1 = true;
11480 }
11481 if (obj1) {
11482 {
11483 arg2 = (long)(SWIG_As_long(obj1));
11484 if (SWIG_arg_fail(2)) SWIG_fail;
11485 }
11486 }
11487 {
11488 PyThreadState* __tstate = wxPyBeginAllowThreads();
11489 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11490
11491 wxPyEndAllowThreads(__tstate);
11492 if (PyErr_Occurred()) SWIG_fail;
11493 }
11494 {
11495 resultobj = SWIG_From_int((int)(result));
11496 }
11497 {
11498 if (temp1)
11499 delete arg1;
11500 }
11501 return resultobj;
11502 fail:
11503 {
11504 if (temp1)
11505 delete arg1;
11506 }
11507 return NULL;
11508 }
11509
11510
11511 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11512 PyObject *resultobj;
11513 wxImage *arg1 = (wxImage *) 0 ;
11514 wxString *arg2 = 0 ;
11515 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11516 int arg4 = (int) -1 ;
11517 bool result;
11518 bool temp2 = false ;
11519 PyObject * obj0 = 0 ;
11520 PyObject * obj1 = 0 ;
11521 PyObject * obj2 = 0 ;
11522 PyObject * obj3 = 0 ;
11523 char *kwnames[] = {
11524 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11525 };
11526
11527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11529 if (SWIG_arg_fail(1)) SWIG_fail;
11530 {
11531 arg2 = wxString_in_helper(obj1);
11532 if (arg2 == NULL) SWIG_fail;
11533 temp2 = true;
11534 }
11535 if (obj2) {
11536 {
11537 arg3 = (long)(SWIG_As_long(obj2));
11538 if (SWIG_arg_fail(3)) SWIG_fail;
11539 }
11540 }
11541 if (obj3) {
11542 {
11543 arg4 = (int)(SWIG_As_int(obj3));
11544 if (SWIG_arg_fail(4)) SWIG_fail;
11545 }
11546 }
11547 {
11548 PyThreadState* __tstate = wxPyBeginAllowThreads();
11549 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11550
11551 wxPyEndAllowThreads(__tstate);
11552 if (PyErr_Occurred()) SWIG_fail;
11553 }
11554 {
11555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11556 }
11557 {
11558 if (temp2)
11559 delete arg2;
11560 }
11561 return resultobj;
11562 fail:
11563 {
11564 if (temp2)
11565 delete arg2;
11566 }
11567 return NULL;
11568 }
11569
11570
11571 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11572 PyObject *resultobj;
11573 wxImage *arg1 = (wxImage *) 0 ;
11574 wxString *arg2 = 0 ;
11575 wxString *arg3 = 0 ;
11576 int arg4 = (int) -1 ;
11577 bool result;
11578 bool temp2 = false ;
11579 bool temp3 = false ;
11580 PyObject * obj0 = 0 ;
11581 PyObject * obj1 = 0 ;
11582 PyObject * obj2 = 0 ;
11583 PyObject * obj3 = 0 ;
11584 char *kwnames[] = {
11585 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11586 };
11587
11588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11590 if (SWIG_arg_fail(1)) SWIG_fail;
11591 {
11592 arg2 = wxString_in_helper(obj1);
11593 if (arg2 == NULL) SWIG_fail;
11594 temp2 = true;
11595 }
11596 {
11597 arg3 = wxString_in_helper(obj2);
11598 if (arg3 == NULL) SWIG_fail;
11599 temp3 = true;
11600 }
11601 if (obj3) {
11602 {
11603 arg4 = (int)(SWIG_As_int(obj3));
11604 if (SWIG_arg_fail(4)) SWIG_fail;
11605 }
11606 }
11607 {
11608 PyThreadState* __tstate = wxPyBeginAllowThreads();
11609 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11610
11611 wxPyEndAllowThreads(__tstate);
11612 if (PyErr_Occurred()) SWIG_fail;
11613 }
11614 {
11615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11616 }
11617 {
11618 if (temp2)
11619 delete arg2;
11620 }
11621 {
11622 if (temp3)
11623 delete arg3;
11624 }
11625 return resultobj;
11626 fail:
11627 {
11628 if (temp2)
11629 delete arg2;
11630 }
11631 {
11632 if (temp3)
11633 delete arg3;
11634 }
11635 return NULL;
11636 }
11637
11638
11639 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11640 PyObject *resultobj;
11641 wxImage *arg1 = (wxImage *) 0 ;
11642 wxString *arg2 = 0 ;
11643 int arg3 ;
11644 bool result;
11645 bool temp2 = false ;
11646 PyObject * obj0 = 0 ;
11647 PyObject * obj1 = 0 ;
11648 PyObject * obj2 = 0 ;
11649 char *kwnames[] = {
11650 (char *) "self",(char *) "name",(char *) "type", NULL
11651 };
11652
11653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11655 if (SWIG_arg_fail(1)) SWIG_fail;
11656 {
11657 arg2 = wxString_in_helper(obj1);
11658 if (arg2 == NULL) SWIG_fail;
11659 temp2 = true;
11660 }
11661 {
11662 arg3 = (int)(SWIG_As_int(obj2));
11663 if (SWIG_arg_fail(3)) SWIG_fail;
11664 }
11665 {
11666 PyThreadState* __tstate = wxPyBeginAllowThreads();
11667 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
11668
11669 wxPyEndAllowThreads(__tstate);
11670 if (PyErr_Occurred()) SWIG_fail;
11671 }
11672 {
11673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11674 }
11675 {
11676 if (temp2)
11677 delete arg2;
11678 }
11679 return resultobj;
11680 fail:
11681 {
11682 if (temp2)
11683 delete arg2;
11684 }
11685 return NULL;
11686 }
11687
11688
11689 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11690 PyObject *resultobj;
11691 wxImage *arg1 = (wxImage *) 0 ;
11692 wxString *arg2 = 0 ;
11693 wxString *arg3 = 0 ;
11694 bool result;
11695 bool temp2 = false ;
11696 bool temp3 = false ;
11697 PyObject * obj0 = 0 ;
11698 PyObject * obj1 = 0 ;
11699 PyObject * obj2 = 0 ;
11700 char *kwnames[] = {
11701 (char *) "self",(char *) "name",(char *) "mimetype", NULL
11702 };
11703
11704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
11705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11706 if (SWIG_arg_fail(1)) SWIG_fail;
11707 {
11708 arg2 = wxString_in_helper(obj1);
11709 if (arg2 == NULL) SWIG_fail;
11710 temp2 = true;
11711 }
11712 {
11713 arg3 = wxString_in_helper(obj2);
11714 if (arg3 == NULL) SWIG_fail;
11715 temp3 = true;
11716 }
11717 {
11718 PyThreadState* __tstate = wxPyBeginAllowThreads();
11719 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
11720
11721 wxPyEndAllowThreads(__tstate);
11722 if (PyErr_Occurred()) SWIG_fail;
11723 }
11724 {
11725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11726 }
11727 {
11728 if (temp2)
11729 delete arg2;
11730 }
11731 {
11732 if (temp3)
11733 delete arg3;
11734 }
11735 return resultobj;
11736 fail:
11737 {
11738 if (temp2)
11739 delete arg2;
11740 }
11741 {
11742 if (temp3)
11743 delete arg3;
11744 }
11745 return NULL;
11746 }
11747
11748
11749 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11750 PyObject *resultobj;
11751 wxInputStream *arg1 = 0 ;
11752 bool result;
11753 wxPyInputStream *temp1 ;
11754 bool created1 ;
11755 PyObject * obj0 = 0 ;
11756 char *kwnames[] = {
11757 (char *) "stream", NULL
11758 };
11759
11760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
11761 {
11762 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11763 arg1 = temp1->m_wxis;
11764 created1 = false;
11765 } else {
11766 PyErr_Clear(); // clear the failure of the wxPyConvert above
11767 arg1 = wxPyCBInputStream_create(obj0, false);
11768 if (arg1 == NULL) {
11769 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11770 SWIG_fail;
11771 }
11772 created1 = true;
11773 }
11774 }
11775 {
11776 PyThreadState* __tstate = wxPyBeginAllowThreads();
11777 result = (bool)wxImage::CanRead(*arg1);
11778
11779 wxPyEndAllowThreads(__tstate);
11780 if (PyErr_Occurred()) SWIG_fail;
11781 }
11782 {
11783 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11784 }
11785 {
11786 if (created1)
11787 delete arg1;
11788 }
11789 return resultobj;
11790 fail:
11791 {
11792 if (created1)
11793 delete arg1;
11794 }
11795 return NULL;
11796 }
11797
11798
11799 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
11800 PyObject *resultobj;
11801 wxImage *arg1 = (wxImage *) 0 ;
11802 wxInputStream *arg2 = 0 ;
11803 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11804 int arg4 = (int) -1 ;
11805 bool result;
11806 wxPyInputStream *temp2 ;
11807 bool created2 ;
11808 PyObject * obj0 = 0 ;
11809 PyObject * obj1 = 0 ;
11810 PyObject * obj2 = 0 ;
11811 PyObject * obj3 = 0 ;
11812 char *kwnames[] = {
11813 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
11814 };
11815
11816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11818 if (SWIG_arg_fail(1)) SWIG_fail;
11819 {
11820 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11821 arg2 = temp2->m_wxis;
11822 created2 = false;
11823 } else {
11824 PyErr_Clear(); // clear the failure of the wxPyConvert above
11825 arg2 = wxPyCBInputStream_create(obj1, false);
11826 if (arg2 == NULL) {
11827 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11828 SWIG_fail;
11829 }
11830 created2 = true;
11831 }
11832 }
11833 if (obj2) {
11834 {
11835 arg3 = (long)(SWIG_As_long(obj2));
11836 if (SWIG_arg_fail(3)) SWIG_fail;
11837 }
11838 }
11839 if (obj3) {
11840 {
11841 arg4 = (int)(SWIG_As_int(obj3));
11842 if (SWIG_arg_fail(4)) SWIG_fail;
11843 }
11844 }
11845 {
11846 PyThreadState* __tstate = wxPyBeginAllowThreads();
11847 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
11848
11849 wxPyEndAllowThreads(__tstate);
11850 if (PyErr_Occurred()) SWIG_fail;
11851 }
11852 {
11853 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11854 }
11855 {
11856 if (created2)
11857 delete arg2;
11858 }
11859 return resultobj;
11860 fail:
11861 {
11862 if (created2)
11863 delete arg2;
11864 }
11865 return NULL;
11866 }
11867
11868
11869 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
11870 PyObject *resultobj;
11871 wxImage *arg1 = (wxImage *) 0 ;
11872 wxInputStream *arg2 = 0 ;
11873 wxString *arg3 = 0 ;
11874 int arg4 = (int) -1 ;
11875 bool result;
11876 wxPyInputStream *temp2 ;
11877 bool created2 ;
11878 bool temp3 = false ;
11879 PyObject * obj0 = 0 ;
11880 PyObject * obj1 = 0 ;
11881 PyObject * obj2 = 0 ;
11882 PyObject * obj3 = 0 ;
11883 char *kwnames[] = {
11884 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
11885 };
11886
11887 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11888 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11889 if (SWIG_arg_fail(1)) SWIG_fail;
11890 {
11891 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11892 arg2 = temp2->m_wxis;
11893 created2 = false;
11894 } else {
11895 PyErr_Clear(); // clear the failure of the wxPyConvert above
11896 arg2 = wxPyCBInputStream_create(obj1, false);
11897 if (arg2 == NULL) {
11898 PyErr_SetString(PyExc_TypeError, "Expected wxInputStream or Python file-like object.");
11899 SWIG_fail;
11900 }
11901 created2 = true;
11902 }
11903 }
11904 {
11905 arg3 = wxString_in_helper(obj2);
11906 if (arg3 == NULL) SWIG_fail;
11907 temp3 = true;
11908 }
11909 if (obj3) {
11910 {
11911 arg4 = (int)(SWIG_As_int(obj3));
11912 if (SWIG_arg_fail(4)) SWIG_fail;
11913 }
11914 }
11915 {
11916 PyThreadState* __tstate = wxPyBeginAllowThreads();
11917 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
11918
11919 wxPyEndAllowThreads(__tstate);
11920 if (PyErr_Occurred()) SWIG_fail;
11921 }
11922 {
11923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11924 }
11925 {
11926 if (created2)
11927 delete arg2;
11928 }
11929 {
11930 if (temp3)
11931 delete arg3;
11932 }
11933 return resultobj;
11934 fail:
11935 {
11936 if (created2)
11937 delete arg2;
11938 }
11939 {
11940 if (temp3)
11941 delete arg3;
11942 }
11943 return NULL;
11944 }
11945
11946
11947 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
11948 PyObject *resultobj;
11949 wxImage *arg1 = (wxImage *) 0 ;
11950 bool result;
11951 PyObject * obj0 = 0 ;
11952 char *kwnames[] = {
11953 (char *) "self", NULL
11954 };
11955
11956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
11957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11958 if (SWIG_arg_fail(1)) SWIG_fail;
11959 {
11960 PyThreadState* __tstate = wxPyBeginAllowThreads();
11961 result = (bool)(arg1)->Ok();
11962
11963 wxPyEndAllowThreads(__tstate);
11964 if (PyErr_Occurred()) SWIG_fail;
11965 }
11966 {
11967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11968 }
11969 return resultobj;
11970 fail:
11971 return NULL;
11972 }
11973
11974
11975 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
11976 PyObject *resultobj;
11977 wxImage *arg1 = (wxImage *) 0 ;
11978 int result;
11979 PyObject * obj0 = 0 ;
11980 char *kwnames[] = {
11981 (char *) "self", NULL
11982 };
11983
11984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
11985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11986 if (SWIG_arg_fail(1)) SWIG_fail;
11987 {
11988 PyThreadState* __tstate = wxPyBeginAllowThreads();
11989 result = (int)(arg1)->GetWidth();
11990
11991 wxPyEndAllowThreads(__tstate);
11992 if (PyErr_Occurred()) SWIG_fail;
11993 }
11994 {
11995 resultobj = SWIG_From_int((int)(result));
11996 }
11997 return resultobj;
11998 fail:
11999 return NULL;
12000 }
12001
12002
12003 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12004 PyObject *resultobj;
12005 wxImage *arg1 = (wxImage *) 0 ;
12006 int result;
12007 PyObject * obj0 = 0 ;
12008 char *kwnames[] = {
12009 (char *) "self", NULL
12010 };
12011
12012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12014 if (SWIG_arg_fail(1)) SWIG_fail;
12015 {
12016 PyThreadState* __tstate = wxPyBeginAllowThreads();
12017 result = (int)(arg1)->GetHeight();
12018
12019 wxPyEndAllowThreads(__tstate);
12020 if (PyErr_Occurred()) SWIG_fail;
12021 }
12022 {
12023 resultobj = SWIG_From_int((int)(result));
12024 }
12025 return resultobj;
12026 fail:
12027 return NULL;
12028 }
12029
12030
12031 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12032 PyObject *resultobj;
12033 wxImage *arg1 = (wxImage *) 0 ;
12034 wxSize result;
12035 PyObject * obj0 = 0 ;
12036 char *kwnames[] = {
12037 (char *) "self", NULL
12038 };
12039
12040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12042 if (SWIG_arg_fail(1)) SWIG_fail;
12043 {
12044 PyThreadState* __tstate = wxPyBeginAllowThreads();
12045 result = wxImage_GetSize(arg1);
12046
12047 wxPyEndAllowThreads(__tstate);
12048 if (PyErr_Occurred()) SWIG_fail;
12049 }
12050 {
12051 wxSize * resultptr;
12052 resultptr = new wxSize((wxSize &)(result));
12053 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12054 }
12055 return resultobj;
12056 fail:
12057 return NULL;
12058 }
12059
12060
12061 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12062 PyObject *resultobj;
12063 wxImage *arg1 = (wxImage *) 0 ;
12064 wxRect *arg2 = 0 ;
12065 SwigValueWrapper<wxImage > result;
12066 wxRect temp2 ;
12067 PyObject * obj0 = 0 ;
12068 PyObject * obj1 = 0 ;
12069 char *kwnames[] = {
12070 (char *) "self",(char *) "rect", NULL
12071 };
12072
12073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12074 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12075 if (SWIG_arg_fail(1)) SWIG_fail;
12076 {
12077 arg2 = &temp2;
12078 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12079 }
12080 {
12081 PyThreadState* __tstate = wxPyBeginAllowThreads();
12082 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12083
12084 wxPyEndAllowThreads(__tstate);
12085 if (PyErr_Occurred()) SWIG_fail;
12086 }
12087 {
12088 wxImage * resultptr;
12089 resultptr = new wxImage((wxImage &)(result));
12090 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12091 }
12092 return resultobj;
12093 fail:
12094 return NULL;
12095 }
12096
12097
12098 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12099 PyObject *resultobj;
12100 wxImage *arg1 = (wxImage *) 0 ;
12101 SwigValueWrapper<wxImage > result;
12102 PyObject * obj0 = 0 ;
12103 char *kwnames[] = {
12104 (char *) "self", NULL
12105 };
12106
12107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12109 if (SWIG_arg_fail(1)) SWIG_fail;
12110 {
12111 PyThreadState* __tstate = wxPyBeginAllowThreads();
12112 result = (arg1)->Copy();
12113
12114 wxPyEndAllowThreads(__tstate);
12115 if (PyErr_Occurred()) SWIG_fail;
12116 }
12117 {
12118 wxImage * resultptr;
12119 resultptr = new wxImage((wxImage &)(result));
12120 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12121 }
12122 return resultobj;
12123 fail:
12124 return NULL;
12125 }
12126
12127
12128 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12129 PyObject *resultobj;
12130 wxImage *arg1 = (wxImage *) 0 ;
12131 wxImage *arg2 = 0 ;
12132 int arg3 ;
12133 int arg4 ;
12134 PyObject * obj0 = 0 ;
12135 PyObject * obj1 = 0 ;
12136 PyObject * obj2 = 0 ;
12137 PyObject * obj3 = 0 ;
12138 char *kwnames[] = {
12139 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12140 };
12141
12142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12144 if (SWIG_arg_fail(1)) SWIG_fail;
12145 {
12146 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12147 if (SWIG_arg_fail(2)) SWIG_fail;
12148 if (arg2 == NULL) {
12149 SWIG_null_ref("wxImage");
12150 }
12151 if (SWIG_arg_fail(2)) SWIG_fail;
12152 }
12153 {
12154 arg3 = (int)(SWIG_As_int(obj2));
12155 if (SWIG_arg_fail(3)) SWIG_fail;
12156 }
12157 {
12158 arg4 = (int)(SWIG_As_int(obj3));
12159 if (SWIG_arg_fail(4)) SWIG_fail;
12160 }
12161 {
12162 PyThreadState* __tstate = wxPyBeginAllowThreads();
12163 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12164
12165 wxPyEndAllowThreads(__tstate);
12166 if (PyErr_Occurred()) SWIG_fail;
12167 }
12168 Py_INCREF(Py_None); resultobj = Py_None;
12169 return resultobj;
12170 fail:
12171 return NULL;
12172 }
12173
12174
12175 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12176 PyObject *resultobj;
12177 wxImage *arg1 = (wxImage *) 0 ;
12178 PyObject *result;
12179 PyObject * obj0 = 0 ;
12180 char *kwnames[] = {
12181 (char *) "self", NULL
12182 };
12183
12184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12186 if (SWIG_arg_fail(1)) SWIG_fail;
12187 {
12188 PyThreadState* __tstate = wxPyBeginAllowThreads();
12189 result = (PyObject *)wxImage_GetData(arg1);
12190
12191 wxPyEndAllowThreads(__tstate);
12192 if (PyErr_Occurred()) SWIG_fail;
12193 }
12194 resultobj = result;
12195 return resultobj;
12196 fail:
12197 return NULL;
12198 }
12199
12200
12201 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12202 PyObject *resultobj;
12203 wxImage *arg1 = (wxImage *) 0 ;
12204 PyObject *arg2 = (PyObject *) 0 ;
12205 PyObject * obj0 = 0 ;
12206 PyObject * obj1 = 0 ;
12207 char *kwnames[] = {
12208 (char *) "self",(char *) "data", NULL
12209 };
12210
12211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12213 if (SWIG_arg_fail(1)) SWIG_fail;
12214 arg2 = obj1;
12215 {
12216 PyThreadState* __tstate = wxPyBeginAllowThreads();
12217 wxImage_SetData(arg1,arg2);
12218
12219 wxPyEndAllowThreads(__tstate);
12220 if (PyErr_Occurred()) SWIG_fail;
12221 }
12222 Py_INCREF(Py_None); resultobj = Py_None;
12223 return resultobj;
12224 fail:
12225 return NULL;
12226 }
12227
12228
12229 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12230 PyObject *resultobj;
12231 wxImage *arg1 = (wxImage *) 0 ;
12232 PyObject *result;
12233 PyObject * obj0 = 0 ;
12234 char *kwnames[] = {
12235 (char *) "self", NULL
12236 };
12237
12238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12240 if (SWIG_arg_fail(1)) SWIG_fail;
12241 {
12242 PyThreadState* __tstate = wxPyBeginAllowThreads();
12243 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12244
12245 wxPyEndAllowThreads(__tstate);
12246 if (PyErr_Occurred()) SWIG_fail;
12247 }
12248 resultobj = result;
12249 return resultobj;
12250 fail:
12251 return NULL;
12252 }
12253
12254
12255 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12256 PyObject *resultobj;
12257 wxImage *arg1 = (wxImage *) 0 ;
12258 PyObject *arg2 = (PyObject *) 0 ;
12259 PyObject * obj0 = 0 ;
12260 PyObject * obj1 = 0 ;
12261 char *kwnames[] = {
12262 (char *) "self",(char *) "data", NULL
12263 };
12264
12265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12267 if (SWIG_arg_fail(1)) SWIG_fail;
12268 arg2 = obj1;
12269 {
12270 PyThreadState* __tstate = wxPyBeginAllowThreads();
12271 wxImage_SetDataBuffer(arg1,arg2);
12272
12273 wxPyEndAllowThreads(__tstate);
12274 if (PyErr_Occurred()) SWIG_fail;
12275 }
12276 Py_INCREF(Py_None); resultobj = Py_None;
12277 return resultobj;
12278 fail:
12279 return NULL;
12280 }
12281
12282
12283 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12284 PyObject *resultobj;
12285 wxImage *arg1 = (wxImage *) 0 ;
12286 PyObject *result;
12287 PyObject * obj0 = 0 ;
12288 char *kwnames[] = {
12289 (char *) "self", NULL
12290 };
12291
12292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",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 = (PyObject *)wxImage_GetAlphaData(arg1);
12298
12299 wxPyEndAllowThreads(__tstate);
12300 if (PyErr_Occurred()) SWIG_fail;
12301 }
12302 resultobj = result;
12303 return resultobj;
12304 fail:
12305 return NULL;
12306 }
12307
12308
12309 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12310 PyObject *resultobj;
12311 wxImage *arg1 = (wxImage *) 0 ;
12312 PyObject *arg2 = (PyObject *) 0 ;
12313 PyObject * obj0 = 0 ;
12314 PyObject * obj1 = 0 ;
12315 char *kwnames[] = {
12316 (char *) "self",(char *) "data", NULL
12317 };
12318
12319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
12320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12321 if (SWIG_arg_fail(1)) SWIG_fail;
12322 arg2 = obj1;
12323 {
12324 PyThreadState* __tstate = wxPyBeginAllowThreads();
12325 wxImage_SetAlphaData(arg1,arg2);
12326
12327 wxPyEndAllowThreads(__tstate);
12328 if (PyErr_Occurred()) SWIG_fail;
12329 }
12330 Py_INCREF(Py_None); resultobj = Py_None;
12331 return resultobj;
12332 fail:
12333 return NULL;
12334 }
12335
12336
12337 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12338 PyObject *resultobj;
12339 wxImage *arg1 = (wxImage *) 0 ;
12340 PyObject *result;
12341 PyObject * obj0 = 0 ;
12342 char *kwnames[] = {
12343 (char *) "self", NULL
12344 };
12345
12346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12348 if (SWIG_arg_fail(1)) SWIG_fail;
12349 {
12350 PyThreadState* __tstate = wxPyBeginAllowThreads();
12351 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12352
12353 wxPyEndAllowThreads(__tstate);
12354 if (PyErr_Occurred()) SWIG_fail;
12355 }
12356 resultobj = result;
12357 return resultobj;
12358 fail:
12359 return NULL;
12360 }
12361
12362
12363 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12364 PyObject *resultobj;
12365 wxImage *arg1 = (wxImage *) 0 ;
12366 PyObject *arg2 = (PyObject *) 0 ;
12367 PyObject * obj0 = 0 ;
12368 PyObject * obj1 = 0 ;
12369 char *kwnames[] = {
12370 (char *) "self",(char *) "data", NULL
12371 };
12372
12373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12375 if (SWIG_arg_fail(1)) SWIG_fail;
12376 arg2 = obj1;
12377 {
12378 PyThreadState* __tstate = wxPyBeginAllowThreads();
12379 wxImage_SetAlphaBuffer(arg1,arg2);
12380
12381 wxPyEndAllowThreads(__tstate);
12382 if (PyErr_Occurred()) SWIG_fail;
12383 }
12384 Py_INCREF(Py_None); resultobj = Py_None;
12385 return resultobj;
12386 fail:
12387 return NULL;
12388 }
12389
12390
12391 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12392 PyObject *resultobj;
12393 wxImage *arg1 = (wxImage *) 0 ;
12394 unsigned char arg2 ;
12395 unsigned char arg3 ;
12396 unsigned char arg4 ;
12397 PyObject * obj0 = 0 ;
12398 PyObject * obj1 = 0 ;
12399 PyObject * obj2 = 0 ;
12400 PyObject * obj3 = 0 ;
12401 char *kwnames[] = {
12402 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12403 };
12404
12405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12407 if (SWIG_arg_fail(1)) SWIG_fail;
12408 {
12409 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12410 if (SWIG_arg_fail(2)) SWIG_fail;
12411 }
12412 {
12413 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12414 if (SWIG_arg_fail(3)) SWIG_fail;
12415 }
12416 {
12417 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12418 if (SWIG_arg_fail(4)) SWIG_fail;
12419 }
12420 {
12421 PyThreadState* __tstate = wxPyBeginAllowThreads();
12422 (arg1)->SetMaskColour(arg2,arg3,arg4);
12423
12424 wxPyEndAllowThreads(__tstate);
12425 if (PyErr_Occurred()) SWIG_fail;
12426 }
12427 Py_INCREF(Py_None); resultobj = Py_None;
12428 return resultobj;
12429 fail:
12430 return NULL;
12431 }
12432
12433
12434 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12435 PyObject *resultobj;
12436 wxImage *arg1 = (wxImage *) 0 ;
12437 unsigned char result;
12438 PyObject * obj0 = 0 ;
12439 char *kwnames[] = {
12440 (char *) "self", NULL
12441 };
12442
12443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12445 if (SWIG_arg_fail(1)) SWIG_fail;
12446 {
12447 PyThreadState* __tstate = wxPyBeginAllowThreads();
12448 result = (unsigned char)(arg1)->GetMaskRed();
12449
12450 wxPyEndAllowThreads(__tstate);
12451 if (PyErr_Occurred()) SWIG_fail;
12452 }
12453 {
12454 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12455 }
12456 return resultobj;
12457 fail:
12458 return NULL;
12459 }
12460
12461
12462 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12463 PyObject *resultobj;
12464 wxImage *arg1 = (wxImage *) 0 ;
12465 unsigned char result;
12466 PyObject * obj0 = 0 ;
12467 char *kwnames[] = {
12468 (char *) "self", NULL
12469 };
12470
12471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12473 if (SWIG_arg_fail(1)) SWIG_fail;
12474 {
12475 PyThreadState* __tstate = wxPyBeginAllowThreads();
12476 result = (unsigned char)(arg1)->GetMaskGreen();
12477
12478 wxPyEndAllowThreads(__tstate);
12479 if (PyErr_Occurred()) SWIG_fail;
12480 }
12481 {
12482 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12483 }
12484 return resultobj;
12485 fail:
12486 return NULL;
12487 }
12488
12489
12490 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12491 PyObject *resultobj;
12492 wxImage *arg1 = (wxImage *) 0 ;
12493 unsigned char result;
12494 PyObject * obj0 = 0 ;
12495 char *kwnames[] = {
12496 (char *) "self", NULL
12497 };
12498
12499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12501 if (SWIG_arg_fail(1)) SWIG_fail;
12502 {
12503 PyThreadState* __tstate = wxPyBeginAllowThreads();
12504 result = (unsigned char)(arg1)->GetMaskBlue();
12505
12506 wxPyEndAllowThreads(__tstate);
12507 if (PyErr_Occurred()) SWIG_fail;
12508 }
12509 {
12510 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12511 }
12512 return resultobj;
12513 fail:
12514 return NULL;
12515 }
12516
12517
12518 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12519 PyObject *resultobj;
12520 wxImage *arg1 = (wxImage *) 0 ;
12521 bool arg2 = (bool) true ;
12522 PyObject * obj0 = 0 ;
12523 PyObject * obj1 = 0 ;
12524 char *kwnames[] = {
12525 (char *) "self",(char *) "mask", NULL
12526 };
12527
12528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
12529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12530 if (SWIG_arg_fail(1)) SWIG_fail;
12531 if (obj1) {
12532 {
12533 arg2 = (bool)(SWIG_As_bool(obj1));
12534 if (SWIG_arg_fail(2)) SWIG_fail;
12535 }
12536 }
12537 {
12538 PyThreadState* __tstate = wxPyBeginAllowThreads();
12539 (arg1)->SetMask(arg2);
12540
12541 wxPyEndAllowThreads(__tstate);
12542 if (PyErr_Occurred()) SWIG_fail;
12543 }
12544 Py_INCREF(Py_None); resultobj = Py_None;
12545 return resultobj;
12546 fail:
12547 return NULL;
12548 }
12549
12550
12551 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
12552 PyObject *resultobj;
12553 wxImage *arg1 = (wxImage *) 0 ;
12554 bool result;
12555 PyObject * obj0 = 0 ;
12556 char *kwnames[] = {
12557 (char *) "self", NULL
12558 };
12559
12560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
12561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12562 if (SWIG_arg_fail(1)) SWIG_fail;
12563 {
12564 PyThreadState* __tstate = wxPyBeginAllowThreads();
12565 result = (bool)(arg1)->HasMask();
12566
12567 wxPyEndAllowThreads(__tstate);
12568 if (PyErr_Occurred()) SWIG_fail;
12569 }
12570 {
12571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12572 }
12573 return resultobj;
12574 fail:
12575 return NULL;
12576 }
12577
12578
12579 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
12580 PyObject *resultobj;
12581 wxImage *arg1 = (wxImage *) 0 ;
12582 double arg2 ;
12583 wxPoint *arg3 = 0 ;
12584 bool arg4 = (bool) true ;
12585 wxPoint *arg5 = (wxPoint *) NULL ;
12586 SwigValueWrapper<wxImage > result;
12587 wxPoint temp3 ;
12588 PyObject * obj0 = 0 ;
12589 PyObject * obj1 = 0 ;
12590 PyObject * obj2 = 0 ;
12591 PyObject * obj3 = 0 ;
12592 PyObject * obj4 = 0 ;
12593 char *kwnames[] = {
12594 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
12595 };
12596
12597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12599 if (SWIG_arg_fail(1)) SWIG_fail;
12600 {
12601 arg2 = (double)(SWIG_As_double(obj1));
12602 if (SWIG_arg_fail(2)) SWIG_fail;
12603 }
12604 {
12605 arg3 = &temp3;
12606 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12607 }
12608 if (obj3) {
12609 {
12610 arg4 = (bool)(SWIG_As_bool(obj3));
12611 if (SWIG_arg_fail(4)) SWIG_fail;
12612 }
12613 }
12614 if (obj4) {
12615 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
12616 if (SWIG_arg_fail(5)) SWIG_fail;
12617 }
12618 {
12619 PyThreadState* __tstate = wxPyBeginAllowThreads();
12620 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
12621
12622 wxPyEndAllowThreads(__tstate);
12623 if (PyErr_Occurred()) SWIG_fail;
12624 }
12625 {
12626 wxImage * resultptr;
12627 resultptr = new wxImage((wxImage &)(result));
12628 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12629 }
12630 return resultobj;
12631 fail:
12632 return NULL;
12633 }
12634
12635
12636 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
12637 PyObject *resultobj;
12638 wxImage *arg1 = (wxImage *) 0 ;
12639 bool arg2 = (bool) true ;
12640 SwigValueWrapper<wxImage > result;
12641 PyObject * obj0 = 0 ;
12642 PyObject * obj1 = 0 ;
12643 char *kwnames[] = {
12644 (char *) "self",(char *) "clockwise", NULL
12645 };
12646
12647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
12648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12649 if (SWIG_arg_fail(1)) SWIG_fail;
12650 if (obj1) {
12651 {
12652 arg2 = (bool)(SWIG_As_bool(obj1));
12653 if (SWIG_arg_fail(2)) SWIG_fail;
12654 }
12655 }
12656 {
12657 PyThreadState* __tstate = wxPyBeginAllowThreads();
12658 result = (arg1)->Rotate90(arg2);
12659
12660 wxPyEndAllowThreads(__tstate);
12661 if (PyErr_Occurred()) SWIG_fail;
12662 }
12663 {
12664 wxImage * resultptr;
12665 resultptr = new wxImage((wxImage &)(result));
12666 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12667 }
12668 return resultobj;
12669 fail:
12670 return NULL;
12671 }
12672
12673
12674 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
12675 PyObject *resultobj;
12676 wxImage *arg1 = (wxImage *) 0 ;
12677 bool arg2 = (bool) true ;
12678 SwigValueWrapper<wxImage > result;
12679 PyObject * obj0 = 0 ;
12680 PyObject * obj1 = 0 ;
12681 char *kwnames[] = {
12682 (char *) "self",(char *) "horizontally", NULL
12683 };
12684
12685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
12686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12687 if (SWIG_arg_fail(1)) SWIG_fail;
12688 if (obj1) {
12689 {
12690 arg2 = (bool)(SWIG_As_bool(obj1));
12691 if (SWIG_arg_fail(2)) SWIG_fail;
12692 }
12693 }
12694 {
12695 PyThreadState* __tstate = wxPyBeginAllowThreads();
12696 result = (arg1)->Mirror(arg2);
12697
12698 wxPyEndAllowThreads(__tstate);
12699 if (PyErr_Occurred()) SWIG_fail;
12700 }
12701 {
12702 wxImage * resultptr;
12703 resultptr = new wxImage((wxImage &)(result));
12704 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12705 }
12706 return resultobj;
12707 fail:
12708 return NULL;
12709 }
12710
12711
12712 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
12713 PyObject *resultobj;
12714 wxImage *arg1 = (wxImage *) 0 ;
12715 unsigned char arg2 ;
12716 unsigned char arg3 ;
12717 unsigned char arg4 ;
12718 unsigned char arg5 ;
12719 unsigned char arg6 ;
12720 unsigned char arg7 ;
12721 PyObject * obj0 = 0 ;
12722 PyObject * obj1 = 0 ;
12723 PyObject * obj2 = 0 ;
12724 PyObject * obj3 = 0 ;
12725 PyObject * obj4 = 0 ;
12726 PyObject * obj5 = 0 ;
12727 PyObject * obj6 = 0 ;
12728 char *kwnames[] = {
12729 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
12730 };
12731
12732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
12733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12734 if (SWIG_arg_fail(1)) SWIG_fail;
12735 {
12736 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12737 if (SWIG_arg_fail(2)) SWIG_fail;
12738 }
12739 {
12740 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12741 if (SWIG_arg_fail(3)) SWIG_fail;
12742 }
12743 {
12744 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12745 if (SWIG_arg_fail(4)) SWIG_fail;
12746 }
12747 {
12748 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
12749 if (SWIG_arg_fail(5)) SWIG_fail;
12750 }
12751 {
12752 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
12753 if (SWIG_arg_fail(6)) SWIG_fail;
12754 }
12755 {
12756 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
12757 if (SWIG_arg_fail(7)) SWIG_fail;
12758 }
12759 {
12760 PyThreadState* __tstate = wxPyBeginAllowThreads();
12761 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
12762
12763 wxPyEndAllowThreads(__tstate);
12764 if (PyErr_Occurred()) SWIG_fail;
12765 }
12766 Py_INCREF(Py_None); resultobj = Py_None;
12767 return resultobj;
12768 fail:
12769 return NULL;
12770 }
12771
12772
12773 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
12774 PyObject *resultobj;
12775 wxImage *arg1 = (wxImage *) 0 ;
12776 unsigned char arg2 ;
12777 unsigned char arg3 ;
12778 unsigned char arg4 ;
12779 SwigValueWrapper<wxImage > result;
12780 PyObject * obj0 = 0 ;
12781 PyObject * obj1 = 0 ;
12782 PyObject * obj2 = 0 ;
12783 PyObject * obj3 = 0 ;
12784 char *kwnames[] = {
12785 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12786 };
12787
12788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12790 if (SWIG_arg_fail(1)) SWIG_fail;
12791 {
12792 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12793 if (SWIG_arg_fail(2)) SWIG_fail;
12794 }
12795 {
12796 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12797 if (SWIG_arg_fail(3)) SWIG_fail;
12798 }
12799 {
12800 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12801 if (SWIG_arg_fail(4)) SWIG_fail;
12802 }
12803 {
12804 PyThreadState* __tstate = wxPyBeginAllowThreads();
12805 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
12806
12807 wxPyEndAllowThreads(__tstate);
12808 if (PyErr_Occurred()) SWIG_fail;
12809 }
12810 {
12811 wxImage * resultptr;
12812 resultptr = new wxImage((wxImage &)(result));
12813 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12814 }
12815 return resultobj;
12816 fail:
12817 return NULL;
12818 }
12819
12820
12821 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12822 PyObject *resultobj;
12823 wxImage *arg1 = (wxImage *) 0 ;
12824 wxString *arg2 = 0 ;
12825 wxString *arg3 = 0 ;
12826 bool temp2 = false ;
12827 bool temp3 = false ;
12828 PyObject * obj0 = 0 ;
12829 PyObject * obj1 = 0 ;
12830 PyObject * obj2 = 0 ;
12831 char *kwnames[] = {
12832 (char *) "self",(char *) "name",(char *) "value", NULL
12833 };
12834
12835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
12836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12837 if (SWIG_arg_fail(1)) SWIG_fail;
12838 {
12839 arg2 = wxString_in_helper(obj1);
12840 if (arg2 == NULL) SWIG_fail;
12841 temp2 = true;
12842 }
12843 {
12844 arg3 = wxString_in_helper(obj2);
12845 if (arg3 == NULL) SWIG_fail;
12846 temp3 = true;
12847 }
12848 {
12849 PyThreadState* __tstate = wxPyBeginAllowThreads();
12850 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
12851
12852 wxPyEndAllowThreads(__tstate);
12853 if (PyErr_Occurred()) SWIG_fail;
12854 }
12855 Py_INCREF(Py_None); resultobj = Py_None;
12856 {
12857 if (temp2)
12858 delete arg2;
12859 }
12860 {
12861 if (temp3)
12862 delete arg3;
12863 }
12864 return resultobj;
12865 fail:
12866 {
12867 if (temp2)
12868 delete arg2;
12869 }
12870 {
12871 if (temp3)
12872 delete arg3;
12873 }
12874 return NULL;
12875 }
12876
12877
12878 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12879 PyObject *resultobj;
12880 wxImage *arg1 = (wxImage *) 0 ;
12881 wxString *arg2 = 0 ;
12882 int arg3 ;
12883 bool temp2 = false ;
12884 PyObject * obj0 = 0 ;
12885 PyObject * obj1 = 0 ;
12886 PyObject * obj2 = 0 ;
12887 char *kwnames[] = {
12888 (char *) "self",(char *) "name",(char *) "value", NULL
12889 };
12890
12891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
12892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12893 if (SWIG_arg_fail(1)) SWIG_fail;
12894 {
12895 arg2 = wxString_in_helper(obj1);
12896 if (arg2 == NULL) SWIG_fail;
12897 temp2 = true;
12898 }
12899 {
12900 arg3 = (int)(SWIG_As_int(obj2));
12901 if (SWIG_arg_fail(3)) SWIG_fail;
12902 }
12903 {
12904 PyThreadState* __tstate = wxPyBeginAllowThreads();
12905 (arg1)->SetOption((wxString const &)*arg2,arg3);
12906
12907 wxPyEndAllowThreads(__tstate);
12908 if (PyErr_Occurred()) SWIG_fail;
12909 }
12910 Py_INCREF(Py_None); resultobj = Py_None;
12911 {
12912 if (temp2)
12913 delete arg2;
12914 }
12915 return resultobj;
12916 fail:
12917 {
12918 if (temp2)
12919 delete arg2;
12920 }
12921 return NULL;
12922 }
12923
12924
12925 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
12926 PyObject *resultobj;
12927 wxImage *arg1 = (wxImage *) 0 ;
12928 wxString *arg2 = 0 ;
12929 wxString result;
12930 bool temp2 = false ;
12931 PyObject * obj0 = 0 ;
12932 PyObject * obj1 = 0 ;
12933 char *kwnames[] = {
12934 (char *) "self",(char *) "name", NULL
12935 };
12936
12937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
12938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12939 if (SWIG_arg_fail(1)) SWIG_fail;
12940 {
12941 arg2 = wxString_in_helper(obj1);
12942 if (arg2 == NULL) SWIG_fail;
12943 temp2 = true;
12944 }
12945 {
12946 PyThreadState* __tstate = wxPyBeginAllowThreads();
12947 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
12948
12949 wxPyEndAllowThreads(__tstate);
12950 if (PyErr_Occurred()) SWIG_fail;
12951 }
12952 {
12953 #if wxUSE_UNICODE
12954 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12955 #else
12956 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12957 #endif
12958 }
12959 {
12960 if (temp2)
12961 delete arg2;
12962 }
12963 return resultobj;
12964 fail:
12965 {
12966 if (temp2)
12967 delete arg2;
12968 }
12969 return NULL;
12970 }
12971
12972
12973 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
12974 PyObject *resultobj;
12975 wxImage *arg1 = (wxImage *) 0 ;
12976 wxString *arg2 = 0 ;
12977 int result;
12978 bool temp2 = false ;
12979 PyObject * obj0 = 0 ;
12980 PyObject * obj1 = 0 ;
12981 char *kwnames[] = {
12982 (char *) "self",(char *) "name", NULL
12983 };
12984
12985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
12986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12987 if (SWIG_arg_fail(1)) SWIG_fail;
12988 {
12989 arg2 = wxString_in_helper(obj1);
12990 if (arg2 == NULL) SWIG_fail;
12991 temp2 = true;
12992 }
12993 {
12994 PyThreadState* __tstate = wxPyBeginAllowThreads();
12995 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
12996
12997 wxPyEndAllowThreads(__tstate);
12998 if (PyErr_Occurred()) SWIG_fail;
12999 }
13000 {
13001 resultobj = SWIG_From_int((int)(result));
13002 }
13003 {
13004 if (temp2)
13005 delete arg2;
13006 }
13007 return resultobj;
13008 fail:
13009 {
13010 if (temp2)
13011 delete arg2;
13012 }
13013 return NULL;
13014 }
13015
13016
13017 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13018 PyObject *resultobj;
13019 wxImage *arg1 = (wxImage *) 0 ;
13020 wxString *arg2 = 0 ;
13021 bool result;
13022 bool temp2 = false ;
13023 PyObject * obj0 = 0 ;
13024 PyObject * obj1 = 0 ;
13025 char *kwnames[] = {
13026 (char *) "self",(char *) "name", NULL
13027 };
13028
13029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13031 if (SWIG_arg_fail(1)) SWIG_fail;
13032 {
13033 arg2 = wxString_in_helper(obj1);
13034 if (arg2 == NULL) SWIG_fail;
13035 temp2 = true;
13036 }
13037 {
13038 PyThreadState* __tstate = wxPyBeginAllowThreads();
13039 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13040
13041 wxPyEndAllowThreads(__tstate);
13042 if (PyErr_Occurred()) SWIG_fail;
13043 }
13044 {
13045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13046 }
13047 {
13048 if (temp2)
13049 delete arg2;
13050 }
13051 return resultobj;
13052 fail:
13053 {
13054 if (temp2)
13055 delete arg2;
13056 }
13057 return NULL;
13058 }
13059
13060
13061 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13062 PyObject *resultobj;
13063 wxImage *arg1 = (wxImage *) 0 ;
13064 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13065 unsigned long result;
13066 PyObject * obj0 = 0 ;
13067 PyObject * obj1 = 0 ;
13068 char *kwnames[] = {
13069 (char *) "self",(char *) "stopafter", NULL
13070 };
13071
13072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13074 if (SWIG_arg_fail(1)) SWIG_fail;
13075 if (obj1) {
13076 {
13077 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13078 if (SWIG_arg_fail(2)) SWIG_fail;
13079 }
13080 }
13081 {
13082 PyThreadState* __tstate = wxPyBeginAllowThreads();
13083 result = (unsigned long)(arg1)->CountColours(arg2);
13084
13085 wxPyEndAllowThreads(__tstate);
13086 if (PyErr_Occurred()) SWIG_fail;
13087 }
13088 {
13089 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13090 }
13091 return resultobj;
13092 fail:
13093 return NULL;
13094 }
13095
13096
13097 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13098 PyObject *resultobj;
13099 wxImage *arg1 = (wxImage *) 0 ;
13100 wxImageHistogram *arg2 = 0 ;
13101 unsigned long result;
13102 PyObject * obj0 = 0 ;
13103 PyObject * obj1 = 0 ;
13104 char *kwnames[] = {
13105 (char *) "self",(char *) "h", NULL
13106 };
13107
13108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13110 if (SWIG_arg_fail(1)) SWIG_fail;
13111 {
13112 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13113 if (SWIG_arg_fail(2)) SWIG_fail;
13114 if (arg2 == NULL) {
13115 SWIG_null_ref("wxImageHistogram");
13116 }
13117 if (SWIG_arg_fail(2)) SWIG_fail;
13118 }
13119 {
13120 PyThreadState* __tstate = wxPyBeginAllowThreads();
13121 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13122
13123 wxPyEndAllowThreads(__tstate);
13124 if (PyErr_Occurred()) SWIG_fail;
13125 }
13126 {
13127 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13128 }
13129 return resultobj;
13130 fail:
13131 return NULL;
13132 }
13133
13134
13135 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13136 PyObject *resultobj;
13137 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13138 PyObject * obj0 = 0 ;
13139 char *kwnames[] = {
13140 (char *) "handler", NULL
13141 };
13142
13143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13145 if (SWIG_arg_fail(1)) SWIG_fail;
13146 {
13147 PyThreadState* __tstate = wxPyBeginAllowThreads();
13148 wxImage::AddHandler(arg1);
13149
13150 wxPyEndAllowThreads(__tstate);
13151 if (PyErr_Occurred()) SWIG_fail;
13152 }
13153 Py_INCREF(Py_None); resultobj = Py_None;
13154 return resultobj;
13155 fail:
13156 return NULL;
13157 }
13158
13159
13160 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13161 PyObject *resultobj;
13162 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13163 PyObject * obj0 = 0 ;
13164 char *kwnames[] = {
13165 (char *) "handler", NULL
13166 };
13167
13168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13169 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13170 if (SWIG_arg_fail(1)) SWIG_fail;
13171 {
13172 PyThreadState* __tstate = wxPyBeginAllowThreads();
13173 wxImage::InsertHandler(arg1);
13174
13175 wxPyEndAllowThreads(__tstate);
13176 if (PyErr_Occurred()) SWIG_fail;
13177 }
13178 Py_INCREF(Py_None); resultobj = Py_None;
13179 return resultobj;
13180 fail:
13181 return NULL;
13182 }
13183
13184
13185 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13186 PyObject *resultobj;
13187 wxString *arg1 = 0 ;
13188 bool result;
13189 bool temp1 = false ;
13190 PyObject * obj0 = 0 ;
13191 char *kwnames[] = {
13192 (char *) "name", NULL
13193 };
13194
13195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13196 {
13197 arg1 = wxString_in_helper(obj0);
13198 if (arg1 == NULL) SWIG_fail;
13199 temp1 = true;
13200 }
13201 {
13202 PyThreadState* __tstate = wxPyBeginAllowThreads();
13203 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13204
13205 wxPyEndAllowThreads(__tstate);
13206 if (PyErr_Occurred()) SWIG_fail;
13207 }
13208 {
13209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13210 }
13211 {
13212 if (temp1)
13213 delete arg1;
13214 }
13215 return resultobj;
13216 fail:
13217 {
13218 if (temp1)
13219 delete arg1;
13220 }
13221 return NULL;
13222 }
13223
13224
13225 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13226 PyObject *resultobj;
13227 wxString result;
13228 char *kwnames[] = {
13229 NULL
13230 };
13231
13232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13233 {
13234 PyThreadState* __tstate = wxPyBeginAllowThreads();
13235 result = wxImage::GetImageExtWildcard();
13236
13237 wxPyEndAllowThreads(__tstate);
13238 if (PyErr_Occurred()) SWIG_fail;
13239 }
13240 {
13241 #if wxUSE_UNICODE
13242 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13243 #else
13244 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13245 #endif
13246 }
13247 return resultobj;
13248 fail:
13249 return NULL;
13250 }
13251
13252
13253 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13254 PyObject *resultobj;
13255 wxImage *arg1 = (wxImage *) 0 ;
13256 int arg2 = (int) -1 ;
13257 wxBitmap result;
13258 PyObject * obj0 = 0 ;
13259 PyObject * obj1 = 0 ;
13260 char *kwnames[] = {
13261 (char *) "self",(char *) "depth", NULL
13262 };
13263
13264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13266 if (SWIG_arg_fail(1)) SWIG_fail;
13267 if (obj1) {
13268 {
13269 arg2 = (int)(SWIG_As_int(obj1));
13270 if (SWIG_arg_fail(2)) SWIG_fail;
13271 }
13272 }
13273 {
13274 if (!wxPyCheckForApp()) SWIG_fail;
13275 PyThreadState* __tstate = wxPyBeginAllowThreads();
13276 result = wxImage_ConvertToBitmap(arg1,arg2);
13277
13278 wxPyEndAllowThreads(__tstate);
13279 if (PyErr_Occurred()) SWIG_fail;
13280 }
13281 {
13282 wxBitmap * resultptr;
13283 resultptr = new wxBitmap((wxBitmap &)(result));
13284 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13285 }
13286 return resultobj;
13287 fail:
13288 return NULL;
13289 }
13290
13291
13292 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13293 PyObject *resultobj;
13294 wxImage *arg1 = (wxImage *) 0 ;
13295 unsigned char arg2 ;
13296 unsigned char arg3 ;
13297 unsigned char arg4 ;
13298 wxBitmap result;
13299 PyObject * obj0 = 0 ;
13300 PyObject * obj1 = 0 ;
13301 PyObject * obj2 = 0 ;
13302 PyObject * obj3 = 0 ;
13303 char *kwnames[] = {
13304 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13305 };
13306
13307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13309 if (SWIG_arg_fail(1)) SWIG_fail;
13310 {
13311 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13312 if (SWIG_arg_fail(2)) SWIG_fail;
13313 }
13314 {
13315 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13316 if (SWIG_arg_fail(3)) SWIG_fail;
13317 }
13318 {
13319 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13320 if (SWIG_arg_fail(4)) SWIG_fail;
13321 }
13322 {
13323 if (!wxPyCheckForApp()) SWIG_fail;
13324 PyThreadState* __tstate = wxPyBeginAllowThreads();
13325 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13326
13327 wxPyEndAllowThreads(__tstate);
13328 if (PyErr_Occurred()) SWIG_fail;
13329 }
13330 {
13331 wxBitmap * resultptr;
13332 resultptr = new wxBitmap((wxBitmap &)(result));
13333 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13334 }
13335 return resultobj;
13336 fail:
13337 return NULL;
13338 }
13339
13340
13341 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13342 PyObject *obj;
13343 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13344 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13345 Py_INCREF(obj);
13346 return Py_BuildValue((char *)"");
13347 }
13348 static int _wrap_NullImage_set(PyObject *) {
13349 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13350 return 1;
13351 }
13352
13353
13354 static PyObject *_wrap_NullImage_get(void) {
13355 PyObject *pyobj;
13356
13357 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13358 return pyobj;
13359 }
13360
13361
13362 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13363 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13364 return 1;
13365 }
13366
13367
13368 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13369 PyObject *pyobj;
13370
13371 {
13372 #if wxUSE_UNICODE
13373 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13374 #else
13375 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13376 #endif
13377 }
13378 return pyobj;
13379 }
13380
13381
13382 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13383 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13384 return 1;
13385 }
13386
13387
13388 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13389 PyObject *pyobj;
13390
13391 {
13392 #if wxUSE_UNICODE
13393 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13394 #else
13395 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13396 #endif
13397 }
13398 return pyobj;
13399 }
13400
13401
13402 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13403 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13404 return 1;
13405 }
13406
13407
13408 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13409 PyObject *pyobj;
13410
13411 {
13412 #if wxUSE_UNICODE
13413 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13414 #else
13415 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13416 #endif
13417 }
13418 return pyobj;
13419 }
13420
13421
13422 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13423 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13424 return 1;
13425 }
13426
13427
13428 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13429 PyObject *pyobj;
13430
13431 {
13432 #if wxUSE_UNICODE
13433 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13434 #else
13435 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13436 #endif
13437 }
13438 return pyobj;
13439 }
13440
13441
13442 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13443 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13444 return 1;
13445 }
13446
13447
13448 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13449 PyObject *pyobj;
13450
13451 {
13452 #if wxUSE_UNICODE
13453 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13454 #else
13455 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13456 #endif
13457 }
13458 return pyobj;
13459 }
13460
13461
13462 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13463 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13464 return 1;
13465 }
13466
13467
13468 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13469 PyObject *pyobj;
13470
13471 {
13472 #if wxUSE_UNICODE
13473 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13474 #else
13475 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13476 #endif
13477 }
13478 return pyobj;
13479 }
13480
13481
13482 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13483 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13484 return 1;
13485 }
13486
13487
13488 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13489 PyObject *pyobj;
13490
13491 {
13492 #if wxUSE_UNICODE
13493 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13494 #else
13495 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13496 #endif
13497 }
13498 return pyobj;
13499 }
13500
13501
13502 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13503 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13504 return 1;
13505 }
13506
13507
13508 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13509 PyObject *pyobj;
13510
13511 {
13512 #if wxUSE_UNICODE
13513 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13514 #else
13515 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13516 #endif
13517 }
13518 return pyobj;
13519 }
13520
13521
13522 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
13523 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
13524 return 1;
13525 }
13526
13527
13528 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
13529 PyObject *pyobj;
13530
13531 {
13532 #if wxUSE_UNICODE
13533 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13534 #else
13535 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
13536 #endif
13537 }
13538 return pyobj;
13539 }
13540
13541
13542 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
13543 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
13544 return 1;
13545 }
13546
13547
13548 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
13549 PyObject *pyobj;
13550
13551 {
13552 #if wxUSE_UNICODE
13553 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13554 #else
13555 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
13556 #endif
13557 }
13558 return pyobj;
13559 }
13560
13561
13562 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
13563 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
13564 return 1;
13565 }
13566
13567
13568 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
13569 PyObject *pyobj;
13570
13571 {
13572 #if wxUSE_UNICODE
13573 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13574 #else
13575 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
13576 #endif
13577 }
13578 return pyobj;
13579 }
13580
13581
13582 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
13583 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
13584 return 1;
13585 }
13586
13587
13588 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
13589 PyObject *pyobj;
13590
13591 {
13592 #if wxUSE_UNICODE
13593 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13594 #else
13595 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
13596 #endif
13597 }
13598 return pyobj;
13599 }
13600
13601
13602 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13603 PyObject *resultobj;
13604 wxBMPHandler *result;
13605 char *kwnames[] = {
13606 NULL
13607 };
13608
13609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
13610 {
13611 PyThreadState* __tstate = wxPyBeginAllowThreads();
13612 result = (wxBMPHandler *)new wxBMPHandler();
13613
13614 wxPyEndAllowThreads(__tstate);
13615 if (PyErr_Occurred()) SWIG_fail;
13616 }
13617 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
13618 return resultobj;
13619 fail:
13620 return NULL;
13621 }
13622
13623
13624 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
13625 PyObject *obj;
13626 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13627 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
13628 Py_INCREF(obj);
13629 return Py_BuildValue((char *)"");
13630 }
13631 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13632 PyObject *resultobj;
13633 wxICOHandler *result;
13634 char *kwnames[] = {
13635 NULL
13636 };
13637
13638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
13639 {
13640 PyThreadState* __tstate = wxPyBeginAllowThreads();
13641 result = (wxICOHandler *)new wxICOHandler();
13642
13643 wxPyEndAllowThreads(__tstate);
13644 if (PyErr_Occurred()) SWIG_fail;
13645 }
13646 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
13647 return resultobj;
13648 fail:
13649 return NULL;
13650 }
13651
13652
13653 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
13654 PyObject *obj;
13655 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13656 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
13657 Py_INCREF(obj);
13658 return Py_BuildValue((char *)"");
13659 }
13660 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13661 PyObject *resultobj;
13662 wxCURHandler *result;
13663 char *kwnames[] = {
13664 NULL
13665 };
13666
13667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
13668 {
13669 PyThreadState* __tstate = wxPyBeginAllowThreads();
13670 result = (wxCURHandler *)new wxCURHandler();
13671
13672 wxPyEndAllowThreads(__tstate);
13673 if (PyErr_Occurred()) SWIG_fail;
13674 }
13675 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
13676 return resultobj;
13677 fail:
13678 return NULL;
13679 }
13680
13681
13682 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
13683 PyObject *obj;
13684 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13685 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
13686 Py_INCREF(obj);
13687 return Py_BuildValue((char *)"");
13688 }
13689 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13690 PyObject *resultobj;
13691 wxANIHandler *result;
13692 char *kwnames[] = {
13693 NULL
13694 };
13695
13696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
13697 {
13698 PyThreadState* __tstate = wxPyBeginAllowThreads();
13699 result = (wxANIHandler *)new wxANIHandler();
13700
13701 wxPyEndAllowThreads(__tstate);
13702 if (PyErr_Occurred()) SWIG_fail;
13703 }
13704 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
13705 return resultobj;
13706 fail:
13707 return NULL;
13708 }
13709
13710
13711 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
13712 PyObject *obj;
13713 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13714 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
13715 Py_INCREF(obj);
13716 return Py_BuildValue((char *)"");
13717 }
13718 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13719 PyObject *resultobj;
13720 wxPNGHandler *result;
13721 char *kwnames[] = {
13722 NULL
13723 };
13724
13725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
13726 {
13727 PyThreadState* __tstate = wxPyBeginAllowThreads();
13728 result = (wxPNGHandler *)new wxPNGHandler();
13729
13730 wxPyEndAllowThreads(__tstate);
13731 if (PyErr_Occurred()) SWIG_fail;
13732 }
13733 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
13734 return resultobj;
13735 fail:
13736 return NULL;
13737 }
13738
13739
13740 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
13741 PyObject *obj;
13742 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13743 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
13744 Py_INCREF(obj);
13745 return Py_BuildValue((char *)"");
13746 }
13747 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13748 PyObject *resultobj;
13749 wxGIFHandler *result;
13750 char *kwnames[] = {
13751 NULL
13752 };
13753
13754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
13755 {
13756 PyThreadState* __tstate = wxPyBeginAllowThreads();
13757 result = (wxGIFHandler *)new wxGIFHandler();
13758
13759 wxPyEndAllowThreads(__tstate);
13760 if (PyErr_Occurred()) SWIG_fail;
13761 }
13762 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
13763 return resultobj;
13764 fail:
13765 return NULL;
13766 }
13767
13768
13769 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
13770 PyObject *obj;
13771 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13772 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
13773 Py_INCREF(obj);
13774 return Py_BuildValue((char *)"");
13775 }
13776 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13777 PyObject *resultobj;
13778 wxPCXHandler *result;
13779 char *kwnames[] = {
13780 NULL
13781 };
13782
13783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
13784 {
13785 PyThreadState* __tstate = wxPyBeginAllowThreads();
13786 result = (wxPCXHandler *)new wxPCXHandler();
13787
13788 wxPyEndAllowThreads(__tstate);
13789 if (PyErr_Occurred()) SWIG_fail;
13790 }
13791 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
13792 return resultobj;
13793 fail:
13794 return NULL;
13795 }
13796
13797
13798 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
13799 PyObject *obj;
13800 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13801 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
13802 Py_INCREF(obj);
13803 return Py_BuildValue((char *)"");
13804 }
13805 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13806 PyObject *resultobj;
13807 wxJPEGHandler *result;
13808 char *kwnames[] = {
13809 NULL
13810 };
13811
13812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
13813 {
13814 PyThreadState* __tstate = wxPyBeginAllowThreads();
13815 result = (wxJPEGHandler *)new wxJPEGHandler();
13816
13817 wxPyEndAllowThreads(__tstate);
13818 if (PyErr_Occurred()) SWIG_fail;
13819 }
13820 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
13821 return resultobj;
13822 fail:
13823 return NULL;
13824 }
13825
13826
13827 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
13828 PyObject *obj;
13829 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13830 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
13831 Py_INCREF(obj);
13832 return Py_BuildValue((char *)"");
13833 }
13834 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13835 PyObject *resultobj;
13836 wxPNMHandler *result;
13837 char *kwnames[] = {
13838 NULL
13839 };
13840
13841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
13842 {
13843 PyThreadState* __tstate = wxPyBeginAllowThreads();
13844 result = (wxPNMHandler *)new wxPNMHandler();
13845
13846 wxPyEndAllowThreads(__tstate);
13847 if (PyErr_Occurred()) SWIG_fail;
13848 }
13849 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
13850 return resultobj;
13851 fail:
13852 return NULL;
13853 }
13854
13855
13856 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
13857 PyObject *obj;
13858 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13859 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
13860 Py_INCREF(obj);
13861 return Py_BuildValue((char *)"");
13862 }
13863 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13864 PyObject *resultobj;
13865 wxXPMHandler *result;
13866 char *kwnames[] = {
13867 NULL
13868 };
13869
13870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
13871 {
13872 PyThreadState* __tstate = wxPyBeginAllowThreads();
13873 result = (wxXPMHandler *)new wxXPMHandler();
13874
13875 wxPyEndAllowThreads(__tstate);
13876 if (PyErr_Occurred()) SWIG_fail;
13877 }
13878 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
13879 return resultobj;
13880 fail:
13881 return NULL;
13882 }
13883
13884
13885 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
13886 PyObject *obj;
13887 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13888 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
13889 Py_INCREF(obj);
13890 return Py_BuildValue((char *)"");
13891 }
13892 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13893 PyObject *resultobj;
13894 wxTIFFHandler *result;
13895 char *kwnames[] = {
13896 NULL
13897 };
13898
13899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
13900 {
13901 PyThreadState* __tstate = wxPyBeginAllowThreads();
13902 result = (wxTIFFHandler *)new wxTIFFHandler();
13903
13904 wxPyEndAllowThreads(__tstate);
13905 if (PyErr_Occurred()) SWIG_fail;
13906 }
13907 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
13908 return resultobj;
13909 fail:
13910 return NULL;
13911 }
13912
13913
13914 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
13915 PyObject *obj;
13916 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13917 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
13918 Py_INCREF(obj);
13919 return Py_BuildValue((char *)"");
13920 }
13921 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
13922 PyObject *resultobj;
13923 wxImage *arg1 = 0 ;
13924 wxImage *arg2 = 0 ;
13925 int arg3 = (int) 236 ;
13926 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
13927 bool result;
13928 PyObject * obj0 = 0 ;
13929 PyObject * obj1 = 0 ;
13930 PyObject * obj2 = 0 ;
13931 PyObject * obj3 = 0 ;
13932 char *kwnames[] = {
13933 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
13934 };
13935
13936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13937 {
13938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13939 if (SWIG_arg_fail(1)) SWIG_fail;
13940 if (arg1 == NULL) {
13941 SWIG_null_ref("wxImage");
13942 }
13943 if (SWIG_arg_fail(1)) SWIG_fail;
13944 }
13945 {
13946 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13947 if (SWIG_arg_fail(2)) SWIG_fail;
13948 if (arg2 == NULL) {
13949 SWIG_null_ref("wxImage");
13950 }
13951 if (SWIG_arg_fail(2)) SWIG_fail;
13952 }
13953 if (obj2) {
13954 {
13955 arg3 = (int)(SWIG_As_int(obj2));
13956 if (SWIG_arg_fail(3)) SWIG_fail;
13957 }
13958 }
13959 if (obj3) {
13960 {
13961 arg4 = (int)(SWIG_As_int(obj3));
13962 if (SWIG_arg_fail(4)) SWIG_fail;
13963 }
13964 }
13965 {
13966 PyThreadState* __tstate = wxPyBeginAllowThreads();
13967 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
13968
13969 wxPyEndAllowThreads(__tstate);
13970 if (PyErr_Occurred()) SWIG_fail;
13971 }
13972 {
13973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13974 }
13975 return resultobj;
13976 fail:
13977 return NULL;
13978 }
13979
13980
13981 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
13982 PyObject *obj;
13983 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13984 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
13985 Py_INCREF(obj);
13986 return Py_BuildValue((char *)"");
13987 }
13988 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13989 PyObject *resultobj;
13990 wxEvtHandler *result;
13991 char *kwnames[] = {
13992 NULL
13993 };
13994
13995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
13996 {
13997 PyThreadState* __tstate = wxPyBeginAllowThreads();
13998 result = (wxEvtHandler *)new wxEvtHandler();
13999
14000 wxPyEndAllowThreads(__tstate);
14001 if (PyErr_Occurred()) SWIG_fail;
14002 }
14003 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14004 return resultobj;
14005 fail:
14006 return NULL;
14007 }
14008
14009
14010 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14011 PyObject *resultobj;
14012 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14013 wxEvtHandler *result;
14014 PyObject * obj0 = 0 ;
14015 char *kwnames[] = {
14016 (char *) "self", NULL
14017 };
14018
14019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14021 if (SWIG_arg_fail(1)) SWIG_fail;
14022 {
14023 PyThreadState* __tstate = wxPyBeginAllowThreads();
14024 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14025
14026 wxPyEndAllowThreads(__tstate);
14027 if (PyErr_Occurred()) SWIG_fail;
14028 }
14029 {
14030 resultobj = wxPyMake_wxObject(result, 0);
14031 }
14032 return resultobj;
14033 fail:
14034 return NULL;
14035 }
14036
14037
14038 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14039 PyObject *resultobj;
14040 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14041 wxEvtHandler *result;
14042 PyObject * obj0 = 0 ;
14043 char *kwnames[] = {
14044 (char *) "self", NULL
14045 };
14046
14047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14049 if (SWIG_arg_fail(1)) SWIG_fail;
14050 {
14051 PyThreadState* __tstate = wxPyBeginAllowThreads();
14052 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14053
14054 wxPyEndAllowThreads(__tstate);
14055 if (PyErr_Occurred()) SWIG_fail;
14056 }
14057 {
14058 resultobj = wxPyMake_wxObject(result, 0);
14059 }
14060 return resultobj;
14061 fail:
14062 return NULL;
14063 }
14064
14065
14066 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14067 PyObject *resultobj;
14068 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14069 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14070 PyObject * obj0 = 0 ;
14071 PyObject * obj1 = 0 ;
14072 char *kwnames[] = {
14073 (char *) "self",(char *) "handler", NULL
14074 };
14075
14076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14078 if (SWIG_arg_fail(1)) SWIG_fail;
14079 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14080 if (SWIG_arg_fail(2)) SWIG_fail;
14081 {
14082 PyThreadState* __tstate = wxPyBeginAllowThreads();
14083 (arg1)->SetNextHandler(arg2);
14084
14085 wxPyEndAllowThreads(__tstate);
14086 if (PyErr_Occurred()) SWIG_fail;
14087 }
14088 Py_INCREF(Py_None); resultobj = Py_None;
14089 return resultobj;
14090 fail:
14091 return NULL;
14092 }
14093
14094
14095 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14096 PyObject *resultobj;
14097 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14098 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14099 PyObject * obj0 = 0 ;
14100 PyObject * obj1 = 0 ;
14101 char *kwnames[] = {
14102 (char *) "self",(char *) "handler", NULL
14103 };
14104
14105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14107 if (SWIG_arg_fail(1)) SWIG_fail;
14108 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14109 if (SWIG_arg_fail(2)) SWIG_fail;
14110 {
14111 PyThreadState* __tstate = wxPyBeginAllowThreads();
14112 (arg1)->SetPreviousHandler(arg2);
14113
14114 wxPyEndAllowThreads(__tstate);
14115 if (PyErr_Occurred()) SWIG_fail;
14116 }
14117 Py_INCREF(Py_None); resultobj = Py_None;
14118 return resultobj;
14119 fail:
14120 return NULL;
14121 }
14122
14123
14124 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14125 PyObject *resultobj;
14126 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14127 bool result;
14128 PyObject * obj0 = 0 ;
14129 char *kwnames[] = {
14130 (char *) "self", NULL
14131 };
14132
14133 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14134 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14135 if (SWIG_arg_fail(1)) SWIG_fail;
14136 {
14137 PyThreadState* __tstate = wxPyBeginAllowThreads();
14138 result = (bool)(arg1)->GetEvtHandlerEnabled();
14139
14140 wxPyEndAllowThreads(__tstate);
14141 if (PyErr_Occurred()) SWIG_fail;
14142 }
14143 {
14144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14145 }
14146 return resultobj;
14147 fail:
14148 return NULL;
14149 }
14150
14151
14152 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14153 PyObject *resultobj;
14154 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14155 bool arg2 ;
14156 PyObject * obj0 = 0 ;
14157 PyObject * obj1 = 0 ;
14158 char *kwnames[] = {
14159 (char *) "self",(char *) "enabled", NULL
14160 };
14161
14162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14164 if (SWIG_arg_fail(1)) SWIG_fail;
14165 {
14166 arg2 = (bool)(SWIG_As_bool(obj1));
14167 if (SWIG_arg_fail(2)) SWIG_fail;
14168 }
14169 {
14170 PyThreadState* __tstate = wxPyBeginAllowThreads();
14171 (arg1)->SetEvtHandlerEnabled(arg2);
14172
14173 wxPyEndAllowThreads(__tstate);
14174 if (PyErr_Occurred()) SWIG_fail;
14175 }
14176 Py_INCREF(Py_None); resultobj = Py_None;
14177 return resultobj;
14178 fail:
14179 return NULL;
14180 }
14181
14182
14183 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14184 PyObject *resultobj;
14185 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14186 wxEvent *arg2 = 0 ;
14187 bool result;
14188 PyObject * obj0 = 0 ;
14189 PyObject * obj1 = 0 ;
14190 char *kwnames[] = {
14191 (char *) "self",(char *) "event", NULL
14192 };
14193
14194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14196 if (SWIG_arg_fail(1)) SWIG_fail;
14197 {
14198 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14199 if (SWIG_arg_fail(2)) SWIG_fail;
14200 if (arg2 == NULL) {
14201 SWIG_null_ref("wxEvent");
14202 }
14203 if (SWIG_arg_fail(2)) SWIG_fail;
14204 }
14205 {
14206 PyThreadState* __tstate = wxPyBeginAllowThreads();
14207 result = (bool)(arg1)->ProcessEvent(*arg2);
14208
14209 wxPyEndAllowThreads(__tstate);
14210 if (PyErr_Occurred()) SWIG_fail;
14211 }
14212 {
14213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14214 }
14215 return resultobj;
14216 fail:
14217 return NULL;
14218 }
14219
14220
14221 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14222 PyObject *resultobj;
14223 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14224 wxEvent *arg2 = 0 ;
14225 PyObject * obj0 = 0 ;
14226 PyObject * obj1 = 0 ;
14227 char *kwnames[] = {
14228 (char *) "self",(char *) "event", NULL
14229 };
14230
14231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14233 if (SWIG_arg_fail(1)) SWIG_fail;
14234 {
14235 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14236 if (SWIG_arg_fail(2)) SWIG_fail;
14237 if (arg2 == NULL) {
14238 SWIG_null_ref("wxEvent");
14239 }
14240 if (SWIG_arg_fail(2)) SWIG_fail;
14241 }
14242 {
14243 PyThreadState* __tstate = wxPyBeginAllowThreads();
14244 (arg1)->AddPendingEvent(*arg2);
14245
14246 wxPyEndAllowThreads(__tstate);
14247 if (PyErr_Occurred()) SWIG_fail;
14248 }
14249 Py_INCREF(Py_None); resultobj = Py_None;
14250 return resultobj;
14251 fail:
14252 return NULL;
14253 }
14254
14255
14256 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14257 PyObject *resultobj;
14258 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14259 PyObject * obj0 = 0 ;
14260 char *kwnames[] = {
14261 (char *) "self", NULL
14262 };
14263
14264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14266 if (SWIG_arg_fail(1)) SWIG_fail;
14267 {
14268 PyThreadState* __tstate = wxPyBeginAllowThreads();
14269 (arg1)->ProcessPendingEvents();
14270
14271 wxPyEndAllowThreads(__tstate);
14272 if (PyErr_Occurred()) SWIG_fail;
14273 }
14274 Py_INCREF(Py_None); resultobj = Py_None;
14275 return resultobj;
14276 fail:
14277 return NULL;
14278 }
14279
14280
14281 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14282 PyObject *resultobj;
14283 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14284 int arg2 ;
14285 int arg3 ;
14286 int arg4 ;
14287 PyObject *arg5 = (PyObject *) 0 ;
14288 PyObject * obj0 = 0 ;
14289 PyObject * obj1 = 0 ;
14290 PyObject * obj2 = 0 ;
14291 PyObject * obj3 = 0 ;
14292 PyObject * obj4 = 0 ;
14293 char *kwnames[] = {
14294 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14295 };
14296
14297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14299 if (SWIG_arg_fail(1)) SWIG_fail;
14300 {
14301 arg2 = (int)(SWIG_As_int(obj1));
14302 if (SWIG_arg_fail(2)) SWIG_fail;
14303 }
14304 {
14305 arg3 = (int)(SWIG_As_int(obj2));
14306 if (SWIG_arg_fail(3)) SWIG_fail;
14307 }
14308 {
14309 arg4 = (int)(SWIG_As_int(obj3));
14310 if (SWIG_arg_fail(4)) SWIG_fail;
14311 }
14312 arg5 = obj4;
14313 {
14314 PyThreadState* __tstate = wxPyBeginAllowThreads();
14315 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14316
14317 wxPyEndAllowThreads(__tstate);
14318 if (PyErr_Occurred()) SWIG_fail;
14319 }
14320 Py_INCREF(Py_None); resultobj = Py_None;
14321 return resultobj;
14322 fail:
14323 return NULL;
14324 }
14325
14326
14327 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14328 PyObject *resultobj;
14329 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14330 int arg2 ;
14331 int arg3 = (int) -1 ;
14332 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14333 bool result;
14334 PyObject * obj0 = 0 ;
14335 PyObject * obj1 = 0 ;
14336 PyObject * obj2 = 0 ;
14337 PyObject * obj3 = 0 ;
14338 char *kwnames[] = {
14339 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14340 };
14341
14342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14344 if (SWIG_arg_fail(1)) SWIG_fail;
14345 {
14346 arg2 = (int)(SWIG_As_int(obj1));
14347 if (SWIG_arg_fail(2)) SWIG_fail;
14348 }
14349 if (obj2) {
14350 {
14351 arg3 = (int)(SWIG_As_int(obj2));
14352 if (SWIG_arg_fail(3)) SWIG_fail;
14353 }
14354 }
14355 if (obj3) {
14356 {
14357 arg4 = (wxEventType)(SWIG_As_int(obj3));
14358 if (SWIG_arg_fail(4)) SWIG_fail;
14359 }
14360 }
14361 {
14362 PyThreadState* __tstate = wxPyBeginAllowThreads();
14363 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14364
14365 wxPyEndAllowThreads(__tstate);
14366 if (PyErr_Occurred()) SWIG_fail;
14367 }
14368 {
14369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14370 }
14371 return resultobj;
14372 fail:
14373 return NULL;
14374 }
14375
14376
14377 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14378 PyObject *resultobj;
14379 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14380 PyObject *arg2 = (PyObject *) 0 ;
14381 bool arg3 = (bool) true ;
14382 PyObject * obj0 = 0 ;
14383 PyObject * obj1 = 0 ;
14384 PyObject * obj2 = 0 ;
14385 char *kwnames[] = {
14386 (char *) "self",(char *) "_self",(char *) "incref", NULL
14387 };
14388
14389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14391 if (SWIG_arg_fail(1)) SWIG_fail;
14392 arg2 = obj1;
14393 if (obj2) {
14394 {
14395 arg3 = (bool)(SWIG_As_bool(obj2));
14396 if (SWIG_arg_fail(3)) SWIG_fail;
14397 }
14398 }
14399 {
14400 PyThreadState* __tstate = wxPyBeginAllowThreads();
14401 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14402
14403 wxPyEndAllowThreads(__tstate);
14404 if (PyErr_Occurred()) SWIG_fail;
14405 }
14406 Py_INCREF(Py_None); resultobj = Py_None;
14407 return resultobj;
14408 fail:
14409 return NULL;
14410 }
14411
14412
14413 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14414 PyObject *obj;
14415 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14416 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14417 Py_INCREF(obj);
14418 return Py_BuildValue((char *)"");
14419 }
14420 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14421 PyObject *resultobj;
14422 wxEventType result;
14423 char *kwnames[] = {
14424 NULL
14425 };
14426
14427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14428 {
14429 PyThreadState* __tstate = wxPyBeginAllowThreads();
14430 result = (wxEventType)wxNewEventType();
14431
14432 wxPyEndAllowThreads(__tstate);
14433 if (PyErr_Occurred()) SWIG_fail;
14434 }
14435 {
14436 resultobj = SWIG_From_int((int)(result));
14437 }
14438 return resultobj;
14439 fail:
14440 return NULL;
14441 }
14442
14443
14444 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14445 PyObject *resultobj;
14446 wxEvent *arg1 = (wxEvent *) 0 ;
14447 PyObject * obj0 = 0 ;
14448 char *kwnames[] = {
14449 (char *) "self", NULL
14450 };
14451
14452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14454 if (SWIG_arg_fail(1)) SWIG_fail;
14455 {
14456 PyThreadState* __tstate = wxPyBeginAllowThreads();
14457 delete arg1;
14458
14459 wxPyEndAllowThreads(__tstate);
14460 if (PyErr_Occurred()) SWIG_fail;
14461 }
14462 Py_INCREF(Py_None); resultobj = Py_None;
14463 return resultobj;
14464 fail:
14465 return NULL;
14466 }
14467
14468
14469 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14470 PyObject *resultobj;
14471 wxEvent *arg1 = (wxEvent *) 0 ;
14472 wxEventType arg2 ;
14473 PyObject * obj0 = 0 ;
14474 PyObject * obj1 = 0 ;
14475 char *kwnames[] = {
14476 (char *) "self",(char *) "typ", NULL
14477 };
14478
14479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
14480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14481 if (SWIG_arg_fail(1)) SWIG_fail;
14482 {
14483 arg2 = (wxEventType)(SWIG_As_int(obj1));
14484 if (SWIG_arg_fail(2)) SWIG_fail;
14485 }
14486 {
14487 PyThreadState* __tstate = wxPyBeginAllowThreads();
14488 (arg1)->SetEventType(arg2);
14489
14490 wxPyEndAllowThreads(__tstate);
14491 if (PyErr_Occurred()) SWIG_fail;
14492 }
14493 Py_INCREF(Py_None); resultobj = Py_None;
14494 return resultobj;
14495 fail:
14496 return NULL;
14497 }
14498
14499
14500 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14501 PyObject *resultobj;
14502 wxEvent *arg1 = (wxEvent *) 0 ;
14503 wxEventType result;
14504 PyObject * obj0 = 0 ;
14505 char *kwnames[] = {
14506 (char *) "self", NULL
14507 };
14508
14509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
14510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14511 if (SWIG_arg_fail(1)) SWIG_fail;
14512 {
14513 PyThreadState* __tstate = wxPyBeginAllowThreads();
14514 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
14515
14516 wxPyEndAllowThreads(__tstate);
14517 if (PyErr_Occurred()) SWIG_fail;
14518 }
14519 {
14520 resultobj = SWIG_From_int((int)(result));
14521 }
14522 return resultobj;
14523 fail:
14524 return NULL;
14525 }
14526
14527
14528 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14529 PyObject *resultobj;
14530 wxEvent *arg1 = (wxEvent *) 0 ;
14531 wxObject *result;
14532 PyObject * obj0 = 0 ;
14533 char *kwnames[] = {
14534 (char *) "self", NULL
14535 };
14536
14537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
14538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14539 if (SWIG_arg_fail(1)) SWIG_fail;
14540 {
14541 PyThreadState* __tstate = wxPyBeginAllowThreads();
14542 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
14543
14544 wxPyEndAllowThreads(__tstate);
14545 if (PyErr_Occurred()) SWIG_fail;
14546 }
14547 {
14548 resultobj = wxPyMake_wxObject(result, 0);
14549 }
14550 return resultobj;
14551 fail:
14552 return NULL;
14553 }
14554
14555
14556 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
14557 PyObject *resultobj;
14558 wxEvent *arg1 = (wxEvent *) 0 ;
14559 wxObject *arg2 = (wxObject *) 0 ;
14560 PyObject * obj0 = 0 ;
14561 PyObject * obj1 = 0 ;
14562 char *kwnames[] = {
14563 (char *) "self",(char *) "obj", NULL
14564 };
14565
14566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
14567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14568 if (SWIG_arg_fail(1)) SWIG_fail;
14569 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
14570 if (SWIG_arg_fail(2)) SWIG_fail;
14571 {
14572 PyThreadState* __tstate = wxPyBeginAllowThreads();
14573 (arg1)->SetEventObject(arg2);
14574
14575 wxPyEndAllowThreads(__tstate);
14576 if (PyErr_Occurred()) SWIG_fail;
14577 }
14578 Py_INCREF(Py_None); resultobj = Py_None;
14579 return resultobj;
14580 fail:
14581 return NULL;
14582 }
14583
14584
14585 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14586 PyObject *resultobj;
14587 wxEvent *arg1 = (wxEvent *) 0 ;
14588 long result;
14589 PyObject * obj0 = 0 ;
14590 char *kwnames[] = {
14591 (char *) "self", NULL
14592 };
14593
14594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
14595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14596 if (SWIG_arg_fail(1)) SWIG_fail;
14597 {
14598 PyThreadState* __tstate = wxPyBeginAllowThreads();
14599 result = (long)((wxEvent const *)arg1)->GetTimestamp();
14600
14601 wxPyEndAllowThreads(__tstate);
14602 if (PyErr_Occurred()) SWIG_fail;
14603 }
14604 {
14605 resultobj = SWIG_From_long((long)(result));
14606 }
14607 return resultobj;
14608 fail:
14609 return NULL;
14610 }
14611
14612
14613 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
14614 PyObject *resultobj;
14615 wxEvent *arg1 = (wxEvent *) 0 ;
14616 long arg2 = (long) 0 ;
14617 PyObject * obj0 = 0 ;
14618 PyObject * obj1 = 0 ;
14619 char *kwnames[] = {
14620 (char *) "self",(char *) "ts", NULL
14621 };
14622
14623 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
14624 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14625 if (SWIG_arg_fail(1)) SWIG_fail;
14626 if (obj1) {
14627 {
14628 arg2 = (long)(SWIG_As_long(obj1));
14629 if (SWIG_arg_fail(2)) SWIG_fail;
14630 }
14631 }
14632 {
14633 PyThreadState* __tstate = wxPyBeginAllowThreads();
14634 (arg1)->SetTimestamp(arg2);
14635
14636 wxPyEndAllowThreads(__tstate);
14637 if (PyErr_Occurred()) SWIG_fail;
14638 }
14639 Py_INCREF(Py_None); resultobj = Py_None;
14640 return resultobj;
14641 fail:
14642 return NULL;
14643 }
14644
14645
14646 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
14647 PyObject *resultobj;
14648 wxEvent *arg1 = (wxEvent *) 0 ;
14649 int result;
14650 PyObject * obj0 = 0 ;
14651 char *kwnames[] = {
14652 (char *) "self", NULL
14653 };
14654
14655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
14656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14657 if (SWIG_arg_fail(1)) SWIG_fail;
14658 {
14659 PyThreadState* __tstate = wxPyBeginAllowThreads();
14660 result = (int)((wxEvent const *)arg1)->GetId();
14661
14662 wxPyEndAllowThreads(__tstate);
14663 if (PyErr_Occurred()) SWIG_fail;
14664 }
14665 {
14666 resultobj = SWIG_From_int((int)(result));
14667 }
14668 return resultobj;
14669 fail:
14670 return NULL;
14671 }
14672
14673
14674 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
14675 PyObject *resultobj;
14676 wxEvent *arg1 = (wxEvent *) 0 ;
14677 int arg2 ;
14678 PyObject * obj0 = 0 ;
14679 PyObject * obj1 = 0 ;
14680 char *kwnames[] = {
14681 (char *) "self",(char *) "Id", NULL
14682 };
14683
14684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
14685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14686 if (SWIG_arg_fail(1)) SWIG_fail;
14687 {
14688 arg2 = (int)(SWIG_As_int(obj1));
14689 if (SWIG_arg_fail(2)) SWIG_fail;
14690 }
14691 {
14692 PyThreadState* __tstate = wxPyBeginAllowThreads();
14693 (arg1)->SetId(arg2);
14694
14695 wxPyEndAllowThreads(__tstate);
14696 if (PyErr_Occurred()) SWIG_fail;
14697 }
14698 Py_INCREF(Py_None); resultobj = Py_None;
14699 return resultobj;
14700 fail:
14701 return NULL;
14702 }
14703
14704
14705 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14706 PyObject *resultobj;
14707 wxEvent *arg1 = (wxEvent *) 0 ;
14708 bool result;
14709 PyObject * obj0 = 0 ;
14710 char *kwnames[] = {
14711 (char *) "self", NULL
14712 };
14713
14714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
14715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14716 if (SWIG_arg_fail(1)) SWIG_fail;
14717 {
14718 PyThreadState* __tstate = wxPyBeginAllowThreads();
14719 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
14720
14721 wxPyEndAllowThreads(__tstate);
14722 if (PyErr_Occurred()) SWIG_fail;
14723 }
14724 {
14725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14726 }
14727 return resultobj;
14728 fail:
14729 return NULL;
14730 }
14731
14732
14733 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
14734 PyObject *resultobj;
14735 wxEvent *arg1 = (wxEvent *) 0 ;
14736 bool arg2 = (bool) true ;
14737 PyObject * obj0 = 0 ;
14738 PyObject * obj1 = 0 ;
14739 char *kwnames[] = {
14740 (char *) "self",(char *) "skip", NULL
14741 };
14742
14743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
14744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14745 if (SWIG_arg_fail(1)) SWIG_fail;
14746 if (obj1) {
14747 {
14748 arg2 = (bool)(SWIG_As_bool(obj1));
14749 if (SWIG_arg_fail(2)) SWIG_fail;
14750 }
14751 }
14752 {
14753 PyThreadState* __tstate = wxPyBeginAllowThreads();
14754 (arg1)->Skip(arg2);
14755
14756 wxPyEndAllowThreads(__tstate);
14757 if (PyErr_Occurred()) SWIG_fail;
14758 }
14759 Py_INCREF(Py_None); resultobj = Py_None;
14760 return resultobj;
14761 fail:
14762 return NULL;
14763 }
14764
14765
14766 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
14767 PyObject *resultobj;
14768 wxEvent *arg1 = (wxEvent *) 0 ;
14769 bool result;
14770 PyObject * obj0 = 0 ;
14771 char *kwnames[] = {
14772 (char *) "self", NULL
14773 };
14774
14775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
14776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14777 if (SWIG_arg_fail(1)) SWIG_fail;
14778 {
14779 PyThreadState* __tstate = wxPyBeginAllowThreads();
14780 result = (bool)((wxEvent const *)arg1)->GetSkipped();
14781
14782 wxPyEndAllowThreads(__tstate);
14783 if (PyErr_Occurred()) SWIG_fail;
14784 }
14785 {
14786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14787 }
14788 return resultobj;
14789 fail:
14790 return NULL;
14791 }
14792
14793
14794 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
14795 PyObject *resultobj;
14796 wxEvent *arg1 = (wxEvent *) 0 ;
14797 bool result;
14798 PyObject * obj0 = 0 ;
14799 char *kwnames[] = {
14800 (char *) "self", NULL
14801 };
14802
14803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
14804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14805 if (SWIG_arg_fail(1)) SWIG_fail;
14806 {
14807 PyThreadState* __tstate = wxPyBeginAllowThreads();
14808 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
14809
14810 wxPyEndAllowThreads(__tstate);
14811 if (PyErr_Occurred()) SWIG_fail;
14812 }
14813 {
14814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14815 }
14816 return resultobj;
14817 fail:
14818 return NULL;
14819 }
14820
14821
14822 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14823 PyObject *resultobj;
14824 wxEvent *arg1 = (wxEvent *) 0 ;
14825 int result;
14826 PyObject * obj0 = 0 ;
14827 char *kwnames[] = {
14828 (char *) "self", NULL
14829 };
14830
14831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
14832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14833 if (SWIG_arg_fail(1)) SWIG_fail;
14834 {
14835 PyThreadState* __tstate = wxPyBeginAllowThreads();
14836 result = (int)(arg1)->StopPropagation();
14837
14838 wxPyEndAllowThreads(__tstate);
14839 if (PyErr_Occurred()) SWIG_fail;
14840 }
14841 {
14842 resultobj = SWIG_From_int((int)(result));
14843 }
14844 return resultobj;
14845 fail:
14846 return NULL;
14847 }
14848
14849
14850 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
14851 PyObject *resultobj;
14852 wxEvent *arg1 = (wxEvent *) 0 ;
14853 int arg2 ;
14854 PyObject * obj0 = 0 ;
14855 PyObject * obj1 = 0 ;
14856 char *kwnames[] = {
14857 (char *) "self",(char *) "propagationLevel", NULL
14858 };
14859
14860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
14861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14862 if (SWIG_arg_fail(1)) SWIG_fail;
14863 {
14864 arg2 = (int)(SWIG_As_int(obj1));
14865 if (SWIG_arg_fail(2)) SWIG_fail;
14866 }
14867 {
14868 PyThreadState* __tstate = wxPyBeginAllowThreads();
14869 (arg1)->ResumePropagation(arg2);
14870
14871 wxPyEndAllowThreads(__tstate);
14872 if (PyErr_Occurred()) SWIG_fail;
14873 }
14874 Py_INCREF(Py_None); resultobj = Py_None;
14875 return resultobj;
14876 fail:
14877 return NULL;
14878 }
14879
14880
14881 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
14882 PyObject *resultobj;
14883 wxEvent *arg1 = (wxEvent *) 0 ;
14884 wxEvent *result;
14885 PyObject * obj0 = 0 ;
14886 char *kwnames[] = {
14887 (char *) "self", NULL
14888 };
14889
14890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
14891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14892 if (SWIG_arg_fail(1)) SWIG_fail;
14893 {
14894 PyThreadState* __tstate = wxPyBeginAllowThreads();
14895 result = (wxEvent *)(arg1)->Clone();
14896
14897 wxPyEndAllowThreads(__tstate);
14898 if (PyErr_Occurred()) SWIG_fail;
14899 }
14900 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
14901 return resultobj;
14902 fail:
14903 return NULL;
14904 }
14905
14906
14907 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
14908 PyObject *obj;
14909 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14910 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
14911 Py_INCREF(obj);
14912 return Py_BuildValue((char *)"");
14913 }
14914 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14915 PyObject *resultobj;
14916 wxEvent *arg1 = 0 ;
14917 wxPropagationDisabler *result;
14918 PyObject * obj0 = 0 ;
14919 char *kwnames[] = {
14920 (char *) "event", NULL
14921 };
14922
14923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
14924 {
14925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14926 if (SWIG_arg_fail(1)) SWIG_fail;
14927 if (arg1 == NULL) {
14928 SWIG_null_ref("wxEvent");
14929 }
14930 if (SWIG_arg_fail(1)) SWIG_fail;
14931 }
14932 {
14933 PyThreadState* __tstate = wxPyBeginAllowThreads();
14934 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
14935
14936 wxPyEndAllowThreads(__tstate);
14937 if (PyErr_Occurred()) SWIG_fail;
14938 }
14939 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
14940 return resultobj;
14941 fail:
14942 return NULL;
14943 }
14944
14945
14946 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
14947 PyObject *resultobj;
14948 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
14949 PyObject * obj0 = 0 ;
14950 char *kwnames[] = {
14951 (char *) "self", NULL
14952 };
14953
14954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
14955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
14956 if (SWIG_arg_fail(1)) SWIG_fail;
14957 {
14958 PyThreadState* __tstate = wxPyBeginAllowThreads();
14959 delete arg1;
14960
14961 wxPyEndAllowThreads(__tstate);
14962 if (PyErr_Occurred()) SWIG_fail;
14963 }
14964 Py_INCREF(Py_None); resultobj = Py_None;
14965 return resultobj;
14966 fail:
14967 return NULL;
14968 }
14969
14970
14971 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
14972 PyObject *obj;
14973 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14974 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
14975 Py_INCREF(obj);
14976 return Py_BuildValue((char *)"");
14977 }
14978 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
14979 PyObject *resultobj;
14980 wxEvent *arg1 = 0 ;
14981 wxPropagateOnce *result;
14982 PyObject * obj0 = 0 ;
14983 char *kwnames[] = {
14984 (char *) "event", NULL
14985 };
14986
14987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
14988 {
14989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14990 if (SWIG_arg_fail(1)) SWIG_fail;
14991 if (arg1 == NULL) {
14992 SWIG_null_ref("wxEvent");
14993 }
14994 if (SWIG_arg_fail(1)) SWIG_fail;
14995 }
14996 {
14997 PyThreadState* __tstate = wxPyBeginAllowThreads();
14998 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
14999
15000 wxPyEndAllowThreads(__tstate);
15001 if (PyErr_Occurred()) SWIG_fail;
15002 }
15003 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15004 return resultobj;
15005 fail:
15006 return NULL;
15007 }
15008
15009
15010 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15011 PyObject *resultobj;
15012 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15013 PyObject * obj0 = 0 ;
15014 char *kwnames[] = {
15015 (char *) "self", NULL
15016 };
15017
15018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15020 if (SWIG_arg_fail(1)) SWIG_fail;
15021 {
15022 PyThreadState* __tstate = wxPyBeginAllowThreads();
15023 delete arg1;
15024
15025 wxPyEndAllowThreads(__tstate);
15026 if (PyErr_Occurred()) SWIG_fail;
15027 }
15028 Py_INCREF(Py_None); resultobj = Py_None;
15029 return resultobj;
15030 fail:
15031 return NULL;
15032 }
15033
15034
15035 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15036 PyObject *obj;
15037 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15038 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15039 Py_INCREF(obj);
15040 return Py_BuildValue((char *)"");
15041 }
15042 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15043 PyObject *resultobj;
15044 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15045 int arg2 = (int) 0 ;
15046 wxCommandEvent *result;
15047 PyObject * obj0 = 0 ;
15048 PyObject * obj1 = 0 ;
15049 char *kwnames[] = {
15050 (char *) "commandType",(char *) "winid", NULL
15051 };
15052
15053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15054 if (obj0) {
15055 {
15056 arg1 = (wxEventType)(SWIG_As_int(obj0));
15057 if (SWIG_arg_fail(1)) SWIG_fail;
15058 }
15059 }
15060 if (obj1) {
15061 {
15062 arg2 = (int)(SWIG_As_int(obj1));
15063 if (SWIG_arg_fail(2)) SWIG_fail;
15064 }
15065 }
15066 {
15067 PyThreadState* __tstate = wxPyBeginAllowThreads();
15068 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15069
15070 wxPyEndAllowThreads(__tstate);
15071 if (PyErr_Occurred()) SWIG_fail;
15072 }
15073 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15074 return resultobj;
15075 fail:
15076 return NULL;
15077 }
15078
15079
15080 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15081 PyObject *resultobj;
15082 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15083 int result;
15084 PyObject * obj0 = 0 ;
15085 char *kwnames[] = {
15086 (char *) "self", NULL
15087 };
15088
15089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15091 if (SWIG_arg_fail(1)) SWIG_fail;
15092 {
15093 PyThreadState* __tstate = wxPyBeginAllowThreads();
15094 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15095
15096 wxPyEndAllowThreads(__tstate);
15097 if (PyErr_Occurred()) SWIG_fail;
15098 }
15099 {
15100 resultobj = SWIG_From_int((int)(result));
15101 }
15102 return resultobj;
15103 fail:
15104 return NULL;
15105 }
15106
15107
15108 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15109 PyObject *resultobj;
15110 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15111 wxString *arg2 = 0 ;
15112 bool temp2 = false ;
15113 PyObject * obj0 = 0 ;
15114 PyObject * obj1 = 0 ;
15115 char *kwnames[] = {
15116 (char *) "self",(char *) "s", NULL
15117 };
15118
15119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15121 if (SWIG_arg_fail(1)) SWIG_fail;
15122 {
15123 arg2 = wxString_in_helper(obj1);
15124 if (arg2 == NULL) SWIG_fail;
15125 temp2 = true;
15126 }
15127 {
15128 PyThreadState* __tstate = wxPyBeginAllowThreads();
15129 (arg1)->SetString((wxString const &)*arg2);
15130
15131 wxPyEndAllowThreads(__tstate);
15132 if (PyErr_Occurred()) SWIG_fail;
15133 }
15134 Py_INCREF(Py_None); resultobj = Py_None;
15135 {
15136 if (temp2)
15137 delete arg2;
15138 }
15139 return resultobj;
15140 fail:
15141 {
15142 if (temp2)
15143 delete arg2;
15144 }
15145 return NULL;
15146 }
15147
15148
15149 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15150 PyObject *resultobj;
15151 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15152 wxString result;
15153 PyObject * obj0 = 0 ;
15154 char *kwnames[] = {
15155 (char *) "self", NULL
15156 };
15157
15158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15160 if (SWIG_arg_fail(1)) SWIG_fail;
15161 {
15162 PyThreadState* __tstate = wxPyBeginAllowThreads();
15163 result = ((wxCommandEvent const *)arg1)->GetString();
15164
15165 wxPyEndAllowThreads(__tstate);
15166 if (PyErr_Occurred()) SWIG_fail;
15167 }
15168 {
15169 #if wxUSE_UNICODE
15170 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15171 #else
15172 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15173 #endif
15174 }
15175 return resultobj;
15176 fail:
15177 return NULL;
15178 }
15179
15180
15181 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15182 PyObject *resultobj;
15183 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15184 bool result;
15185 PyObject * obj0 = 0 ;
15186 char *kwnames[] = {
15187 (char *) "self", NULL
15188 };
15189
15190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15192 if (SWIG_arg_fail(1)) SWIG_fail;
15193 {
15194 PyThreadState* __tstate = wxPyBeginAllowThreads();
15195 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15196
15197 wxPyEndAllowThreads(__tstate);
15198 if (PyErr_Occurred()) SWIG_fail;
15199 }
15200 {
15201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15202 }
15203 return resultobj;
15204 fail:
15205 return NULL;
15206 }
15207
15208
15209 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15210 PyObject *resultobj;
15211 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15212 bool result;
15213 PyObject * obj0 = 0 ;
15214 char *kwnames[] = {
15215 (char *) "self", NULL
15216 };
15217
15218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15220 if (SWIG_arg_fail(1)) SWIG_fail;
15221 {
15222 PyThreadState* __tstate = wxPyBeginAllowThreads();
15223 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15224
15225 wxPyEndAllowThreads(__tstate);
15226 if (PyErr_Occurred()) SWIG_fail;
15227 }
15228 {
15229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15230 }
15231 return resultobj;
15232 fail:
15233 return NULL;
15234 }
15235
15236
15237 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15238 PyObject *resultobj;
15239 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15240 long arg2 ;
15241 PyObject * obj0 = 0 ;
15242 PyObject * obj1 = 0 ;
15243 char *kwnames[] = {
15244 (char *) "self",(char *) "extraLong", NULL
15245 };
15246
15247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15249 if (SWIG_arg_fail(1)) SWIG_fail;
15250 {
15251 arg2 = (long)(SWIG_As_long(obj1));
15252 if (SWIG_arg_fail(2)) SWIG_fail;
15253 }
15254 {
15255 PyThreadState* __tstate = wxPyBeginAllowThreads();
15256 (arg1)->SetExtraLong(arg2);
15257
15258 wxPyEndAllowThreads(__tstate);
15259 if (PyErr_Occurred()) SWIG_fail;
15260 }
15261 Py_INCREF(Py_None); resultobj = Py_None;
15262 return resultobj;
15263 fail:
15264 return NULL;
15265 }
15266
15267
15268 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15269 PyObject *resultobj;
15270 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15271 long result;
15272 PyObject * obj0 = 0 ;
15273 char *kwnames[] = {
15274 (char *) "self", NULL
15275 };
15276
15277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15279 if (SWIG_arg_fail(1)) SWIG_fail;
15280 {
15281 PyThreadState* __tstate = wxPyBeginAllowThreads();
15282 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15283
15284 wxPyEndAllowThreads(__tstate);
15285 if (PyErr_Occurred()) SWIG_fail;
15286 }
15287 {
15288 resultobj = SWIG_From_long((long)(result));
15289 }
15290 return resultobj;
15291 fail:
15292 return NULL;
15293 }
15294
15295
15296 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15297 PyObject *resultobj;
15298 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15299 int arg2 ;
15300 PyObject * obj0 = 0 ;
15301 PyObject * obj1 = 0 ;
15302 char *kwnames[] = {
15303 (char *) "self",(char *) "i", NULL
15304 };
15305
15306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15308 if (SWIG_arg_fail(1)) SWIG_fail;
15309 {
15310 arg2 = (int)(SWIG_As_int(obj1));
15311 if (SWIG_arg_fail(2)) SWIG_fail;
15312 }
15313 {
15314 PyThreadState* __tstate = wxPyBeginAllowThreads();
15315 (arg1)->SetInt(arg2);
15316
15317 wxPyEndAllowThreads(__tstate);
15318 if (PyErr_Occurred()) SWIG_fail;
15319 }
15320 Py_INCREF(Py_None); resultobj = Py_None;
15321 return resultobj;
15322 fail:
15323 return NULL;
15324 }
15325
15326
15327 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15328 PyObject *resultobj;
15329 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15330 long result;
15331 PyObject * obj0 = 0 ;
15332 char *kwnames[] = {
15333 (char *) "self", NULL
15334 };
15335
15336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15338 if (SWIG_arg_fail(1)) SWIG_fail;
15339 {
15340 PyThreadState* __tstate = wxPyBeginAllowThreads();
15341 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15342
15343 wxPyEndAllowThreads(__tstate);
15344 if (PyErr_Occurred()) SWIG_fail;
15345 }
15346 {
15347 resultobj = SWIG_From_long((long)(result));
15348 }
15349 return resultobj;
15350 fail:
15351 return NULL;
15352 }
15353
15354
15355 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15356 PyObject *resultobj;
15357 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15358 wxEvent *result;
15359 PyObject * obj0 = 0 ;
15360 char *kwnames[] = {
15361 (char *) "self", NULL
15362 };
15363
15364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15366 if (SWIG_arg_fail(1)) SWIG_fail;
15367 {
15368 PyThreadState* __tstate = wxPyBeginAllowThreads();
15369 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15370
15371 wxPyEndAllowThreads(__tstate);
15372 if (PyErr_Occurred()) SWIG_fail;
15373 }
15374 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15375 return resultobj;
15376 fail:
15377 return NULL;
15378 }
15379
15380
15381 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15382 PyObject *obj;
15383 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15384 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15385 Py_INCREF(obj);
15386 return Py_BuildValue((char *)"");
15387 }
15388 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15389 PyObject *resultobj;
15390 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15391 int arg2 = (int) 0 ;
15392 wxNotifyEvent *result;
15393 PyObject * obj0 = 0 ;
15394 PyObject * obj1 = 0 ;
15395 char *kwnames[] = {
15396 (char *) "commandType",(char *) "winid", NULL
15397 };
15398
15399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15400 if (obj0) {
15401 {
15402 arg1 = (wxEventType)(SWIG_As_int(obj0));
15403 if (SWIG_arg_fail(1)) SWIG_fail;
15404 }
15405 }
15406 if (obj1) {
15407 {
15408 arg2 = (int)(SWIG_As_int(obj1));
15409 if (SWIG_arg_fail(2)) SWIG_fail;
15410 }
15411 }
15412 {
15413 PyThreadState* __tstate = wxPyBeginAllowThreads();
15414 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15415
15416 wxPyEndAllowThreads(__tstate);
15417 if (PyErr_Occurred()) SWIG_fail;
15418 }
15419 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15420 return resultobj;
15421 fail:
15422 return NULL;
15423 }
15424
15425
15426 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15427 PyObject *resultobj;
15428 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15429 PyObject * obj0 = 0 ;
15430 char *kwnames[] = {
15431 (char *) "self", NULL
15432 };
15433
15434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15436 if (SWIG_arg_fail(1)) SWIG_fail;
15437 {
15438 PyThreadState* __tstate = wxPyBeginAllowThreads();
15439 (arg1)->Veto();
15440
15441 wxPyEndAllowThreads(__tstate);
15442 if (PyErr_Occurred()) SWIG_fail;
15443 }
15444 Py_INCREF(Py_None); resultobj = Py_None;
15445 return resultobj;
15446 fail:
15447 return NULL;
15448 }
15449
15450
15451 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15452 PyObject *resultobj;
15453 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15454 PyObject * obj0 = 0 ;
15455 char *kwnames[] = {
15456 (char *) "self", NULL
15457 };
15458
15459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15461 if (SWIG_arg_fail(1)) SWIG_fail;
15462 {
15463 PyThreadState* __tstate = wxPyBeginAllowThreads();
15464 (arg1)->Allow();
15465
15466 wxPyEndAllowThreads(__tstate);
15467 if (PyErr_Occurred()) SWIG_fail;
15468 }
15469 Py_INCREF(Py_None); resultobj = Py_None;
15470 return resultobj;
15471 fail:
15472 return NULL;
15473 }
15474
15475
15476 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
15477 PyObject *resultobj;
15478 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15479 bool result;
15480 PyObject * obj0 = 0 ;
15481 char *kwnames[] = {
15482 (char *) "self", NULL
15483 };
15484
15485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
15486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15487 if (SWIG_arg_fail(1)) SWIG_fail;
15488 {
15489 PyThreadState* __tstate = wxPyBeginAllowThreads();
15490 result = (bool)(arg1)->IsAllowed();
15491
15492 wxPyEndAllowThreads(__tstate);
15493 if (PyErr_Occurred()) SWIG_fail;
15494 }
15495 {
15496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15497 }
15498 return resultobj;
15499 fail:
15500 return NULL;
15501 }
15502
15503
15504 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
15505 PyObject *obj;
15506 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15507 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
15508 Py_INCREF(obj);
15509 return Py_BuildValue((char *)"");
15510 }
15511 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15512 PyObject *resultobj;
15513 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15514 int arg2 = (int) 0 ;
15515 int arg3 = (int) 0 ;
15516 int arg4 = (int) 0 ;
15517 wxScrollEvent *result;
15518 PyObject * obj0 = 0 ;
15519 PyObject * obj1 = 0 ;
15520 PyObject * obj2 = 0 ;
15521 PyObject * obj3 = 0 ;
15522 char *kwnames[] = {
15523 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
15524 };
15525
15526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15527 if (obj0) {
15528 {
15529 arg1 = (wxEventType)(SWIG_As_int(obj0));
15530 if (SWIG_arg_fail(1)) SWIG_fail;
15531 }
15532 }
15533 if (obj1) {
15534 {
15535 arg2 = (int)(SWIG_As_int(obj1));
15536 if (SWIG_arg_fail(2)) SWIG_fail;
15537 }
15538 }
15539 if (obj2) {
15540 {
15541 arg3 = (int)(SWIG_As_int(obj2));
15542 if (SWIG_arg_fail(3)) SWIG_fail;
15543 }
15544 }
15545 if (obj3) {
15546 {
15547 arg4 = (int)(SWIG_As_int(obj3));
15548 if (SWIG_arg_fail(4)) SWIG_fail;
15549 }
15550 }
15551 {
15552 PyThreadState* __tstate = wxPyBeginAllowThreads();
15553 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
15554
15555 wxPyEndAllowThreads(__tstate);
15556 if (PyErr_Occurred()) SWIG_fail;
15557 }
15558 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
15559 return resultobj;
15560 fail:
15561 return NULL;
15562 }
15563
15564
15565 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15566 PyObject *resultobj;
15567 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15568 int result;
15569 PyObject * obj0 = 0 ;
15570 char *kwnames[] = {
15571 (char *) "self", NULL
15572 };
15573
15574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
15575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15576 if (SWIG_arg_fail(1)) SWIG_fail;
15577 {
15578 PyThreadState* __tstate = wxPyBeginAllowThreads();
15579 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
15580
15581 wxPyEndAllowThreads(__tstate);
15582 if (PyErr_Occurred()) SWIG_fail;
15583 }
15584 {
15585 resultobj = SWIG_From_int((int)(result));
15586 }
15587 return resultobj;
15588 fail:
15589 return NULL;
15590 }
15591
15592
15593 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15594 PyObject *resultobj;
15595 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15596 int result;
15597 PyObject * obj0 = 0 ;
15598 char *kwnames[] = {
15599 (char *) "self", NULL
15600 };
15601
15602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
15603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15604 if (SWIG_arg_fail(1)) SWIG_fail;
15605 {
15606 PyThreadState* __tstate = wxPyBeginAllowThreads();
15607 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
15608
15609 wxPyEndAllowThreads(__tstate);
15610 if (PyErr_Occurred()) SWIG_fail;
15611 }
15612 {
15613 resultobj = SWIG_From_int((int)(result));
15614 }
15615 return resultobj;
15616 fail:
15617 return NULL;
15618 }
15619
15620
15621 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15622 PyObject *resultobj;
15623 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15624 int arg2 ;
15625 PyObject * obj0 = 0 ;
15626 PyObject * obj1 = 0 ;
15627 char *kwnames[] = {
15628 (char *) "self",(char *) "orient", NULL
15629 };
15630
15631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15633 if (SWIG_arg_fail(1)) SWIG_fail;
15634 {
15635 arg2 = (int)(SWIG_As_int(obj1));
15636 if (SWIG_arg_fail(2)) SWIG_fail;
15637 }
15638 {
15639 PyThreadState* __tstate = wxPyBeginAllowThreads();
15640 (arg1)->SetOrientation(arg2);
15641
15642 wxPyEndAllowThreads(__tstate);
15643 if (PyErr_Occurred()) SWIG_fail;
15644 }
15645 Py_INCREF(Py_None); resultobj = Py_None;
15646 return resultobj;
15647 fail:
15648 return NULL;
15649 }
15650
15651
15652 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15653 PyObject *resultobj;
15654 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
15655 int arg2 ;
15656 PyObject * obj0 = 0 ;
15657 PyObject * obj1 = 0 ;
15658 char *kwnames[] = {
15659 (char *) "self",(char *) "pos", NULL
15660 };
15661
15662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
15664 if (SWIG_arg_fail(1)) SWIG_fail;
15665 {
15666 arg2 = (int)(SWIG_As_int(obj1));
15667 if (SWIG_arg_fail(2)) SWIG_fail;
15668 }
15669 {
15670 PyThreadState* __tstate = wxPyBeginAllowThreads();
15671 (arg1)->SetPosition(arg2);
15672
15673 wxPyEndAllowThreads(__tstate);
15674 if (PyErr_Occurred()) SWIG_fail;
15675 }
15676 Py_INCREF(Py_None); resultobj = Py_None;
15677 return resultobj;
15678 fail:
15679 return NULL;
15680 }
15681
15682
15683 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
15684 PyObject *obj;
15685 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15686 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
15687 Py_INCREF(obj);
15688 return Py_BuildValue((char *)"");
15689 }
15690 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15691 PyObject *resultobj;
15692 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15693 int arg2 = (int) 0 ;
15694 int arg3 = (int) 0 ;
15695 wxScrollWinEvent *result;
15696 PyObject * obj0 = 0 ;
15697 PyObject * obj1 = 0 ;
15698 PyObject * obj2 = 0 ;
15699 char *kwnames[] = {
15700 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
15701 };
15702
15703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
15704 if (obj0) {
15705 {
15706 arg1 = (wxEventType)(SWIG_As_int(obj0));
15707 if (SWIG_arg_fail(1)) SWIG_fail;
15708 }
15709 }
15710 if (obj1) {
15711 {
15712 arg2 = (int)(SWIG_As_int(obj1));
15713 if (SWIG_arg_fail(2)) SWIG_fail;
15714 }
15715 }
15716 if (obj2) {
15717 {
15718 arg3 = (int)(SWIG_As_int(obj2));
15719 if (SWIG_arg_fail(3)) SWIG_fail;
15720 }
15721 }
15722 {
15723 PyThreadState* __tstate = wxPyBeginAllowThreads();
15724 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
15725
15726 wxPyEndAllowThreads(__tstate);
15727 if (PyErr_Occurred()) SWIG_fail;
15728 }
15729 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
15730 return resultobj;
15731 fail:
15732 return NULL;
15733 }
15734
15735
15736 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15737 PyObject *resultobj;
15738 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15739 int result;
15740 PyObject * obj0 = 0 ;
15741 char *kwnames[] = {
15742 (char *) "self", NULL
15743 };
15744
15745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
15746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15747 if (SWIG_arg_fail(1)) SWIG_fail;
15748 {
15749 PyThreadState* __tstate = wxPyBeginAllowThreads();
15750 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
15751
15752 wxPyEndAllowThreads(__tstate);
15753 if (PyErr_Occurred()) SWIG_fail;
15754 }
15755 {
15756 resultobj = SWIG_From_int((int)(result));
15757 }
15758 return resultobj;
15759 fail:
15760 return NULL;
15761 }
15762
15763
15764 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15765 PyObject *resultobj;
15766 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15767 int result;
15768 PyObject * obj0 = 0 ;
15769 char *kwnames[] = {
15770 (char *) "self", NULL
15771 };
15772
15773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
15774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15775 if (SWIG_arg_fail(1)) SWIG_fail;
15776 {
15777 PyThreadState* __tstate = wxPyBeginAllowThreads();
15778 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
15779
15780 wxPyEndAllowThreads(__tstate);
15781 if (PyErr_Occurred()) SWIG_fail;
15782 }
15783 {
15784 resultobj = SWIG_From_int((int)(result));
15785 }
15786 return resultobj;
15787 fail:
15788 return NULL;
15789 }
15790
15791
15792 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
15793 PyObject *resultobj;
15794 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15795 int arg2 ;
15796 PyObject * obj0 = 0 ;
15797 PyObject * obj1 = 0 ;
15798 char *kwnames[] = {
15799 (char *) "self",(char *) "orient", NULL
15800 };
15801
15802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
15803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15804 if (SWIG_arg_fail(1)) SWIG_fail;
15805 {
15806 arg2 = (int)(SWIG_As_int(obj1));
15807 if (SWIG_arg_fail(2)) SWIG_fail;
15808 }
15809 {
15810 PyThreadState* __tstate = wxPyBeginAllowThreads();
15811 (arg1)->SetOrientation(arg2);
15812
15813 wxPyEndAllowThreads(__tstate);
15814 if (PyErr_Occurred()) SWIG_fail;
15815 }
15816 Py_INCREF(Py_None); resultobj = Py_None;
15817 return resultobj;
15818 fail:
15819 return NULL;
15820 }
15821
15822
15823 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
15824 PyObject *resultobj;
15825 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
15826 int arg2 ;
15827 PyObject * obj0 = 0 ;
15828 PyObject * obj1 = 0 ;
15829 char *kwnames[] = {
15830 (char *) "self",(char *) "pos", NULL
15831 };
15832
15833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
15834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
15835 if (SWIG_arg_fail(1)) SWIG_fail;
15836 {
15837 arg2 = (int)(SWIG_As_int(obj1));
15838 if (SWIG_arg_fail(2)) SWIG_fail;
15839 }
15840 {
15841 PyThreadState* __tstate = wxPyBeginAllowThreads();
15842 (arg1)->SetPosition(arg2);
15843
15844 wxPyEndAllowThreads(__tstate);
15845 if (PyErr_Occurred()) SWIG_fail;
15846 }
15847 Py_INCREF(Py_None); resultobj = Py_None;
15848 return resultobj;
15849 fail:
15850 return NULL;
15851 }
15852
15853
15854 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
15855 PyObject *obj;
15856 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15857 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
15858 Py_INCREF(obj);
15859 return Py_BuildValue((char *)"");
15860 }
15861 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15862 PyObject *resultobj;
15863 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15864 wxMouseEvent *result;
15865 PyObject * obj0 = 0 ;
15866 char *kwnames[] = {
15867 (char *) "mouseType", NULL
15868 };
15869
15870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
15871 if (obj0) {
15872 {
15873 arg1 = (wxEventType)(SWIG_As_int(obj0));
15874 if (SWIG_arg_fail(1)) SWIG_fail;
15875 }
15876 }
15877 {
15878 PyThreadState* __tstate = wxPyBeginAllowThreads();
15879 result = (wxMouseEvent *)new wxMouseEvent(arg1);
15880
15881 wxPyEndAllowThreads(__tstate);
15882 if (PyErr_Occurred()) SWIG_fail;
15883 }
15884 {
15885 resultobj = wxPyMake_wxObject(result, 1);
15886 }
15887 return resultobj;
15888 fail:
15889 return NULL;
15890 }
15891
15892
15893 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
15894 PyObject *resultobj;
15895 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15896 bool result;
15897 PyObject * obj0 = 0 ;
15898 char *kwnames[] = {
15899 (char *) "self", NULL
15900 };
15901
15902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
15903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15904 if (SWIG_arg_fail(1)) SWIG_fail;
15905 {
15906 PyThreadState* __tstate = wxPyBeginAllowThreads();
15907 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
15908
15909 wxPyEndAllowThreads(__tstate);
15910 if (PyErr_Occurred()) SWIG_fail;
15911 }
15912 {
15913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15914 }
15915 return resultobj;
15916 fail:
15917 return NULL;
15918 }
15919
15920
15921 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
15922 PyObject *resultobj;
15923 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15924 int arg2 = (int) wxMOUSE_BTN_ANY ;
15925 bool result;
15926 PyObject * obj0 = 0 ;
15927 PyObject * obj1 = 0 ;
15928 char *kwnames[] = {
15929 (char *) "self",(char *) "but", NULL
15930 };
15931
15932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
15933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15934 if (SWIG_arg_fail(1)) SWIG_fail;
15935 if (obj1) {
15936 {
15937 arg2 = (int)(SWIG_As_int(obj1));
15938 if (SWIG_arg_fail(2)) SWIG_fail;
15939 }
15940 }
15941 {
15942 PyThreadState* __tstate = wxPyBeginAllowThreads();
15943 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
15944
15945 wxPyEndAllowThreads(__tstate);
15946 if (PyErr_Occurred()) SWIG_fail;
15947 }
15948 {
15949 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15950 }
15951 return resultobj;
15952 fail:
15953 return NULL;
15954 }
15955
15956
15957 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
15958 PyObject *resultobj;
15959 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15960 int arg2 = (int) wxMOUSE_BTN_ANY ;
15961 bool result;
15962 PyObject * obj0 = 0 ;
15963 PyObject * obj1 = 0 ;
15964 char *kwnames[] = {
15965 (char *) "self",(char *) "but", NULL
15966 };
15967
15968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
15969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
15970 if (SWIG_arg_fail(1)) SWIG_fail;
15971 if (obj1) {
15972 {
15973 arg2 = (int)(SWIG_As_int(obj1));
15974 if (SWIG_arg_fail(2)) SWIG_fail;
15975 }
15976 }
15977 {
15978 PyThreadState* __tstate = wxPyBeginAllowThreads();
15979 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
15980
15981 wxPyEndAllowThreads(__tstate);
15982 if (PyErr_Occurred()) SWIG_fail;
15983 }
15984 {
15985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15986 }
15987 return resultobj;
15988 fail:
15989 return NULL;
15990 }
15991
15992
15993 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
15994 PyObject *resultobj;
15995 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
15996 int arg2 = (int) wxMOUSE_BTN_ANY ;
15997 bool result;
15998 PyObject * obj0 = 0 ;
15999 PyObject * obj1 = 0 ;
16000 char *kwnames[] = {
16001 (char *) "self",(char *) "but", NULL
16002 };
16003
16004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16006 if (SWIG_arg_fail(1)) SWIG_fail;
16007 if (obj1) {
16008 {
16009 arg2 = (int)(SWIG_As_int(obj1));
16010 if (SWIG_arg_fail(2)) SWIG_fail;
16011 }
16012 }
16013 {
16014 PyThreadState* __tstate = wxPyBeginAllowThreads();
16015 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16016
16017 wxPyEndAllowThreads(__tstate);
16018 if (PyErr_Occurred()) SWIG_fail;
16019 }
16020 {
16021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16022 }
16023 return resultobj;
16024 fail:
16025 return NULL;
16026 }
16027
16028
16029 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16030 PyObject *resultobj;
16031 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16032 int arg2 ;
16033 bool result;
16034 PyObject * obj0 = 0 ;
16035 PyObject * obj1 = 0 ;
16036 char *kwnames[] = {
16037 (char *) "self",(char *) "but", NULL
16038 };
16039
16040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16042 if (SWIG_arg_fail(1)) SWIG_fail;
16043 {
16044 arg2 = (int)(SWIG_As_int(obj1));
16045 if (SWIG_arg_fail(2)) SWIG_fail;
16046 }
16047 {
16048 PyThreadState* __tstate = wxPyBeginAllowThreads();
16049 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16050
16051 wxPyEndAllowThreads(__tstate);
16052 if (PyErr_Occurred()) SWIG_fail;
16053 }
16054 {
16055 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16056 }
16057 return resultobj;
16058 fail:
16059 return NULL;
16060 }
16061
16062
16063 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16064 PyObject *resultobj;
16065 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16066 int arg2 ;
16067 bool result;
16068 PyObject * obj0 = 0 ;
16069 PyObject * obj1 = 0 ;
16070 char *kwnames[] = {
16071 (char *) "self",(char *) "but", NULL
16072 };
16073
16074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16076 if (SWIG_arg_fail(1)) SWIG_fail;
16077 {
16078 arg2 = (int)(SWIG_As_int(obj1));
16079 if (SWIG_arg_fail(2)) SWIG_fail;
16080 }
16081 {
16082 PyThreadState* __tstate = wxPyBeginAllowThreads();
16083 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16084
16085 wxPyEndAllowThreads(__tstate);
16086 if (PyErr_Occurred()) SWIG_fail;
16087 }
16088 {
16089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16090 }
16091 return resultobj;
16092 fail:
16093 return NULL;
16094 }
16095
16096
16097 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16098 PyObject *resultobj;
16099 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16100 int result;
16101 PyObject * obj0 = 0 ;
16102 char *kwnames[] = {
16103 (char *) "self", NULL
16104 };
16105
16106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16108 if (SWIG_arg_fail(1)) SWIG_fail;
16109 {
16110 PyThreadState* __tstate = wxPyBeginAllowThreads();
16111 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16112
16113 wxPyEndAllowThreads(__tstate);
16114 if (PyErr_Occurred()) SWIG_fail;
16115 }
16116 {
16117 resultobj = SWIG_From_int((int)(result));
16118 }
16119 return resultobj;
16120 fail:
16121 return NULL;
16122 }
16123
16124
16125 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16126 PyObject *resultobj;
16127 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16128 bool result;
16129 PyObject * obj0 = 0 ;
16130 char *kwnames[] = {
16131 (char *) "self", NULL
16132 };
16133
16134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16136 if (SWIG_arg_fail(1)) SWIG_fail;
16137 {
16138 PyThreadState* __tstate = wxPyBeginAllowThreads();
16139 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16140
16141 wxPyEndAllowThreads(__tstate);
16142 if (PyErr_Occurred()) SWIG_fail;
16143 }
16144 {
16145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16146 }
16147 return resultobj;
16148 fail:
16149 return NULL;
16150 }
16151
16152
16153 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16154 PyObject *resultobj;
16155 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16156 bool result;
16157 PyObject * obj0 = 0 ;
16158 char *kwnames[] = {
16159 (char *) "self", NULL
16160 };
16161
16162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16164 if (SWIG_arg_fail(1)) SWIG_fail;
16165 {
16166 PyThreadState* __tstate = wxPyBeginAllowThreads();
16167 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16168
16169 wxPyEndAllowThreads(__tstate);
16170 if (PyErr_Occurred()) SWIG_fail;
16171 }
16172 {
16173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16174 }
16175 return resultobj;
16176 fail:
16177 return NULL;
16178 }
16179
16180
16181 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16182 PyObject *resultobj;
16183 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16184 bool result;
16185 PyObject * obj0 = 0 ;
16186 char *kwnames[] = {
16187 (char *) "self", NULL
16188 };
16189
16190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16192 if (SWIG_arg_fail(1)) SWIG_fail;
16193 {
16194 PyThreadState* __tstate = wxPyBeginAllowThreads();
16195 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16196
16197 wxPyEndAllowThreads(__tstate);
16198 if (PyErr_Occurred()) SWIG_fail;
16199 }
16200 {
16201 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16202 }
16203 return resultobj;
16204 fail:
16205 return NULL;
16206 }
16207
16208
16209 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16210 PyObject *resultobj;
16211 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16212 bool result;
16213 PyObject * obj0 = 0 ;
16214 char *kwnames[] = {
16215 (char *) "self", NULL
16216 };
16217
16218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16220 if (SWIG_arg_fail(1)) SWIG_fail;
16221 {
16222 PyThreadState* __tstate = wxPyBeginAllowThreads();
16223 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16224
16225 wxPyEndAllowThreads(__tstate);
16226 if (PyErr_Occurred()) SWIG_fail;
16227 }
16228 {
16229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16230 }
16231 return resultobj;
16232 fail:
16233 return NULL;
16234 }
16235
16236
16237 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16238 PyObject *resultobj;
16239 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16240 bool result;
16241 PyObject * obj0 = 0 ;
16242 char *kwnames[] = {
16243 (char *) "self", NULL
16244 };
16245
16246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16248 if (SWIG_arg_fail(1)) SWIG_fail;
16249 {
16250 PyThreadState* __tstate = wxPyBeginAllowThreads();
16251 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16252
16253 wxPyEndAllowThreads(__tstate);
16254 if (PyErr_Occurred()) SWIG_fail;
16255 }
16256 {
16257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16258 }
16259 return resultobj;
16260 fail:
16261 return NULL;
16262 }
16263
16264
16265 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16266 PyObject *resultobj;
16267 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16268 bool result;
16269 PyObject * obj0 = 0 ;
16270 char *kwnames[] = {
16271 (char *) "self", NULL
16272 };
16273
16274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16276 if (SWIG_arg_fail(1)) SWIG_fail;
16277 {
16278 PyThreadState* __tstate = wxPyBeginAllowThreads();
16279 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16280
16281 wxPyEndAllowThreads(__tstate);
16282 if (PyErr_Occurred()) SWIG_fail;
16283 }
16284 {
16285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16286 }
16287 return resultobj;
16288 fail:
16289 return NULL;
16290 }
16291
16292
16293 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16294 PyObject *resultobj;
16295 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16296 bool result;
16297 PyObject * obj0 = 0 ;
16298 char *kwnames[] = {
16299 (char *) "self", NULL
16300 };
16301
16302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16304 if (SWIG_arg_fail(1)) SWIG_fail;
16305 {
16306 PyThreadState* __tstate = wxPyBeginAllowThreads();
16307 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16308
16309 wxPyEndAllowThreads(__tstate);
16310 if (PyErr_Occurred()) SWIG_fail;
16311 }
16312 {
16313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16314 }
16315 return resultobj;
16316 fail:
16317 return NULL;
16318 }
16319
16320
16321 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16322 PyObject *resultobj;
16323 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16324 bool result;
16325 PyObject * obj0 = 0 ;
16326 char *kwnames[] = {
16327 (char *) "self", NULL
16328 };
16329
16330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16332 if (SWIG_arg_fail(1)) SWIG_fail;
16333 {
16334 PyThreadState* __tstate = wxPyBeginAllowThreads();
16335 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16336
16337 wxPyEndAllowThreads(__tstate);
16338 if (PyErr_Occurred()) SWIG_fail;
16339 }
16340 {
16341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16342 }
16343 return resultobj;
16344 fail:
16345 return NULL;
16346 }
16347
16348
16349 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16350 PyObject *resultobj;
16351 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16352 bool result;
16353 PyObject * obj0 = 0 ;
16354 char *kwnames[] = {
16355 (char *) "self", NULL
16356 };
16357
16358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16360 if (SWIG_arg_fail(1)) SWIG_fail;
16361 {
16362 PyThreadState* __tstate = wxPyBeginAllowThreads();
16363 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16364
16365 wxPyEndAllowThreads(__tstate);
16366 if (PyErr_Occurred()) SWIG_fail;
16367 }
16368 {
16369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16370 }
16371 return resultobj;
16372 fail:
16373 return NULL;
16374 }
16375
16376
16377 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16378 PyObject *resultobj;
16379 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16380 bool result;
16381 PyObject * obj0 = 0 ;
16382 char *kwnames[] = {
16383 (char *) "self", NULL
16384 };
16385
16386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16388 if (SWIG_arg_fail(1)) SWIG_fail;
16389 {
16390 PyThreadState* __tstate = wxPyBeginAllowThreads();
16391 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16392
16393 wxPyEndAllowThreads(__tstate);
16394 if (PyErr_Occurred()) SWIG_fail;
16395 }
16396 {
16397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16398 }
16399 return resultobj;
16400 fail:
16401 return NULL;
16402 }
16403
16404
16405 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16406 PyObject *resultobj;
16407 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16408 bool result;
16409 PyObject * obj0 = 0 ;
16410 char *kwnames[] = {
16411 (char *) "self", NULL
16412 };
16413
16414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16416 if (SWIG_arg_fail(1)) SWIG_fail;
16417 {
16418 PyThreadState* __tstate = wxPyBeginAllowThreads();
16419 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16420
16421 wxPyEndAllowThreads(__tstate);
16422 if (PyErr_Occurred()) SWIG_fail;
16423 }
16424 {
16425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16426 }
16427 return resultobj;
16428 fail:
16429 return NULL;
16430 }
16431
16432
16433 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16434 PyObject *resultobj;
16435 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16436 bool result;
16437 PyObject * obj0 = 0 ;
16438 char *kwnames[] = {
16439 (char *) "self", NULL
16440 };
16441
16442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16444 if (SWIG_arg_fail(1)) SWIG_fail;
16445 {
16446 PyThreadState* __tstate = wxPyBeginAllowThreads();
16447 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16448
16449 wxPyEndAllowThreads(__tstate);
16450 if (PyErr_Occurred()) SWIG_fail;
16451 }
16452 {
16453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16454 }
16455 return resultobj;
16456 fail:
16457 return NULL;
16458 }
16459
16460
16461 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16462 PyObject *resultobj;
16463 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16464 bool result;
16465 PyObject * obj0 = 0 ;
16466 char *kwnames[] = {
16467 (char *) "self", NULL
16468 };
16469
16470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
16471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16472 if (SWIG_arg_fail(1)) SWIG_fail;
16473 {
16474 PyThreadState* __tstate = wxPyBeginAllowThreads();
16475 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
16476
16477 wxPyEndAllowThreads(__tstate);
16478 if (PyErr_Occurred()) SWIG_fail;
16479 }
16480 {
16481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16482 }
16483 return resultobj;
16484 fail:
16485 return NULL;
16486 }
16487
16488
16489 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16490 PyObject *resultobj;
16491 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16492 bool result;
16493 PyObject * obj0 = 0 ;
16494 char *kwnames[] = {
16495 (char *) "self", NULL
16496 };
16497
16498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
16499 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16500 if (SWIG_arg_fail(1)) SWIG_fail;
16501 {
16502 PyThreadState* __tstate = wxPyBeginAllowThreads();
16503 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
16504
16505 wxPyEndAllowThreads(__tstate);
16506 if (PyErr_Occurred()) SWIG_fail;
16507 }
16508 {
16509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16510 }
16511 return resultobj;
16512 fail:
16513 return NULL;
16514 }
16515
16516
16517 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16518 PyObject *resultobj;
16519 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16520 bool result;
16521 PyObject * obj0 = 0 ;
16522 char *kwnames[] = {
16523 (char *) "self", NULL
16524 };
16525
16526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
16527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16528 if (SWIG_arg_fail(1)) SWIG_fail;
16529 {
16530 PyThreadState* __tstate = wxPyBeginAllowThreads();
16531 result = (bool)(arg1)->LeftIsDown();
16532
16533 wxPyEndAllowThreads(__tstate);
16534 if (PyErr_Occurred()) SWIG_fail;
16535 }
16536 {
16537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16538 }
16539 return resultobj;
16540 fail:
16541 return NULL;
16542 }
16543
16544
16545 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16546 PyObject *resultobj;
16547 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16548 bool result;
16549 PyObject * obj0 = 0 ;
16550 char *kwnames[] = {
16551 (char *) "self", NULL
16552 };
16553
16554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
16555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16556 if (SWIG_arg_fail(1)) SWIG_fail;
16557 {
16558 PyThreadState* __tstate = wxPyBeginAllowThreads();
16559 result = (bool)(arg1)->MiddleIsDown();
16560
16561 wxPyEndAllowThreads(__tstate);
16562 if (PyErr_Occurred()) SWIG_fail;
16563 }
16564 {
16565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16566 }
16567 return resultobj;
16568 fail:
16569 return NULL;
16570 }
16571
16572
16573 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16574 PyObject *resultobj;
16575 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16576 bool result;
16577 PyObject * obj0 = 0 ;
16578 char *kwnames[] = {
16579 (char *) "self", NULL
16580 };
16581
16582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
16583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16584 if (SWIG_arg_fail(1)) SWIG_fail;
16585 {
16586 PyThreadState* __tstate = wxPyBeginAllowThreads();
16587 result = (bool)(arg1)->RightIsDown();
16588
16589 wxPyEndAllowThreads(__tstate);
16590 if (PyErr_Occurred()) SWIG_fail;
16591 }
16592 {
16593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16594 }
16595 return resultobj;
16596 fail:
16597 return NULL;
16598 }
16599
16600
16601 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
16602 PyObject *resultobj;
16603 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16604 bool result;
16605 PyObject * obj0 = 0 ;
16606 char *kwnames[] = {
16607 (char *) "self", NULL
16608 };
16609
16610 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
16611 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16612 if (SWIG_arg_fail(1)) SWIG_fail;
16613 {
16614 PyThreadState* __tstate = wxPyBeginAllowThreads();
16615 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
16616
16617 wxPyEndAllowThreads(__tstate);
16618 if (PyErr_Occurred()) SWIG_fail;
16619 }
16620 {
16621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16622 }
16623 return resultobj;
16624 fail:
16625 return NULL;
16626 }
16627
16628
16629 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
16630 PyObject *resultobj;
16631 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16632 bool result;
16633 PyObject * obj0 = 0 ;
16634 char *kwnames[] = {
16635 (char *) "self", NULL
16636 };
16637
16638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
16639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16640 if (SWIG_arg_fail(1)) SWIG_fail;
16641 {
16642 PyThreadState* __tstate = wxPyBeginAllowThreads();
16643 result = (bool)((wxMouseEvent const *)arg1)->Moving();
16644
16645 wxPyEndAllowThreads(__tstate);
16646 if (PyErr_Occurred()) SWIG_fail;
16647 }
16648 {
16649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16650 }
16651 return resultobj;
16652 fail:
16653 return NULL;
16654 }
16655
16656
16657 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
16658 PyObject *resultobj;
16659 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16660 bool result;
16661 PyObject * obj0 = 0 ;
16662 char *kwnames[] = {
16663 (char *) "self", NULL
16664 };
16665
16666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
16667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16668 if (SWIG_arg_fail(1)) SWIG_fail;
16669 {
16670 PyThreadState* __tstate = wxPyBeginAllowThreads();
16671 result = (bool)((wxMouseEvent const *)arg1)->Entering();
16672
16673 wxPyEndAllowThreads(__tstate);
16674 if (PyErr_Occurred()) SWIG_fail;
16675 }
16676 {
16677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16678 }
16679 return resultobj;
16680 fail:
16681 return NULL;
16682 }
16683
16684
16685 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
16686 PyObject *resultobj;
16687 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16688 bool result;
16689 PyObject * obj0 = 0 ;
16690 char *kwnames[] = {
16691 (char *) "self", NULL
16692 };
16693
16694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
16695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16696 if (SWIG_arg_fail(1)) SWIG_fail;
16697 {
16698 PyThreadState* __tstate = wxPyBeginAllowThreads();
16699 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
16700
16701 wxPyEndAllowThreads(__tstate);
16702 if (PyErr_Occurred()) SWIG_fail;
16703 }
16704 {
16705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16706 }
16707 return resultobj;
16708 fail:
16709 return NULL;
16710 }
16711
16712
16713 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16714 PyObject *resultobj;
16715 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16716 wxPoint result;
16717 PyObject * obj0 = 0 ;
16718 char *kwnames[] = {
16719 (char *) "self", NULL
16720 };
16721
16722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
16723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16724 if (SWIG_arg_fail(1)) SWIG_fail;
16725 {
16726 PyThreadState* __tstate = wxPyBeginAllowThreads();
16727 result = (arg1)->GetPosition();
16728
16729 wxPyEndAllowThreads(__tstate);
16730 if (PyErr_Occurred()) SWIG_fail;
16731 }
16732 {
16733 wxPoint * resultptr;
16734 resultptr = new wxPoint((wxPoint &)(result));
16735 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16736 }
16737 return resultobj;
16738 fail:
16739 return NULL;
16740 }
16741
16742
16743 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
16744 PyObject *resultobj;
16745 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16746 long *arg2 = (long *) 0 ;
16747 long *arg3 = (long *) 0 ;
16748 long temp2 ;
16749 int res2 = 0 ;
16750 long temp3 ;
16751 int res3 = 0 ;
16752 PyObject * obj0 = 0 ;
16753 char *kwnames[] = {
16754 (char *) "self", NULL
16755 };
16756
16757 arg2 = &temp2; res2 = SWIG_NEWOBJ;
16758 arg3 = &temp3; res3 = SWIG_NEWOBJ;
16759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
16760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16761 if (SWIG_arg_fail(1)) SWIG_fail;
16762 {
16763 PyThreadState* __tstate = wxPyBeginAllowThreads();
16764 (arg1)->GetPosition(arg2,arg3);
16765
16766 wxPyEndAllowThreads(__tstate);
16767 if (PyErr_Occurred()) SWIG_fail;
16768 }
16769 Py_INCREF(Py_None); resultobj = Py_None;
16770 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
16771 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
16772 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
16773 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
16774 return resultobj;
16775 fail:
16776 return NULL;
16777 }
16778
16779
16780 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16781 PyObject *resultobj;
16782 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16783 wxDC *arg2 = 0 ;
16784 wxPoint result;
16785 PyObject * obj0 = 0 ;
16786 PyObject * obj1 = 0 ;
16787 char *kwnames[] = {
16788 (char *) "self",(char *) "dc", NULL
16789 };
16790
16791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
16792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16793 if (SWIG_arg_fail(1)) SWIG_fail;
16794 {
16795 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
16796 if (SWIG_arg_fail(2)) SWIG_fail;
16797 if (arg2 == NULL) {
16798 SWIG_null_ref("wxDC");
16799 }
16800 if (SWIG_arg_fail(2)) SWIG_fail;
16801 }
16802 {
16803 PyThreadState* __tstate = wxPyBeginAllowThreads();
16804 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
16805
16806 wxPyEndAllowThreads(__tstate);
16807 if (PyErr_Occurred()) SWIG_fail;
16808 }
16809 {
16810 wxPoint * resultptr;
16811 resultptr = new wxPoint((wxPoint &)(result));
16812 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
16813 }
16814 return resultobj;
16815 fail:
16816 return NULL;
16817 }
16818
16819
16820 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
16821 PyObject *resultobj;
16822 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16823 int result;
16824 PyObject * obj0 = 0 ;
16825 char *kwnames[] = {
16826 (char *) "self", NULL
16827 };
16828
16829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
16830 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16831 if (SWIG_arg_fail(1)) SWIG_fail;
16832 {
16833 PyThreadState* __tstate = wxPyBeginAllowThreads();
16834 result = (int)((wxMouseEvent const *)arg1)->GetX();
16835
16836 wxPyEndAllowThreads(__tstate);
16837 if (PyErr_Occurred()) SWIG_fail;
16838 }
16839 {
16840 resultobj = SWIG_From_int((int)(result));
16841 }
16842 return resultobj;
16843 fail:
16844 return NULL;
16845 }
16846
16847
16848 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
16849 PyObject *resultobj;
16850 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16851 int result;
16852 PyObject * obj0 = 0 ;
16853 char *kwnames[] = {
16854 (char *) "self", NULL
16855 };
16856
16857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
16858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16859 if (SWIG_arg_fail(1)) SWIG_fail;
16860 {
16861 PyThreadState* __tstate = wxPyBeginAllowThreads();
16862 result = (int)((wxMouseEvent const *)arg1)->GetY();
16863
16864 wxPyEndAllowThreads(__tstate);
16865 if (PyErr_Occurred()) SWIG_fail;
16866 }
16867 {
16868 resultobj = SWIG_From_int((int)(result));
16869 }
16870 return resultobj;
16871 fail:
16872 return NULL;
16873 }
16874
16875
16876 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
16877 PyObject *resultobj;
16878 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16879 int result;
16880 PyObject * obj0 = 0 ;
16881 char *kwnames[] = {
16882 (char *) "self", NULL
16883 };
16884
16885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
16886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16887 if (SWIG_arg_fail(1)) SWIG_fail;
16888 {
16889 PyThreadState* __tstate = wxPyBeginAllowThreads();
16890 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
16891
16892 wxPyEndAllowThreads(__tstate);
16893 if (PyErr_Occurred()) SWIG_fail;
16894 }
16895 {
16896 resultobj = SWIG_From_int((int)(result));
16897 }
16898 return resultobj;
16899 fail:
16900 return NULL;
16901 }
16902
16903
16904 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
16905 PyObject *resultobj;
16906 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16907 int result;
16908 PyObject * obj0 = 0 ;
16909 char *kwnames[] = {
16910 (char *) "self", NULL
16911 };
16912
16913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
16914 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16915 if (SWIG_arg_fail(1)) SWIG_fail;
16916 {
16917 PyThreadState* __tstate = wxPyBeginAllowThreads();
16918 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
16919
16920 wxPyEndAllowThreads(__tstate);
16921 if (PyErr_Occurred()) SWIG_fail;
16922 }
16923 {
16924 resultobj = SWIG_From_int((int)(result));
16925 }
16926 return resultobj;
16927 fail:
16928 return NULL;
16929 }
16930
16931
16932 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
16933 PyObject *resultobj;
16934 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16935 int result;
16936 PyObject * obj0 = 0 ;
16937 char *kwnames[] = {
16938 (char *) "self", NULL
16939 };
16940
16941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
16942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16943 if (SWIG_arg_fail(1)) SWIG_fail;
16944 {
16945 PyThreadState* __tstate = wxPyBeginAllowThreads();
16946 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
16947
16948 wxPyEndAllowThreads(__tstate);
16949 if (PyErr_Occurred()) SWIG_fail;
16950 }
16951 {
16952 resultobj = SWIG_From_int((int)(result));
16953 }
16954 return resultobj;
16955 fail:
16956 return NULL;
16957 }
16958
16959
16960 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
16961 PyObject *resultobj;
16962 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16963 bool result;
16964 PyObject * obj0 = 0 ;
16965 char *kwnames[] = {
16966 (char *) "self", NULL
16967 };
16968
16969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
16970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16971 if (SWIG_arg_fail(1)) SWIG_fail;
16972 {
16973 PyThreadState* __tstate = wxPyBeginAllowThreads();
16974 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
16975
16976 wxPyEndAllowThreads(__tstate);
16977 if (PyErr_Occurred()) SWIG_fail;
16978 }
16979 {
16980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16981 }
16982 return resultobj;
16983 fail:
16984 return NULL;
16985 }
16986
16987
16988 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
16989 PyObject *resultobj;
16990 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16991 int arg2 ;
16992 PyObject * obj0 = 0 ;
16993 PyObject * obj1 = 0 ;
16994 char *kwnames[] = {
16995 (char *) "self",(char *) "m_x", NULL
16996 };
16997
16998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
16999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17000 if (SWIG_arg_fail(1)) SWIG_fail;
17001 {
17002 arg2 = (int)(SWIG_As_int(obj1));
17003 if (SWIG_arg_fail(2)) SWIG_fail;
17004 }
17005 if (arg1) (arg1)->m_x = arg2;
17006
17007 Py_INCREF(Py_None); resultobj = Py_None;
17008 return resultobj;
17009 fail:
17010 return NULL;
17011 }
17012
17013
17014 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17015 PyObject *resultobj;
17016 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17017 int result;
17018 PyObject * obj0 = 0 ;
17019 char *kwnames[] = {
17020 (char *) "self", NULL
17021 };
17022
17023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17025 if (SWIG_arg_fail(1)) SWIG_fail;
17026 result = (int) ((arg1)->m_x);
17027
17028 {
17029 resultobj = SWIG_From_int((int)(result));
17030 }
17031 return resultobj;
17032 fail:
17033 return NULL;
17034 }
17035
17036
17037 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17038 PyObject *resultobj;
17039 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17040 int arg2 ;
17041 PyObject * obj0 = 0 ;
17042 PyObject * obj1 = 0 ;
17043 char *kwnames[] = {
17044 (char *) "self",(char *) "m_y", NULL
17045 };
17046
17047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17049 if (SWIG_arg_fail(1)) SWIG_fail;
17050 {
17051 arg2 = (int)(SWIG_As_int(obj1));
17052 if (SWIG_arg_fail(2)) SWIG_fail;
17053 }
17054 if (arg1) (arg1)->m_y = arg2;
17055
17056 Py_INCREF(Py_None); resultobj = Py_None;
17057 return resultobj;
17058 fail:
17059 return NULL;
17060 }
17061
17062
17063 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17064 PyObject *resultobj;
17065 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17066 int result;
17067 PyObject * obj0 = 0 ;
17068 char *kwnames[] = {
17069 (char *) "self", NULL
17070 };
17071
17072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17074 if (SWIG_arg_fail(1)) SWIG_fail;
17075 result = (int) ((arg1)->m_y);
17076
17077 {
17078 resultobj = SWIG_From_int((int)(result));
17079 }
17080 return resultobj;
17081 fail:
17082 return NULL;
17083 }
17084
17085
17086 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17087 PyObject *resultobj;
17088 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17089 bool arg2 ;
17090 PyObject * obj0 = 0 ;
17091 PyObject * obj1 = 0 ;
17092 char *kwnames[] = {
17093 (char *) "self",(char *) "m_leftDown", NULL
17094 };
17095
17096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17098 if (SWIG_arg_fail(1)) SWIG_fail;
17099 {
17100 arg2 = (bool)(SWIG_As_bool(obj1));
17101 if (SWIG_arg_fail(2)) SWIG_fail;
17102 }
17103 if (arg1) (arg1)->m_leftDown = arg2;
17104
17105 Py_INCREF(Py_None); resultobj = Py_None;
17106 return resultobj;
17107 fail:
17108 return NULL;
17109 }
17110
17111
17112 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17113 PyObject *resultobj;
17114 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17115 bool result;
17116 PyObject * obj0 = 0 ;
17117 char *kwnames[] = {
17118 (char *) "self", NULL
17119 };
17120
17121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17123 if (SWIG_arg_fail(1)) SWIG_fail;
17124 result = (bool) ((arg1)->m_leftDown);
17125
17126 {
17127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17128 }
17129 return resultobj;
17130 fail:
17131 return NULL;
17132 }
17133
17134
17135 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17136 PyObject *resultobj;
17137 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17138 bool arg2 ;
17139 PyObject * obj0 = 0 ;
17140 PyObject * obj1 = 0 ;
17141 char *kwnames[] = {
17142 (char *) "self",(char *) "m_middleDown", NULL
17143 };
17144
17145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17147 if (SWIG_arg_fail(1)) SWIG_fail;
17148 {
17149 arg2 = (bool)(SWIG_As_bool(obj1));
17150 if (SWIG_arg_fail(2)) SWIG_fail;
17151 }
17152 if (arg1) (arg1)->m_middleDown = arg2;
17153
17154 Py_INCREF(Py_None); resultobj = Py_None;
17155 return resultobj;
17156 fail:
17157 return NULL;
17158 }
17159
17160
17161 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17162 PyObject *resultobj;
17163 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17164 bool result;
17165 PyObject * obj0 = 0 ;
17166 char *kwnames[] = {
17167 (char *) "self", NULL
17168 };
17169
17170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17172 if (SWIG_arg_fail(1)) SWIG_fail;
17173 result = (bool) ((arg1)->m_middleDown);
17174
17175 {
17176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17177 }
17178 return resultobj;
17179 fail:
17180 return NULL;
17181 }
17182
17183
17184 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17185 PyObject *resultobj;
17186 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17187 bool arg2 ;
17188 PyObject * obj0 = 0 ;
17189 PyObject * obj1 = 0 ;
17190 char *kwnames[] = {
17191 (char *) "self",(char *) "m_rightDown", NULL
17192 };
17193
17194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17196 if (SWIG_arg_fail(1)) SWIG_fail;
17197 {
17198 arg2 = (bool)(SWIG_As_bool(obj1));
17199 if (SWIG_arg_fail(2)) SWIG_fail;
17200 }
17201 if (arg1) (arg1)->m_rightDown = arg2;
17202
17203 Py_INCREF(Py_None); resultobj = Py_None;
17204 return resultobj;
17205 fail:
17206 return NULL;
17207 }
17208
17209
17210 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17211 PyObject *resultobj;
17212 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17213 bool result;
17214 PyObject * obj0 = 0 ;
17215 char *kwnames[] = {
17216 (char *) "self", NULL
17217 };
17218
17219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17221 if (SWIG_arg_fail(1)) SWIG_fail;
17222 result = (bool) ((arg1)->m_rightDown);
17223
17224 {
17225 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17226 }
17227 return resultobj;
17228 fail:
17229 return NULL;
17230 }
17231
17232
17233 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17234 PyObject *resultobj;
17235 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17236 bool arg2 ;
17237 PyObject * obj0 = 0 ;
17238 PyObject * obj1 = 0 ;
17239 char *kwnames[] = {
17240 (char *) "self",(char *) "m_controlDown", NULL
17241 };
17242
17243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17245 if (SWIG_arg_fail(1)) SWIG_fail;
17246 {
17247 arg2 = (bool)(SWIG_As_bool(obj1));
17248 if (SWIG_arg_fail(2)) SWIG_fail;
17249 }
17250 if (arg1) (arg1)->m_controlDown = arg2;
17251
17252 Py_INCREF(Py_None); resultobj = Py_None;
17253 return resultobj;
17254 fail:
17255 return NULL;
17256 }
17257
17258
17259 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17260 PyObject *resultobj;
17261 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17262 bool result;
17263 PyObject * obj0 = 0 ;
17264 char *kwnames[] = {
17265 (char *) "self", NULL
17266 };
17267
17268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17270 if (SWIG_arg_fail(1)) SWIG_fail;
17271 result = (bool) ((arg1)->m_controlDown);
17272
17273 {
17274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17275 }
17276 return resultobj;
17277 fail:
17278 return NULL;
17279 }
17280
17281
17282 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17283 PyObject *resultobj;
17284 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17285 bool arg2 ;
17286 PyObject * obj0 = 0 ;
17287 PyObject * obj1 = 0 ;
17288 char *kwnames[] = {
17289 (char *) "self",(char *) "m_shiftDown", NULL
17290 };
17291
17292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17294 if (SWIG_arg_fail(1)) SWIG_fail;
17295 {
17296 arg2 = (bool)(SWIG_As_bool(obj1));
17297 if (SWIG_arg_fail(2)) SWIG_fail;
17298 }
17299 if (arg1) (arg1)->m_shiftDown = arg2;
17300
17301 Py_INCREF(Py_None); resultobj = Py_None;
17302 return resultobj;
17303 fail:
17304 return NULL;
17305 }
17306
17307
17308 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17309 PyObject *resultobj;
17310 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17311 bool result;
17312 PyObject * obj0 = 0 ;
17313 char *kwnames[] = {
17314 (char *) "self", NULL
17315 };
17316
17317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17319 if (SWIG_arg_fail(1)) SWIG_fail;
17320 result = (bool) ((arg1)->m_shiftDown);
17321
17322 {
17323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17324 }
17325 return resultobj;
17326 fail:
17327 return NULL;
17328 }
17329
17330
17331 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17332 PyObject *resultobj;
17333 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17334 bool arg2 ;
17335 PyObject * obj0 = 0 ;
17336 PyObject * obj1 = 0 ;
17337 char *kwnames[] = {
17338 (char *) "self",(char *) "m_altDown", NULL
17339 };
17340
17341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17343 if (SWIG_arg_fail(1)) SWIG_fail;
17344 {
17345 arg2 = (bool)(SWIG_As_bool(obj1));
17346 if (SWIG_arg_fail(2)) SWIG_fail;
17347 }
17348 if (arg1) (arg1)->m_altDown = arg2;
17349
17350 Py_INCREF(Py_None); resultobj = Py_None;
17351 return resultobj;
17352 fail:
17353 return NULL;
17354 }
17355
17356
17357 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17358 PyObject *resultobj;
17359 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17360 bool result;
17361 PyObject * obj0 = 0 ;
17362 char *kwnames[] = {
17363 (char *) "self", NULL
17364 };
17365
17366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17368 if (SWIG_arg_fail(1)) SWIG_fail;
17369 result = (bool) ((arg1)->m_altDown);
17370
17371 {
17372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17373 }
17374 return resultobj;
17375 fail:
17376 return NULL;
17377 }
17378
17379
17380 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17381 PyObject *resultobj;
17382 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17383 bool arg2 ;
17384 PyObject * obj0 = 0 ;
17385 PyObject * obj1 = 0 ;
17386 char *kwnames[] = {
17387 (char *) "self",(char *) "m_metaDown", NULL
17388 };
17389
17390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17392 if (SWIG_arg_fail(1)) SWIG_fail;
17393 {
17394 arg2 = (bool)(SWIG_As_bool(obj1));
17395 if (SWIG_arg_fail(2)) SWIG_fail;
17396 }
17397 if (arg1) (arg1)->m_metaDown = arg2;
17398
17399 Py_INCREF(Py_None); resultobj = Py_None;
17400 return resultobj;
17401 fail:
17402 return NULL;
17403 }
17404
17405
17406 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17407 PyObject *resultobj;
17408 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17409 bool result;
17410 PyObject * obj0 = 0 ;
17411 char *kwnames[] = {
17412 (char *) "self", NULL
17413 };
17414
17415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17417 if (SWIG_arg_fail(1)) SWIG_fail;
17418 result = (bool) ((arg1)->m_metaDown);
17419
17420 {
17421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17422 }
17423 return resultobj;
17424 fail:
17425 return NULL;
17426 }
17427
17428
17429 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17430 PyObject *resultobj;
17431 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17432 int arg2 ;
17433 PyObject * obj0 = 0 ;
17434 PyObject * obj1 = 0 ;
17435 char *kwnames[] = {
17436 (char *) "self",(char *) "m_wheelRotation", NULL
17437 };
17438
17439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17441 if (SWIG_arg_fail(1)) SWIG_fail;
17442 {
17443 arg2 = (int)(SWIG_As_int(obj1));
17444 if (SWIG_arg_fail(2)) SWIG_fail;
17445 }
17446 if (arg1) (arg1)->m_wheelRotation = arg2;
17447
17448 Py_INCREF(Py_None); resultobj = Py_None;
17449 return resultobj;
17450 fail:
17451 return NULL;
17452 }
17453
17454
17455 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17456 PyObject *resultobj;
17457 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17458 int result;
17459 PyObject * obj0 = 0 ;
17460 char *kwnames[] = {
17461 (char *) "self", NULL
17462 };
17463
17464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
17465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17466 if (SWIG_arg_fail(1)) SWIG_fail;
17467 result = (int) ((arg1)->m_wheelRotation);
17468
17469 {
17470 resultobj = SWIG_From_int((int)(result));
17471 }
17472 return resultobj;
17473 fail:
17474 return NULL;
17475 }
17476
17477
17478 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
17479 PyObject *resultobj;
17480 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17481 int arg2 ;
17482 PyObject * obj0 = 0 ;
17483 PyObject * obj1 = 0 ;
17484 char *kwnames[] = {
17485 (char *) "self",(char *) "m_wheelDelta", NULL
17486 };
17487
17488 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
17493 if (SWIG_arg_fail(2)) SWIG_fail;
17494 }
17495 if (arg1) (arg1)->m_wheelDelta = arg2;
17496
17497 Py_INCREF(Py_None); resultobj = Py_None;
17498 return resultobj;
17499 fail:
17500 return NULL;
17501 }
17502
17503
17504 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
17505 PyObject *resultobj;
17506 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17507 int result;
17508 PyObject * obj0 = 0 ;
17509 char *kwnames[] = {
17510 (char *) "self", NULL
17511 };
17512
17513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
17514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17515 if (SWIG_arg_fail(1)) SWIG_fail;
17516 result = (int) ((arg1)->m_wheelDelta);
17517
17518 {
17519 resultobj = SWIG_From_int((int)(result));
17520 }
17521 return resultobj;
17522 fail:
17523 return NULL;
17524 }
17525
17526
17527 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
17528 PyObject *resultobj;
17529 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17530 int arg2 ;
17531 PyObject * obj0 = 0 ;
17532 PyObject * obj1 = 0 ;
17533 char *kwnames[] = {
17534 (char *) "self",(char *) "m_linesPerAction", NULL
17535 };
17536
17537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
17538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17539 if (SWIG_arg_fail(1)) SWIG_fail;
17540 {
17541 arg2 = (int)(SWIG_As_int(obj1));
17542 if (SWIG_arg_fail(2)) SWIG_fail;
17543 }
17544 if (arg1) (arg1)->m_linesPerAction = arg2;
17545
17546 Py_INCREF(Py_None); resultobj = Py_None;
17547 return resultobj;
17548 fail:
17549 return NULL;
17550 }
17551
17552
17553 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
17554 PyObject *resultobj;
17555 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17556 int result;
17557 PyObject * obj0 = 0 ;
17558 char *kwnames[] = {
17559 (char *) "self", NULL
17560 };
17561
17562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
17563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17564 if (SWIG_arg_fail(1)) SWIG_fail;
17565 result = (int) ((arg1)->m_linesPerAction);
17566
17567 {
17568 resultobj = SWIG_From_int((int)(result));
17569 }
17570 return resultobj;
17571 fail:
17572 return NULL;
17573 }
17574
17575
17576 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
17577 PyObject *obj;
17578 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17579 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
17580 Py_INCREF(obj);
17581 return Py_BuildValue((char *)"");
17582 }
17583 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17584 PyObject *resultobj;
17585 int arg1 = (int) 0 ;
17586 int arg2 = (int) 0 ;
17587 wxSetCursorEvent *result;
17588 PyObject * obj0 = 0 ;
17589 PyObject * obj1 = 0 ;
17590 char *kwnames[] = {
17591 (char *) "x",(char *) "y", NULL
17592 };
17593
17594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
17595 if (obj0) {
17596 {
17597 arg1 = (int)(SWIG_As_int(obj0));
17598 if (SWIG_arg_fail(1)) SWIG_fail;
17599 }
17600 }
17601 if (obj1) {
17602 {
17603 arg2 = (int)(SWIG_As_int(obj1));
17604 if (SWIG_arg_fail(2)) SWIG_fail;
17605 }
17606 }
17607 {
17608 PyThreadState* __tstate = wxPyBeginAllowThreads();
17609 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
17610
17611 wxPyEndAllowThreads(__tstate);
17612 if (PyErr_Occurred()) SWIG_fail;
17613 }
17614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
17615 return resultobj;
17616 fail:
17617 return NULL;
17618 }
17619
17620
17621 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17622 PyObject *resultobj;
17623 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17624 int result;
17625 PyObject * obj0 = 0 ;
17626 char *kwnames[] = {
17627 (char *) "self", NULL
17628 };
17629
17630 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
17631 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17632 if (SWIG_arg_fail(1)) SWIG_fail;
17633 {
17634 PyThreadState* __tstate = wxPyBeginAllowThreads();
17635 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
17636
17637 wxPyEndAllowThreads(__tstate);
17638 if (PyErr_Occurred()) SWIG_fail;
17639 }
17640 {
17641 resultobj = SWIG_From_int((int)(result));
17642 }
17643 return resultobj;
17644 fail:
17645 return NULL;
17646 }
17647
17648
17649 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17650 PyObject *resultobj;
17651 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17652 int result;
17653 PyObject * obj0 = 0 ;
17654 char *kwnames[] = {
17655 (char *) "self", NULL
17656 };
17657
17658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
17659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17660 if (SWIG_arg_fail(1)) SWIG_fail;
17661 {
17662 PyThreadState* __tstate = wxPyBeginAllowThreads();
17663 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
17664
17665 wxPyEndAllowThreads(__tstate);
17666 if (PyErr_Occurred()) SWIG_fail;
17667 }
17668 {
17669 resultobj = SWIG_From_int((int)(result));
17670 }
17671 return resultobj;
17672 fail:
17673 return NULL;
17674 }
17675
17676
17677 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17678 PyObject *resultobj;
17679 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17680 wxCursor *arg2 = 0 ;
17681 PyObject * obj0 = 0 ;
17682 PyObject * obj1 = 0 ;
17683 char *kwnames[] = {
17684 (char *) "self",(char *) "cursor", NULL
17685 };
17686
17687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
17688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17689 if (SWIG_arg_fail(1)) SWIG_fail;
17690 {
17691 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
17692 if (SWIG_arg_fail(2)) SWIG_fail;
17693 if (arg2 == NULL) {
17694 SWIG_null_ref("wxCursor");
17695 }
17696 if (SWIG_arg_fail(2)) SWIG_fail;
17697 }
17698 {
17699 PyThreadState* __tstate = wxPyBeginAllowThreads();
17700 (arg1)->SetCursor((wxCursor const &)*arg2);
17701
17702 wxPyEndAllowThreads(__tstate);
17703 if (PyErr_Occurred()) SWIG_fail;
17704 }
17705 Py_INCREF(Py_None); resultobj = Py_None;
17706 return resultobj;
17707 fail:
17708 return NULL;
17709 }
17710
17711
17712 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17713 PyObject *resultobj;
17714 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17715 wxCursor *result;
17716 PyObject * obj0 = 0 ;
17717 char *kwnames[] = {
17718 (char *) "self", NULL
17719 };
17720
17721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
17722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17723 if (SWIG_arg_fail(1)) SWIG_fail;
17724 {
17725 PyThreadState* __tstate = wxPyBeginAllowThreads();
17726 {
17727 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
17728 result = (wxCursor *) &_result_ref;
17729 }
17730
17731 wxPyEndAllowThreads(__tstate);
17732 if (PyErr_Occurred()) SWIG_fail;
17733 }
17734 {
17735 wxCursor* resultptr = new wxCursor(*result);
17736 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
17737 }
17738 return resultobj;
17739 fail:
17740 return NULL;
17741 }
17742
17743
17744 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
17745 PyObject *resultobj;
17746 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
17747 bool result;
17748 PyObject * obj0 = 0 ;
17749 char *kwnames[] = {
17750 (char *) "self", NULL
17751 };
17752
17753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
17754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
17755 if (SWIG_arg_fail(1)) SWIG_fail;
17756 {
17757 PyThreadState* __tstate = wxPyBeginAllowThreads();
17758 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
17759
17760 wxPyEndAllowThreads(__tstate);
17761 if (PyErr_Occurred()) SWIG_fail;
17762 }
17763 {
17764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17765 }
17766 return resultobj;
17767 fail:
17768 return NULL;
17769 }
17770
17771
17772 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
17773 PyObject *obj;
17774 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
17775 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
17776 Py_INCREF(obj);
17777 return Py_BuildValue((char *)"");
17778 }
17779 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
17780 PyObject *resultobj;
17781 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
17782 wxKeyEvent *result;
17783 PyObject * obj0 = 0 ;
17784 char *kwnames[] = {
17785 (char *) "keyType", NULL
17786 };
17787
17788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
17789 if (obj0) {
17790 {
17791 arg1 = (wxEventType)(SWIG_As_int(obj0));
17792 if (SWIG_arg_fail(1)) SWIG_fail;
17793 }
17794 }
17795 {
17796 PyThreadState* __tstate = wxPyBeginAllowThreads();
17797 result = (wxKeyEvent *)new wxKeyEvent(arg1);
17798
17799 wxPyEndAllowThreads(__tstate);
17800 if (PyErr_Occurred()) SWIG_fail;
17801 }
17802 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
17803 return resultobj;
17804 fail:
17805 return NULL;
17806 }
17807
17808
17809 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17810 PyObject *resultobj;
17811 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17812 bool result;
17813 PyObject * obj0 = 0 ;
17814 char *kwnames[] = {
17815 (char *) "self", NULL
17816 };
17817
17818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
17819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17820 if (SWIG_arg_fail(1)) SWIG_fail;
17821 {
17822 PyThreadState* __tstate = wxPyBeginAllowThreads();
17823 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
17824
17825 wxPyEndAllowThreads(__tstate);
17826 if (PyErr_Occurred()) SWIG_fail;
17827 }
17828 {
17829 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17830 }
17831 return resultobj;
17832 fail:
17833 return NULL;
17834 }
17835
17836
17837 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17838 PyObject *resultobj;
17839 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17840 bool result;
17841 PyObject * obj0 = 0 ;
17842 char *kwnames[] = {
17843 (char *) "self", NULL
17844 };
17845
17846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
17847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17848 if (SWIG_arg_fail(1)) SWIG_fail;
17849 {
17850 PyThreadState* __tstate = wxPyBeginAllowThreads();
17851 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
17852
17853 wxPyEndAllowThreads(__tstate);
17854 if (PyErr_Occurred()) SWIG_fail;
17855 }
17856 {
17857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17858 }
17859 return resultobj;
17860 fail:
17861 return NULL;
17862 }
17863
17864
17865 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17866 PyObject *resultobj;
17867 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17868 bool result;
17869 PyObject * obj0 = 0 ;
17870 char *kwnames[] = {
17871 (char *) "self", NULL
17872 };
17873
17874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
17875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17876 if (SWIG_arg_fail(1)) SWIG_fail;
17877 {
17878 PyThreadState* __tstate = wxPyBeginAllowThreads();
17879 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
17880
17881 wxPyEndAllowThreads(__tstate);
17882 if (PyErr_Occurred()) SWIG_fail;
17883 }
17884 {
17885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17886 }
17887 return resultobj;
17888 fail:
17889 return NULL;
17890 }
17891
17892
17893 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17894 PyObject *resultobj;
17895 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17896 bool result;
17897 PyObject * obj0 = 0 ;
17898 char *kwnames[] = {
17899 (char *) "self", NULL
17900 };
17901
17902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
17903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17904 if (SWIG_arg_fail(1)) SWIG_fail;
17905 {
17906 PyThreadState* __tstate = wxPyBeginAllowThreads();
17907 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
17908
17909 wxPyEndAllowThreads(__tstate);
17910 if (PyErr_Occurred()) SWIG_fail;
17911 }
17912 {
17913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17914 }
17915 return resultobj;
17916 fail:
17917 return NULL;
17918 }
17919
17920
17921 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17922 PyObject *resultobj;
17923 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17924 bool result;
17925 PyObject * obj0 = 0 ;
17926 char *kwnames[] = {
17927 (char *) "self", NULL
17928 };
17929
17930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
17931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17932 if (SWIG_arg_fail(1)) SWIG_fail;
17933 {
17934 PyThreadState* __tstate = wxPyBeginAllowThreads();
17935 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
17936
17937 wxPyEndAllowThreads(__tstate);
17938 if (PyErr_Occurred()) SWIG_fail;
17939 }
17940 {
17941 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17942 }
17943 return resultobj;
17944 fail:
17945 return NULL;
17946 }
17947
17948
17949 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
17950 PyObject *resultobj;
17951 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17952 bool result;
17953 PyObject * obj0 = 0 ;
17954 char *kwnames[] = {
17955 (char *) "self", NULL
17956 };
17957
17958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
17959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17960 if (SWIG_arg_fail(1)) SWIG_fail;
17961 {
17962 PyThreadState* __tstate = wxPyBeginAllowThreads();
17963 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
17964
17965 wxPyEndAllowThreads(__tstate);
17966 if (PyErr_Occurred()) SWIG_fail;
17967 }
17968 {
17969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17970 }
17971 return resultobj;
17972 fail:
17973 return NULL;
17974 }
17975
17976
17977 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
17978 PyObject *resultobj;
17979 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
17980 int result;
17981 PyObject * obj0 = 0 ;
17982 char *kwnames[] = {
17983 (char *) "self", NULL
17984 };
17985
17986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
17987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
17988 if (SWIG_arg_fail(1)) SWIG_fail;
17989 {
17990 PyThreadState* __tstate = wxPyBeginAllowThreads();
17991 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
17992
17993 wxPyEndAllowThreads(__tstate);
17994 if (PyErr_Occurred()) SWIG_fail;
17995 }
17996 {
17997 resultobj = SWIG_From_int((int)(result));
17998 }
17999 return resultobj;
18000 fail:
18001 return NULL;
18002 }
18003
18004
18005 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18006 PyObject *resultobj;
18007 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18008 int result;
18009 PyObject * obj0 = 0 ;
18010 char *kwnames[] = {
18011 (char *) "self", NULL
18012 };
18013
18014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18016 if (SWIG_arg_fail(1)) SWIG_fail;
18017 {
18018 PyThreadState* __tstate = wxPyBeginAllowThreads();
18019 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18020
18021 wxPyEndAllowThreads(__tstate);
18022 if (PyErr_Occurred()) SWIG_fail;
18023 }
18024 {
18025 resultobj = SWIG_From_int((int)(result));
18026 }
18027 return resultobj;
18028 fail:
18029 return NULL;
18030 }
18031
18032
18033 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18034 PyObject *resultobj;
18035 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18036 unsigned int result;
18037 PyObject * obj0 = 0 ;
18038 char *kwnames[] = {
18039 (char *) "self", NULL
18040 };
18041
18042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18044 if (SWIG_arg_fail(1)) SWIG_fail;
18045 {
18046 PyThreadState* __tstate = wxPyBeginAllowThreads();
18047 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18048
18049 wxPyEndAllowThreads(__tstate);
18050 if (PyErr_Occurred()) SWIG_fail;
18051 }
18052 {
18053 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18054 }
18055 return resultobj;
18056 fail:
18057 return NULL;
18058 }
18059
18060
18061 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18062 PyObject *resultobj;
18063 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18064 unsigned int result;
18065 PyObject * obj0 = 0 ;
18066 char *kwnames[] = {
18067 (char *) "self", NULL
18068 };
18069
18070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18072 if (SWIG_arg_fail(1)) SWIG_fail;
18073 {
18074 PyThreadState* __tstate = wxPyBeginAllowThreads();
18075 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18076
18077 wxPyEndAllowThreads(__tstate);
18078 if (PyErr_Occurred()) SWIG_fail;
18079 }
18080 {
18081 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18082 }
18083 return resultobj;
18084 fail:
18085 return NULL;
18086 }
18087
18088
18089 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18090 PyObject *resultobj;
18091 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18092 wxPoint result;
18093 PyObject * obj0 = 0 ;
18094 char *kwnames[] = {
18095 (char *) "self", NULL
18096 };
18097
18098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18100 if (SWIG_arg_fail(1)) SWIG_fail;
18101 {
18102 PyThreadState* __tstate = wxPyBeginAllowThreads();
18103 result = (arg1)->GetPosition();
18104
18105 wxPyEndAllowThreads(__tstate);
18106 if (PyErr_Occurred()) SWIG_fail;
18107 }
18108 {
18109 wxPoint * resultptr;
18110 resultptr = new wxPoint((wxPoint &)(result));
18111 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18112 }
18113 return resultobj;
18114 fail:
18115 return NULL;
18116 }
18117
18118
18119 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18120 PyObject *resultobj;
18121 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18122 long *arg2 = (long *) 0 ;
18123 long *arg3 = (long *) 0 ;
18124 long temp2 ;
18125 int res2 = 0 ;
18126 long temp3 ;
18127 int res3 = 0 ;
18128 PyObject * obj0 = 0 ;
18129 char *kwnames[] = {
18130 (char *) "self", NULL
18131 };
18132
18133 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18134 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18137 if (SWIG_arg_fail(1)) SWIG_fail;
18138 {
18139 PyThreadState* __tstate = wxPyBeginAllowThreads();
18140 (arg1)->GetPosition(arg2,arg3);
18141
18142 wxPyEndAllowThreads(__tstate);
18143 if (PyErr_Occurred()) SWIG_fail;
18144 }
18145 Py_INCREF(Py_None); resultobj = Py_None;
18146 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18147 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18148 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18149 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18150 return resultobj;
18151 fail:
18152 return NULL;
18153 }
18154
18155
18156 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18157 PyObject *resultobj;
18158 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18159 int result;
18160 PyObject * obj0 = 0 ;
18161 char *kwnames[] = {
18162 (char *) "self", NULL
18163 };
18164
18165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18167 if (SWIG_arg_fail(1)) SWIG_fail;
18168 {
18169 PyThreadState* __tstate = wxPyBeginAllowThreads();
18170 result = (int)((wxKeyEvent const *)arg1)->GetX();
18171
18172 wxPyEndAllowThreads(__tstate);
18173 if (PyErr_Occurred()) SWIG_fail;
18174 }
18175 {
18176 resultobj = SWIG_From_int((int)(result));
18177 }
18178 return resultobj;
18179 fail:
18180 return NULL;
18181 }
18182
18183
18184 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18185 PyObject *resultobj;
18186 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18187 int result;
18188 PyObject * obj0 = 0 ;
18189 char *kwnames[] = {
18190 (char *) "self", NULL
18191 };
18192
18193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18195 if (SWIG_arg_fail(1)) SWIG_fail;
18196 {
18197 PyThreadState* __tstate = wxPyBeginAllowThreads();
18198 result = (int)((wxKeyEvent const *)arg1)->GetY();
18199
18200 wxPyEndAllowThreads(__tstate);
18201 if (PyErr_Occurred()) SWIG_fail;
18202 }
18203 {
18204 resultobj = SWIG_From_int((int)(result));
18205 }
18206 return resultobj;
18207 fail:
18208 return NULL;
18209 }
18210
18211
18212 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18213 PyObject *resultobj;
18214 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18215 int arg2 ;
18216 PyObject * obj0 = 0 ;
18217 PyObject * obj1 = 0 ;
18218 char *kwnames[] = {
18219 (char *) "self",(char *) "m_x", NULL
18220 };
18221
18222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18224 if (SWIG_arg_fail(1)) SWIG_fail;
18225 {
18226 arg2 = (int)(SWIG_As_int(obj1));
18227 if (SWIG_arg_fail(2)) SWIG_fail;
18228 }
18229 if (arg1) (arg1)->m_x = arg2;
18230
18231 Py_INCREF(Py_None); resultobj = Py_None;
18232 return resultobj;
18233 fail:
18234 return NULL;
18235 }
18236
18237
18238 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18239 PyObject *resultobj;
18240 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18241 int result;
18242 PyObject * obj0 = 0 ;
18243 char *kwnames[] = {
18244 (char *) "self", NULL
18245 };
18246
18247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18249 if (SWIG_arg_fail(1)) SWIG_fail;
18250 result = (int) ((arg1)->m_x);
18251
18252 {
18253 resultobj = SWIG_From_int((int)(result));
18254 }
18255 return resultobj;
18256 fail:
18257 return NULL;
18258 }
18259
18260
18261 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18262 PyObject *resultobj;
18263 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18264 int arg2 ;
18265 PyObject * obj0 = 0 ;
18266 PyObject * obj1 = 0 ;
18267 char *kwnames[] = {
18268 (char *) "self",(char *) "m_y", NULL
18269 };
18270
18271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18273 if (SWIG_arg_fail(1)) SWIG_fail;
18274 {
18275 arg2 = (int)(SWIG_As_int(obj1));
18276 if (SWIG_arg_fail(2)) SWIG_fail;
18277 }
18278 if (arg1) (arg1)->m_y = arg2;
18279
18280 Py_INCREF(Py_None); resultobj = Py_None;
18281 return resultobj;
18282 fail:
18283 return NULL;
18284 }
18285
18286
18287 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18288 PyObject *resultobj;
18289 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18290 int result;
18291 PyObject * obj0 = 0 ;
18292 char *kwnames[] = {
18293 (char *) "self", NULL
18294 };
18295
18296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18298 if (SWIG_arg_fail(1)) SWIG_fail;
18299 result = (int) ((arg1)->m_y);
18300
18301 {
18302 resultobj = SWIG_From_int((int)(result));
18303 }
18304 return resultobj;
18305 fail:
18306 return NULL;
18307 }
18308
18309
18310 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18311 PyObject *resultobj;
18312 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18313 long arg2 ;
18314 PyObject * obj0 = 0 ;
18315 PyObject * obj1 = 0 ;
18316 char *kwnames[] = {
18317 (char *) "self",(char *) "m_keyCode", NULL
18318 };
18319
18320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18322 if (SWIG_arg_fail(1)) SWIG_fail;
18323 {
18324 arg2 = (long)(SWIG_As_long(obj1));
18325 if (SWIG_arg_fail(2)) SWIG_fail;
18326 }
18327 if (arg1) (arg1)->m_keyCode = arg2;
18328
18329 Py_INCREF(Py_None); resultobj = Py_None;
18330 return resultobj;
18331 fail:
18332 return NULL;
18333 }
18334
18335
18336 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18337 PyObject *resultobj;
18338 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18339 long result;
18340 PyObject * obj0 = 0 ;
18341 char *kwnames[] = {
18342 (char *) "self", NULL
18343 };
18344
18345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18347 if (SWIG_arg_fail(1)) SWIG_fail;
18348 result = (long) ((arg1)->m_keyCode);
18349
18350 {
18351 resultobj = SWIG_From_long((long)(result));
18352 }
18353 return resultobj;
18354 fail:
18355 return NULL;
18356 }
18357
18358
18359 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18360 PyObject *resultobj;
18361 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18362 bool arg2 ;
18363 PyObject * obj0 = 0 ;
18364 PyObject * obj1 = 0 ;
18365 char *kwnames[] = {
18366 (char *) "self",(char *) "m_controlDown", NULL
18367 };
18368
18369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18371 if (SWIG_arg_fail(1)) SWIG_fail;
18372 {
18373 arg2 = (bool)(SWIG_As_bool(obj1));
18374 if (SWIG_arg_fail(2)) SWIG_fail;
18375 }
18376 if (arg1) (arg1)->m_controlDown = arg2;
18377
18378 Py_INCREF(Py_None); resultobj = Py_None;
18379 return resultobj;
18380 fail:
18381 return NULL;
18382 }
18383
18384
18385 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18386 PyObject *resultobj;
18387 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18388 bool result;
18389 PyObject * obj0 = 0 ;
18390 char *kwnames[] = {
18391 (char *) "self", NULL
18392 };
18393
18394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18396 if (SWIG_arg_fail(1)) SWIG_fail;
18397 result = (bool) ((arg1)->m_controlDown);
18398
18399 {
18400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18401 }
18402 return resultobj;
18403 fail:
18404 return NULL;
18405 }
18406
18407
18408 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18409 PyObject *resultobj;
18410 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18411 bool arg2 ;
18412 PyObject * obj0 = 0 ;
18413 PyObject * obj1 = 0 ;
18414 char *kwnames[] = {
18415 (char *) "self",(char *) "m_shiftDown", NULL
18416 };
18417
18418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18420 if (SWIG_arg_fail(1)) SWIG_fail;
18421 {
18422 arg2 = (bool)(SWIG_As_bool(obj1));
18423 if (SWIG_arg_fail(2)) SWIG_fail;
18424 }
18425 if (arg1) (arg1)->m_shiftDown = arg2;
18426
18427 Py_INCREF(Py_None); resultobj = Py_None;
18428 return resultobj;
18429 fail:
18430 return NULL;
18431 }
18432
18433
18434 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18435 PyObject *resultobj;
18436 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18437 bool result;
18438 PyObject * obj0 = 0 ;
18439 char *kwnames[] = {
18440 (char *) "self", NULL
18441 };
18442
18443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18445 if (SWIG_arg_fail(1)) SWIG_fail;
18446 result = (bool) ((arg1)->m_shiftDown);
18447
18448 {
18449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18450 }
18451 return resultobj;
18452 fail:
18453 return NULL;
18454 }
18455
18456
18457 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18458 PyObject *resultobj;
18459 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18460 bool arg2 ;
18461 PyObject * obj0 = 0 ;
18462 PyObject * obj1 = 0 ;
18463 char *kwnames[] = {
18464 (char *) "self",(char *) "m_altDown", NULL
18465 };
18466
18467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18469 if (SWIG_arg_fail(1)) SWIG_fail;
18470 {
18471 arg2 = (bool)(SWIG_As_bool(obj1));
18472 if (SWIG_arg_fail(2)) SWIG_fail;
18473 }
18474 if (arg1) (arg1)->m_altDown = arg2;
18475
18476 Py_INCREF(Py_None); resultobj = Py_None;
18477 return resultobj;
18478 fail:
18479 return NULL;
18480 }
18481
18482
18483 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18484 PyObject *resultobj;
18485 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18486 bool result;
18487 PyObject * obj0 = 0 ;
18488 char *kwnames[] = {
18489 (char *) "self", NULL
18490 };
18491
18492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18494 if (SWIG_arg_fail(1)) SWIG_fail;
18495 result = (bool) ((arg1)->m_altDown);
18496
18497 {
18498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18499 }
18500 return resultobj;
18501 fail:
18502 return NULL;
18503 }
18504
18505
18506 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18507 PyObject *resultobj;
18508 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18509 bool arg2 ;
18510 PyObject * obj0 = 0 ;
18511 PyObject * obj1 = 0 ;
18512 char *kwnames[] = {
18513 (char *) "self",(char *) "m_metaDown", NULL
18514 };
18515
18516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18518 if (SWIG_arg_fail(1)) SWIG_fail;
18519 {
18520 arg2 = (bool)(SWIG_As_bool(obj1));
18521 if (SWIG_arg_fail(2)) SWIG_fail;
18522 }
18523 if (arg1) (arg1)->m_metaDown = arg2;
18524
18525 Py_INCREF(Py_None); resultobj = Py_None;
18526 return resultobj;
18527 fail:
18528 return NULL;
18529 }
18530
18531
18532 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18533 PyObject *resultobj;
18534 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18535 bool result;
18536 PyObject * obj0 = 0 ;
18537 char *kwnames[] = {
18538 (char *) "self", NULL
18539 };
18540
18541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18543 if (SWIG_arg_fail(1)) SWIG_fail;
18544 result = (bool) ((arg1)->m_metaDown);
18545
18546 {
18547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18548 }
18549 return resultobj;
18550 fail:
18551 return NULL;
18552 }
18553
18554
18555 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18556 PyObject *resultobj;
18557 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18558 bool arg2 ;
18559 PyObject * obj0 = 0 ;
18560 PyObject * obj1 = 0 ;
18561 char *kwnames[] = {
18562 (char *) "self",(char *) "m_scanCode", NULL
18563 };
18564
18565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
18566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18567 if (SWIG_arg_fail(1)) SWIG_fail;
18568 {
18569 arg2 = (bool)(SWIG_As_bool(obj1));
18570 if (SWIG_arg_fail(2)) SWIG_fail;
18571 }
18572 if (arg1) (arg1)->m_scanCode = arg2;
18573
18574 Py_INCREF(Py_None); resultobj = Py_None;
18575 return resultobj;
18576 fail:
18577 return NULL;
18578 }
18579
18580
18581 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18582 PyObject *resultobj;
18583 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18584 bool result;
18585 PyObject * obj0 = 0 ;
18586 char *kwnames[] = {
18587 (char *) "self", NULL
18588 };
18589
18590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
18591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18592 if (SWIG_arg_fail(1)) SWIG_fail;
18593 result = (bool) ((arg1)->m_scanCode);
18594
18595 {
18596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18597 }
18598 return resultobj;
18599 fail:
18600 return NULL;
18601 }
18602
18603
18604 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18605 PyObject *resultobj;
18606 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18607 unsigned int arg2 ;
18608 PyObject * obj0 = 0 ;
18609 PyObject * obj1 = 0 ;
18610 char *kwnames[] = {
18611 (char *) "self",(char *) "m_rawCode", NULL
18612 };
18613
18614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
18615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18616 if (SWIG_arg_fail(1)) SWIG_fail;
18617 {
18618 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18619 if (SWIG_arg_fail(2)) SWIG_fail;
18620 }
18621 if (arg1) (arg1)->m_rawCode = arg2;
18622
18623 Py_INCREF(Py_None); resultobj = Py_None;
18624 return resultobj;
18625 fail:
18626 return NULL;
18627 }
18628
18629
18630 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18631 PyObject *resultobj;
18632 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18633 unsigned int result;
18634 PyObject * obj0 = 0 ;
18635 char *kwnames[] = {
18636 (char *) "self", NULL
18637 };
18638
18639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
18640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18641 if (SWIG_arg_fail(1)) SWIG_fail;
18642 result = (unsigned int) ((arg1)->m_rawCode);
18643
18644 {
18645 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18646 }
18647 return resultobj;
18648 fail:
18649 return NULL;
18650 }
18651
18652
18653 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
18654 PyObject *resultobj;
18655 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18656 unsigned int arg2 ;
18657 PyObject * obj0 = 0 ;
18658 PyObject * obj1 = 0 ;
18659 char *kwnames[] = {
18660 (char *) "self",(char *) "m_rawFlags", NULL
18661 };
18662
18663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
18664 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18665 if (SWIG_arg_fail(1)) SWIG_fail;
18666 {
18667 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
18668 if (SWIG_arg_fail(2)) SWIG_fail;
18669 }
18670 if (arg1) (arg1)->m_rawFlags = arg2;
18671
18672 Py_INCREF(Py_None); resultobj = Py_None;
18673 return resultobj;
18674 fail:
18675 return NULL;
18676 }
18677
18678
18679 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
18680 PyObject *resultobj;
18681 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18682 unsigned int result;
18683 PyObject * obj0 = 0 ;
18684 char *kwnames[] = {
18685 (char *) "self", NULL
18686 };
18687
18688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
18689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18690 if (SWIG_arg_fail(1)) SWIG_fail;
18691 result = (unsigned int) ((arg1)->m_rawFlags);
18692
18693 {
18694 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18695 }
18696 return resultobj;
18697 fail:
18698 return NULL;
18699 }
18700
18701
18702 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
18703 PyObject *obj;
18704 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18705 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
18706 Py_INCREF(obj);
18707 return Py_BuildValue((char *)"");
18708 }
18709 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18710 PyObject *resultobj;
18711 wxSize const &arg1_defvalue = wxDefaultSize ;
18712 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
18713 int arg2 = (int) 0 ;
18714 wxSizeEvent *result;
18715 wxSize temp1 ;
18716 PyObject * obj0 = 0 ;
18717 PyObject * obj1 = 0 ;
18718 char *kwnames[] = {
18719 (char *) "sz",(char *) "winid", NULL
18720 };
18721
18722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
18723 if (obj0) {
18724 {
18725 arg1 = &temp1;
18726 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
18727 }
18728 }
18729 if (obj1) {
18730 {
18731 arg2 = (int)(SWIG_As_int(obj1));
18732 if (SWIG_arg_fail(2)) SWIG_fail;
18733 }
18734 }
18735 {
18736 PyThreadState* __tstate = wxPyBeginAllowThreads();
18737 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
18738
18739 wxPyEndAllowThreads(__tstate);
18740 if (PyErr_Occurred()) SWIG_fail;
18741 }
18742 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
18743 return resultobj;
18744 fail:
18745 return NULL;
18746 }
18747
18748
18749 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18750 PyObject *resultobj;
18751 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18752 wxSize result;
18753 PyObject * obj0 = 0 ;
18754 char *kwnames[] = {
18755 (char *) "self", NULL
18756 };
18757
18758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
18759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18760 if (SWIG_arg_fail(1)) SWIG_fail;
18761 {
18762 PyThreadState* __tstate = wxPyBeginAllowThreads();
18763 result = ((wxSizeEvent const *)arg1)->GetSize();
18764
18765 wxPyEndAllowThreads(__tstate);
18766 if (PyErr_Occurred()) SWIG_fail;
18767 }
18768 {
18769 wxSize * resultptr;
18770 resultptr = new wxSize((wxSize &)(result));
18771 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
18772 }
18773 return resultobj;
18774 fail:
18775 return NULL;
18776 }
18777
18778
18779 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18780 PyObject *resultobj;
18781 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18782 wxRect result;
18783 PyObject * obj0 = 0 ;
18784 char *kwnames[] = {
18785 (char *) "self", NULL
18786 };
18787
18788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
18789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18790 if (SWIG_arg_fail(1)) SWIG_fail;
18791 {
18792 PyThreadState* __tstate = wxPyBeginAllowThreads();
18793 result = ((wxSizeEvent const *)arg1)->GetRect();
18794
18795 wxPyEndAllowThreads(__tstate);
18796 if (PyErr_Occurred()) SWIG_fail;
18797 }
18798 {
18799 wxRect * resultptr;
18800 resultptr = new wxRect((wxRect &)(result));
18801 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
18802 }
18803 return resultobj;
18804 fail:
18805 return NULL;
18806 }
18807
18808
18809 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
18810 PyObject *resultobj;
18811 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18812 wxRect arg2 ;
18813 PyObject * obj0 = 0 ;
18814 PyObject * obj1 = 0 ;
18815 char *kwnames[] = {
18816 (char *) "self",(char *) "rect", NULL
18817 };
18818
18819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
18820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18821 if (SWIG_arg_fail(1)) SWIG_fail;
18822 {
18823 wxRect * argp;
18824 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
18825 if (SWIG_arg_fail(2)) SWIG_fail;
18826 if (argp == NULL) {
18827 SWIG_null_ref("wxRect");
18828 }
18829 if (SWIG_arg_fail(2)) SWIG_fail;
18830 arg2 = *argp;
18831 }
18832 {
18833 PyThreadState* __tstate = wxPyBeginAllowThreads();
18834 (arg1)->SetRect(arg2);
18835
18836 wxPyEndAllowThreads(__tstate);
18837 if (PyErr_Occurred()) SWIG_fail;
18838 }
18839 Py_INCREF(Py_None); resultobj = Py_None;
18840 return resultobj;
18841 fail:
18842 return NULL;
18843 }
18844
18845
18846 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
18847 PyObject *resultobj;
18848 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18849 wxSize arg2 ;
18850 PyObject * obj0 = 0 ;
18851 PyObject * obj1 = 0 ;
18852 char *kwnames[] = {
18853 (char *) "self",(char *) "size", NULL
18854 };
18855
18856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
18857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18858 if (SWIG_arg_fail(1)) SWIG_fail;
18859 {
18860 wxSize * argp;
18861 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
18862 if (SWIG_arg_fail(2)) SWIG_fail;
18863 if (argp == NULL) {
18864 SWIG_null_ref("wxSize");
18865 }
18866 if (SWIG_arg_fail(2)) SWIG_fail;
18867 arg2 = *argp;
18868 }
18869 {
18870 PyThreadState* __tstate = wxPyBeginAllowThreads();
18871 wxSizeEvent_SetSize(arg1,arg2);
18872
18873 wxPyEndAllowThreads(__tstate);
18874 if (PyErr_Occurred()) SWIG_fail;
18875 }
18876 Py_INCREF(Py_None); resultobj = Py_None;
18877 return resultobj;
18878 fail:
18879 return NULL;
18880 }
18881
18882
18883 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
18884 PyObject *resultobj;
18885 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18886 wxSize *arg2 = (wxSize *) 0 ;
18887 PyObject * obj0 = 0 ;
18888 PyObject * obj1 = 0 ;
18889 char *kwnames[] = {
18890 (char *) "self",(char *) "m_size", NULL
18891 };
18892
18893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
18894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18895 if (SWIG_arg_fail(1)) SWIG_fail;
18896 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
18897 if (SWIG_arg_fail(2)) SWIG_fail;
18898 if (arg1) (arg1)->m_size = *arg2;
18899
18900 Py_INCREF(Py_None); resultobj = Py_None;
18901 return resultobj;
18902 fail:
18903 return NULL;
18904 }
18905
18906
18907 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
18908 PyObject *resultobj;
18909 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18910 wxSize *result;
18911 PyObject * obj0 = 0 ;
18912 char *kwnames[] = {
18913 (char *) "self", NULL
18914 };
18915
18916 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
18917 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18918 if (SWIG_arg_fail(1)) SWIG_fail;
18919 result = (wxSize *)& ((arg1)->m_size);
18920
18921 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
18922 return resultobj;
18923 fail:
18924 return NULL;
18925 }
18926
18927
18928 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
18929 PyObject *resultobj;
18930 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18931 wxRect *arg2 = (wxRect *) 0 ;
18932 PyObject * obj0 = 0 ;
18933 PyObject * obj1 = 0 ;
18934 char *kwnames[] = {
18935 (char *) "self",(char *) "m_rect", NULL
18936 };
18937
18938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
18939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18940 if (SWIG_arg_fail(1)) SWIG_fail;
18941 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
18942 if (SWIG_arg_fail(2)) SWIG_fail;
18943 if (arg1) (arg1)->m_rect = *arg2;
18944
18945 Py_INCREF(Py_None); resultobj = Py_None;
18946 return resultobj;
18947 fail:
18948 return NULL;
18949 }
18950
18951
18952 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
18953 PyObject *resultobj;
18954 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
18955 wxRect *result;
18956 PyObject * obj0 = 0 ;
18957 char *kwnames[] = {
18958 (char *) "self", NULL
18959 };
18960
18961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
18962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
18963 if (SWIG_arg_fail(1)) SWIG_fail;
18964 result = (wxRect *)& ((arg1)->m_rect);
18965
18966 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
18967 return resultobj;
18968 fail:
18969 return NULL;
18970 }
18971
18972
18973 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
18974 PyObject *obj;
18975 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18976 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
18977 Py_INCREF(obj);
18978 return Py_BuildValue((char *)"");
18979 }
18980 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18981 PyObject *resultobj;
18982 wxPoint const &arg1_defvalue = wxDefaultPosition ;
18983 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
18984 int arg2 = (int) 0 ;
18985 wxMoveEvent *result;
18986 wxPoint temp1 ;
18987 PyObject * obj0 = 0 ;
18988 PyObject * obj1 = 0 ;
18989 char *kwnames[] = {
18990 (char *) "pos",(char *) "winid", NULL
18991 };
18992
18993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
18994 if (obj0) {
18995 {
18996 arg1 = &temp1;
18997 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
18998 }
18999 }
19000 if (obj1) {
19001 {
19002 arg2 = (int)(SWIG_As_int(obj1));
19003 if (SWIG_arg_fail(2)) SWIG_fail;
19004 }
19005 }
19006 {
19007 PyThreadState* __tstate = wxPyBeginAllowThreads();
19008 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19009
19010 wxPyEndAllowThreads(__tstate);
19011 if (PyErr_Occurred()) SWIG_fail;
19012 }
19013 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19014 return resultobj;
19015 fail:
19016 return NULL;
19017 }
19018
19019
19020 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19021 PyObject *resultobj;
19022 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19023 wxPoint result;
19024 PyObject * obj0 = 0 ;
19025 char *kwnames[] = {
19026 (char *) "self", NULL
19027 };
19028
19029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19031 if (SWIG_arg_fail(1)) SWIG_fail;
19032 {
19033 PyThreadState* __tstate = wxPyBeginAllowThreads();
19034 result = ((wxMoveEvent const *)arg1)->GetPosition();
19035
19036 wxPyEndAllowThreads(__tstate);
19037 if (PyErr_Occurred()) SWIG_fail;
19038 }
19039 {
19040 wxPoint * resultptr;
19041 resultptr = new wxPoint((wxPoint &)(result));
19042 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19043 }
19044 return resultobj;
19045 fail:
19046 return NULL;
19047 }
19048
19049
19050 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19051 PyObject *resultobj;
19052 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19053 wxRect result;
19054 PyObject * obj0 = 0 ;
19055 char *kwnames[] = {
19056 (char *) "self", NULL
19057 };
19058
19059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19061 if (SWIG_arg_fail(1)) SWIG_fail;
19062 {
19063 PyThreadState* __tstate = wxPyBeginAllowThreads();
19064 result = ((wxMoveEvent const *)arg1)->GetRect();
19065
19066 wxPyEndAllowThreads(__tstate);
19067 if (PyErr_Occurred()) SWIG_fail;
19068 }
19069 {
19070 wxRect * resultptr;
19071 resultptr = new wxRect((wxRect &)(result));
19072 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19073 }
19074 return resultobj;
19075 fail:
19076 return NULL;
19077 }
19078
19079
19080 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19081 PyObject *resultobj;
19082 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19083 wxRect *arg2 = 0 ;
19084 wxRect temp2 ;
19085 PyObject * obj0 = 0 ;
19086 PyObject * obj1 = 0 ;
19087 char *kwnames[] = {
19088 (char *) "self",(char *) "rect", NULL
19089 };
19090
19091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19093 if (SWIG_arg_fail(1)) SWIG_fail;
19094 {
19095 arg2 = &temp2;
19096 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19097 }
19098 {
19099 PyThreadState* __tstate = wxPyBeginAllowThreads();
19100 (arg1)->SetRect((wxRect const &)*arg2);
19101
19102 wxPyEndAllowThreads(__tstate);
19103 if (PyErr_Occurred()) SWIG_fail;
19104 }
19105 Py_INCREF(Py_None); resultobj = Py_None;
19106 return resultobj;
19107 fail:
19108 return NULL;
19109 }
19110
19111
19112 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19113 PyObject *resultobj;
19114 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19115 wxPoint *arg2 = 0 ;
19116 wxPoint temp2 ;
19117 PyObject * obj0 = 0 ;
19118 PyObject * obj1 = 0 ;
19119 char *kwnames[] = {
19120 (char *) "self",(char *) "pos", NULL
19121 };
19122
19123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19125 if (SWIG_arg_fail(1)) SWIG_fail;
19126 {
19127 arg2 = &temp2;
19128 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19129 }
19130 {
19131 PyThreadState* __tstate = wxPyBeginAllowThreads();
19132 (arg1)->SetPosition((wxPoint const &)*arg2);
19133
19134 wxPyEndAllowThreads(__tstate);
19135 if (PyErr_Occurred()) SWIG_fail;
19136 }
19137 Py_INCREF(Py_None); resultobj = Py_None;
19138 return resultobj;
19139 fail:
19140 return NULL;
19141 }
19142
19143
19144 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19145 PyObject *obj;
19146 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19147 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19148 Py_INCREF(obj);
19149 return Py_BuildValue((char *)"");
19150 }
19151 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19152 PyObject *resultobj;
19153 int arg1 = (int) 0 ;
19154 wxPaintEvent *result;
19155 PyObject * obj0 = 0 ;
19156 char *kwnames[] = {
19157 (char *) "Id", NULL
19158 };
19159
19160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19161 if (obj0) {
19162 {
19163 arg1 = (int)(SWIG_As_int(obj0));
19164 if (SWIG_arg_fail(1)) SWIG_fail;
19165 }
19166 }
19167 {
19168 PyThreadState* __tstate = wxPyBeginAllowThreads();
19169 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19170
19171 wxPyEndAllowThreads(__tstate);
19172 if (PyErr_Occurred()) SWIG_fail;
19173 }
19174 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19175 return resultobj;
19176 fail:
19177 return NULL;
19178 }
19179
19180
19181 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19182 PyObject *obj;
19183 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19184 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19185 Py_INCREF(obj);
19186 return Py_BuildValue((char *)"");
19187 }
19188 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19189 PyObject *resultobj;
19190 int arg1 = (int) 0 ;
19191 wxNcPaintEvent *result;
19192 PyObject * obj0 = 0 ;
19193 char *kwnames[] = {
19194 (char *) "winid", NULL
19195 };
19196
19197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19198 if (obj0) {
19199 {
19200 arg1 = (int)(SWIG_As_int(obj0));
19201 if (SWIG_arg_fail(1)) SWIG_fail;
19202 }
19203 }
19204 {
19205 PyThreadState* __tstate = wxPyBeginAllowThreads();
19206 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19207
19208 wxPyEndAllowThreads(__tstate);
19209 if (PyErr_Occurred()) SWIG_fail;
19210 }
19211 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19212 return resultobj;
19213 fail:
19214 return NULL;
19215 }
19216
19217
19218 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19219 PyObject *obj;
19220 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19221 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19222 Py_INCREF(obj);
19223 return Py_BuildValue((char *)"");
19224 }
19225 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19226 PyObject *resultobj;
19227 int arg1 = (int) 0 ;
19228 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19229 wxEraseEvent *result;
19230 PyObject * obj0 = 0 ;
19231 PyObject * obj1 = 0 ;
19232 char *kwnames[] = {
19233 (char *) "Id",(char *) "dc", NULL
19234 };
19235
19236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19237 if (obj0) {
19238 {
19239 arg1 = (int)(SWIG_As_int(obj0));
19240 if (SWIG_arg_fail(1)) SWIG_fail;
19241 }
19242 }
19243 if (obj1) {
19244 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19245 if (SWIG_arg_fail(2)) SWIG_fail;
19246 }
19247 {
19248 PyThreadState* __tstate = wxPyBeginAllowThreads();
19249 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19250
19251 wxPyEndAllowThreads(__tstate);
19252 if (PyErr_Occurred()) SWIG_fail;
19253 }
19254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19255 return resultobj;
19256 fail:
19257 return NULL;
19258 }
19259
19260
19261 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19262 PyObject *resultobj;
19263 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19264 wxDC *result;
19265 PyObject * obj0 = 0 ;
19266 char *kwnames[] = {
19267 (char *) "self", NULL
19268 };
19269
19270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19272 if (SWIG_arg_fail(1)) SWIG_fail;
19273 {
19274 PyThreadState* __tstate = wxPyBeginAllowThreads();
19275 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19276
19277 wxPyEndAllowThreads(__tstate);
19278 if (PyErr_Occurred()) SWIG_fail;
19279 }
19280 {
19281 resultobj = wxPyMake_wxObject(result, 0);
19282 }
19283 return resultobj;
19284 fail:
19285 return NULL;
19286 }
19287
19288
19289 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19290 PyObject *obj;
19291 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19292 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19293 Py_INCREF(obj);
19294 return Py_BuildValue((char *)"");
19295 }
19296 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19297 PyObject *resultobj;
19298 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19299 int arg2 = (int) 0 ;
19300 wxFocusEvent *result;
19301 PyObject * obj0 = 0 ;
19302 PyObject * obj1 = 0 ;
19303 char *kwnames[] = {
19304 (char *) "type",(char *) "winid", NULL
19305 };
19306
19307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19308 if (obj0) {
19309 {
19310 arg1 = (wxEventType)(SWIG_As_int(obj0));
19311 if (SWIG_arg_fail(1)) SWIG_fail;
19312 }
19313 }
19314 if (obj1) {
19315 {
19316 arg2 = (int)(SWIG_As_int(obj1));
19317 if (SWIG_arg_fail(2)) SWIG_fail;
19318 }
19319 }
19320 {
19321 PyThreadState* __tstate = wxPyBeginAllowThreads();
19322 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19323
19324 wxPyEndAllowThreads(__tstate);
19325 if (PyErr_Occurred()) SWIG_fail;
19326 }
19327 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19328 return resultobj;
19329 fail:
19330 return NULL;
19331 }
19332
19333
19334 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19335 PyObject *resultobj;
19336 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19337 wxWindow *result;
19338 PyObject * obj0 = 0 ;
19339 char *kwnames[] = {
19340 (char *) "self", NULL
19341 };
19342
19343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19345 if (SWIG_arg_fail(1)) SWIG_fail;
19346 {
19347 PyThreadState* __tstate = wxPyBeginAllowThreads();
19348 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19349
19350 wxPyEndAllowThreads(__tstate);
19351 if (PyErr_Occurred()) SWIG_fail;
19352 }
19353 {
19354 resultobj = wxPyMake_wxObject(result, 0);
19355 }
19356 return resultobj;
19357 fail:
19358 return NULL;
19359 }
19360
19361
19362 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19363 PyObject *resultobj;
19364 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19365 wxWindow *arg2 = (wxWindow *) 0 ;
19366 PyObject * obj0 = 0 ;
19367 PyObject * obj1 = 0 ;
19368 char *kwnames[] = {
19369 (char *) "self",(char *) "win", NULL
19370 };
19371
19372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19374 if (SWIG_arg_fail(1)) SWIG_fail;
19375 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19376 if (SWIG_arg_fail(2)) SWIG_fail;
19377 {
19378 PyThreadState* __tstate = wxPyBeginAllowThreads();
19379 (arg1)->SetWindow(arg2);
19380
19381 wxPyEndAllowThreads(__tstate);
19382 if (PyErr_Occurred()) SWIG_fail;
19383 }
19384 Py_INCREF(Py_None); resultobj = Py_None;
19385 return resultobj;
19386 fail:
19387 return NULL;
19388 }
19389
19390
19391 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19392 PyObject *obj;
19393 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19394 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19395 Py_INCREF(obj);
19396 return Py_BuildValue((char *)"");
19397 }
19398 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19399 PyObject *resultobj;
19400 wxWindow *arg1 = (wxWindow *) NULL ;
19401 wxChildFocusEvent *result;
19402 PyObject * obj0 = 0 ;
19403 char *kwnames[] = {
19404 (char *) "win", NULL
19405 };
19406
19407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19408 if (obj0) {
19409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19410 if (SWIG_arg_fail(1)) SWIG_fail;
19411 }
19412 {
19413 PyThreadState* __tstate = wxPyBeginAllowThreads();
19414 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19415
19416 wxPyEndAllowThreads(__tstate);
19417 if (PyErr_Occurred()) SWIG_fail;
19418 }
19419 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19420 return resultobj;
19421 fail:
19422 return NULL;
19423 }
19424
19425
19426 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19427 PyObject *resultobj;
19428 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19429 wxWindow *result;
19430 PyObject * obj0 = 0 ;
19431 char *kwnames[] = {
19432 (char *) "self", NULL
19433 };
19434
19435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19437 if (SWIG_arg_fail(1)) SWIG_fail;
19438 {
19439 PyThreadState* __tstate = wxPyBeginAllowThreads();
19440 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19441
19442 wxPyEndAllowThreads(__tstate);
19443 if (PyErr_Occurred()) SWIG_fail;
19444 }
19445 {
19446 resultobj = wxPyMake_wxObject(result, 0);
19447 }
19448 return resultobj;
19449 fail:
19450 return NULL;
19451 }
19452
19453
19454 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19455 PyObject *obj;
19456 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19457 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19458 Py_INCREF(obj);
19459 return Py_BuildValue((char *)"");
19460 }
19461 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19462 PyObject *resultobj;
19463 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19464 bool arg2 = (bool) true ;
19465 int arg3 = (int) 0 ;
19466 wxActivateEvent *result;
19467 PyObject * obj0 = 0 ;
19468 PyObject * obj1 = 0 ;
19469 PyObject * obj2 = 0 ;
19470 char *kwnames[] = {
19471 (char *) "type",(char *) "active",(char *) "Id", NULL
19472 };
19473
19474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19475 if (obj0) {
19476 {
19477 arg1 = (wxEventType)(SWIG_As_int(obj0));
19478 if (SWIG_arg_fail(1)) SWIG_fail;
19479 }
19480 }
19481 if (obj1) {
19482 {
19483 arg2 = (bool)(SWIG_As_bool(obj1));
19484 if (SWIG_arg_fail(2)) SWIG_fail;
19485 }
19486 }
19487 if (obj2) {
19488 {
19489 arg3 = (int)(SWIG_As_int(obj2));
19490 if (SWIG_arg_fail(3)) SWIG_fail;
19491 }
19492 }
19493 {
19494 PyThreadState* __tstate = wxPyBeginAllowThreads();
19495 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
19496
19497 wxPyEndAllowThreads(__tstate);
19498 if (PyErr_Occurred()) SWIG_fail;
19499 }
19500 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
19501 return resultobj;
19502 fail:
19503 return NULL;
19504 }
19505
19506
19507 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
19508 PyObject *resultobj;
19509 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
19510 bool result;
19511 PyObject * obj0 = 0 ;
19512 char *kwnames[] = {
19513 (char *) "self", NULL
19514 };
19515
19516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
19517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
19518 if (SWIG_arg_fail(1)) SWIG_fail;
19519 {
19520 PyThreadState* __tstate = wxPyBeginAllowThreads();
19521 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
19522
19523 wxPyEndAllowThreads(__tstate);
19524 if (PyErr_Occurred()) SWIG_fail;
19525 }
19526 {
19527 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19528 }
19529 return resultobj;
19530 fail:
19531 return NULL;
19532 }
19533
19534
19535 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
19536 PyObject *obj;
19537 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19538 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
19539 Py_INCREF(obj);
19540 return Py_BuildValue((char *)"");
19541 }
19542 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19543 PyObject *resultobj;
19544 int arg1 = (int) 0 ;
19545 wxInitDialogEvent *result;
19546 PyObject * obj0 = 0 ;
19547 char *kwnames[] = {
19548 (char *) "Id", NULL
19549 };
19550
19551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
19552 if (obj0) {
19553 {
19554 arg1 = (int)(SWIG_As_int(obj0));
19555 if (SWIG_arg_fail(1)) SWIG_fail;
19556 }
19557 }
19558 {
19559 PyThreadState* __tstate = wxPyBeginAllowThreads();
19560 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
19561
19562 wxPyEndAllowThreads(__tstate);
19563 if (PyErr_Occurred()) SWIG_fail;
19564 }
19565 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
19566 return resultobj;
19567 fail:
19568 return NULL;
19569 }
19570
19571
19572 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
19573 PyObject *obj;
19574 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19575 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
19576 Py_INCREF(obj);
19577 return Py_BuildValue((char *)"");
19578 }
19579 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19580 PyObject *resultobj;
19581 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19582 int arg2 = (int) 0 ;
19583 wxMenu *arg3 = (wxMenu *) NULL ;
19584 wxMenuEvent *result;
19585 PyObject * obj0 = 0 ;
19586 PyObject * obj1 = 0 ;
19587 PyObject * obj2 = 0 ;
19588 char *kwnames[] = {
19589 (char *) "type",(char *) "winid",(char *) "menu", NULL
19590 };
19591
19592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
19593 if (obj0) {
19594 {
19595 arg1 = (wxEventType)(SWIG_As_int(obj0));
19596 if (SWIG_arg_fail(1)) SWIG_fail;
19597 }
19598 }
19599 if (obj1) {
19600 {
19601 arg2 = (int)(SWIG_As_int(obj1));
19602 if (SWIG_arg_fail(2)) SWIG_fail;
19603 }
19604 }
19605 if (obj2) {
19606 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
19607 if (SWIG_arg_fail(3)) SWIG_fail;
19608 }
19609 {
19610 PyThreadState* __tstate = wxPyBeginAllowThreads();
19611 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
19612
19613 wxPyEndAllowThreads(__tstate);
19614 if (PyErr_Occurred()) SWIG_fail;
19615 }
19616 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
19617 return resultobj;
19618 fail:
19619 return NULL;
19620 }
19621
19622
19623 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
19624 PyObject *resultobj;
19625 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19626 int result;
19627 PyObject * obj0 = 0 ;
19628 char *kwnames[] = {
19629 (char *) "self", NULL
19630 };
19631
19632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
19633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19634 if (SWIG_arg_fail(1)) SWIG_fail;
19635 {
19636 PyThreadState* __tstate = wxPyBeginAllowThreads();
19637 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
19638
19639 wxPyEndAllowThreads(__tstate);
19640 if (PyErr_Occurred()) SWIG_fail;
19641 }
19642 {
19643 resultobj = SWIG_From_int((int)(result));
19644 }
19645 return resultobj;
19646 fail:
19647 return NULL;
19648 }
19649
19650
19651 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
19652 PyObject *resultobj;
19653 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19654 bool result;
19655 PyObject * obj0 = 0 ;
19656 char *kwnames[] = {
19657 (char *) "self", NULL
19658 };
19659
19660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
19661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19662 if (SWIG_arg_fail(1)) SWIG_fail;
19663 {
19664 PyThreadState* __tstate = wxPyBeginAllowThreads();
19665 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
19666
19667 wxPyEndAllowThreads(__tstate);
19668 if (PyErr_Occurred()) SWIG_fail;
19669 }
19670 {
19671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19672 }
19673 return resultobj;
19674 fail:
19675 return NULL;
19676 }
19677
19678
19679 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
19680 PyObject *resultobj;
19681 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
19682 wxMenu *result;
19683 PyObject * obj0 = 0 ;
19684 char *kwnames[] = {
19685 (char *) "self", NULL
19686 };
19687
19688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
19689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
19690 if (SWIG_arg_fail(1)) SWIG_fail;
19691 {
19692 PyThreadState* __tstate = wxPyBeginAllowThreads();
19693 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
19694
19695 wxPyEndAllowThreads(__tstate);
19696 if (PyErr_Occurred()) SWIG_fail;
19697 }
19698 {
19699 resultobj = wxPyMake_wxObject(result, 0);
19700 }
19701 return resultobj;
19702 fail:
19703 return NULL;
19704 }
19705
19706
19707 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
19708 PyObject *obj;
19709 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19710 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
19711 Py_INCREF(obj);
19712 return Py_BuildValue((char *)"");
19713 }
19714 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19715 PyObject *resultobj;
19716 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19717 int arg2 = (int) 0 ;
19718 wxCloseEvent *result;
19719 PyObject * obj0 = 0 ;
19720 PyObject * obj1 = 0 ;
19721 char *kwnames[] = {
19722 (char *) "type",(char *) "winid", NULL
19723 };
19724
19725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
19726 if (obj0) {
19727 {
19728 arg1 = (wxEventType)(SWIG_As_int(obj0));
19729 if (SWIG_arg_fail(1)) SWIG_fail;
19730 }
19731 }
19732 if (obj1) {
19733 {
19734 arg2 = (int)(SWIG_As_int(obj1));
19735 if (SWIG_arg_fail(2)) SWIG_fail;
19736 }
19737 }
19738 {
19739 PyThreadState* __tstate = wxPyBeginAllowThreads();
19740 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
19741
19742 wxPyEndAllowThreads(__tstate);
19743 if (PyErr_Occurred()) SWIG_fail;
19744 }
19745 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
19746 return resultobj;
19747 fail:
19748 return NULL;
19749 }
19750
19751
19752 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19753 PyObject *resultobj;
19754 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19755 bool arg2 ;
19756 PyObject * obj0 = 0 ;
19757 PyObject * obj1 = 0 ;
19758 char *kwnames[] = {
19759 (char *) "self",(char *) "logOff", NULL
19760 };
19761
19762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
19763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19764 if (SWIG_arg_fail(1)) SWIG_fail;
19765 {
19766 arg2 = (bool)(SWIG_As_bool(obj1));
19767 if (SWIG_arg_fail(2)) SWIG_fail;
19768 }
19769 {
19770 PyThreadState* __tstate = wxPyBeginAllowThreads();
19771 (arg1)->SetLoggingOff(arg2);
19772
19773 wxPyEndAllowThreads(__tstate);
19774 if (PyErr_Occurred()) SWIG_fail;
19775 }
19776 Py_INCREF(Py_None); resultobj = Py_None;
19777 return resultobj;
19778 fail:
19779 return NULL;
19780 }
19781
19782
19783 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
19784 PyObject *resultobj;
19785 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19786 bool result;
19787 PyObject * obj0 = 0 ;
19788 char *kwnames[] = {
19789 (char *) "self", NULL
19790 };
19791
19792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
19793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19794 if (SWIG_arg_fail(1)) SWIG_fail;
19795 {
19796 PyThreadState* __tstate = wxPyBeginAllowThreads();
19797 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
19798
19799 wxPyEndAllowThreads(__tstate);
19800 if (PyErr_Occurred()) SWIG_fail;
19801 }
19802 {
19803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19804 }
19805 return resultobj;
19806 fail:
19807 return NULL;
19808 }
19809
19810
19811 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
19812 PyObject *resultobj;
19813 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19814 bool arg2 = (bool) true ;
19815 PyObject * obj0 = 0 ;
19816 PyObject * obj1 = 0 ;
19817 char *kwnames[] = {
19818 (char *) "self",(char *) "veto", NULL
19819 };
19820
19821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
19822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19823 if (SWIG_arg_fail(1)) SWIG_fail;
19824 if (obj1) {
19825 {
19826 arg2 = (bool)(SWIG_As_bool(obj1));
19827 if (SWIG_arg_fail(2)) SWIG_fail;
19828 }
19829 }
19830 {
19831 PyThreadState* __tstate = wxPyBeginAllowThreads();
19832 (arg1)->Veto(arg2);
19833
19834 wxPyEndAllowThreads(__tstate);
19835 if (PyErr_Occurred()) SWIG_fail;
19836 }
19837 Py_INCREF(Py_None); resultobj = Py_None;
19838 return resultobj;
19839 fail:
19840 return NULL;
19841 }
19842
19843
19844 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19845 PyObject *resultobj;
19846 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19847 bool arg2 ;
19848 PyObject * obj0 = 0 ;
19849 PyObject * obj1 = 0 ;
19850 char *kwnames[] = {
19851 (char *) "self",(char *) "canVeto", NULL
19852 };
19853
19854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
19855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19856 if (SWIG_arg_fail(1)) SWIG_fail;
19857 {
19858 arg2 = (bool)(SWIG_As_bool(obj1));
19859 if (SWIG_arg_fail(2)) SWIG_fail;
19860 }
19861 {
19862 PyThreadState* __tstate = wxPyBeginAllowThreads();
19863 (arg1)->SetCanVeto(arg2);
19864
19865 wxPyEndAllowThreads(__tstate);
19866 if (PyErr_Occurred()) SWIG_fail;
19867 }
19868 Py_INCREF(Py_None); resultobj = Py_None;
19869 return resultobj;
19870 fail:
19871 return NULL;
19872 }
19873
19874
19875 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19876 PyObject *resultobj;
19877 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19878 bool result;
19879 PyObject * obj0 = 0 ;
19880 char *kwnames[] = {
19881 (char *) "self", NULL
19882 };
19883
19884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
19885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19886 if (SWIG_arg_fail(1)) SWIG_fail;
19887 {
19888 PyThreadState* __tstate = wxPyBeginAllowThreads();
19889 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
19890
19891 wxPyEndAllowThreads(__tstate);
19892 if (PyErr_Occurred()) SWIG_fail;
19893 }
19894 {
19895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19896 }
19897 return resultobj;
19898 fail:
19899 return NULL;
19900 }
19901
19902
19903 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
19904 PyObject *resultobj;
19905 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
19906 bool result;
19907 PyObject * obj0 = 0 ;
19908 char *kwnames[] = {
19909 (char *) "self", NULL
19910 };
19911
19912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
19913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
19914 if (SWIG_arg_fail(1)) SWIG_fail;
19915 {
19916 PyThreadState* __tstate = wxPyBeginAllowThreads();
19917 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
19918
19919 wxPyEndAllowThreads(__tstate);
19920 if (PyErr_Occurred()) SWIG_fail;
19921 }
19922 {
19923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19924 }
19925 return resultobj;
19926 fail:
19927 return NULL;
19928 }
19929
19930
19931 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
19932 PyObject *obj;
19933 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19934 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
19935 Py_INCREF(obj);
19936 return Py_BuildValue((char *)"");
19937 }
19938 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19939 PyObject *resultobj;
19940 int arg1 = (int) 0 ;
19941 bool arg2 = (bool) false ;
19942 wxShowEvent *result;
19943 PyObject * obj0 = 0 ;
19944 PyObject * obj1 = 0 ;
19945 char *kwnames[] = {
19946 (char *) "winid",(char *) "show", NULL
19947 };
19948
19949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
19950 if (obj0) {
19951 {
19952 arg1 = (int)(SWIG_As_int(obj0));
19953 if (SWIG_arg_fail(1)) SWIG_fail;
19954 }
19955 }
19956 if (obj1) {
19957 {
19958 arg2 = (bool)(SWIG_As_bool(obj1));
19959 if (SWIG_arg_fail(2)) SWIG_fail;
19960 }
19961 }
19962 {
19963 PyThreadState* __tstate = wxPyBeginAllowThreads();
19964 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
19965
19966 wxPyEndAllowThreads(__tstate);
19967 if (PyErr_Occurred()) SWIG_fail;
19968 }
19969 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
19970 return resultobj;
19971 fail:
19972 return NULL;
19973 }
19974
19975
19976 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
19977 PyObject *resultobj;
19978 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
19979 bool arg2 ;
19980 PyObject * obj0 = 0 ;
19981 PyObject * obj1 = 0 ;
19982 char *kwnames[] = {
19983 (char *) "self",(char *) "show", NULL
19984 };
19985
19986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
19987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
19988 if (SWIG_arg_fail(1)) SWIG_fail;
19989 {
19990 arg2 = (bool)(SWIG_As_bool(obj1));
19991 if (SWIG_arg_fail(2)) SWIG_fail;
19992 }
19993 {
19994 PyThreadState* __tstate = wxPyBeginAllowThreads();
19995 (arg1)->SetShow(arg2);
19996
19997 wxPyEndAllowThreads(__tstate);
19998 if (PyErr_Occurred()) SWIG_fail;
19999 }
20000 Py_INCREF(Py_None); resultobj = Py_None;
20001 return resultobj;
20002 fail:
20003 return NULL;
20004 }
20005
20006
20007 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20008 PyObject *resultobj;
20009 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20010 bool result;
20011 PyObject * obj0 = 0 ;
20012 char *kwnames[] = {
20013 (char *) "self", NULL
20014 };
20015
20016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20018 if (SWIG_arg_fail(1)) SWIG_fail;
20019 {
20020 PyThreadState* __tstate = wxPyBeginAllowThreads();
20021 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20022
20023 wxPyEndAllowThreads(__tstate);
20024 if (PyErr_Occurred()) SWIG_fail;
20025 }
20026 {
20027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20028 }
20029 return resultobj;
20030 fail:
20031 return NULL;
20032 }
20033
20034
20035 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20036 PyObject *obj;
20037 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20038 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20039 Py_INCREF(obj);
20040 return Py_BuildValue((char *)"");
20041 }
20042 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20043 PyObject *resultobj;
20044 int arg1 = (int) 0 ;
20045 bool arg2 = (bool) true ;
20046 wxIconizeEvent *result;
20047 PyObject * obj0 = 0 ;
20048 PyObject * obj1 = 0 ;
20049 char *kwnames[] = {
20050 (char *) "id",(char *) "iconized", NULL
20051 };
20052
20053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20054 if (obj0) {
20055 {
20056 arg1 = (int)(SWIG_As_int(obj0));
20057 if (SWIG_arg_fail(1)) SWIG_fail;
20058 }
20059 }
20060 if (obj1) {
20061 {
20062 arg2 = (bool)(SWIG_As_bool(obj1));
20063 if (SWIG_arg_fail(2)) SWIG_fail;
20064 }
20065 }
20066 {
20067 PyThreadState* __tstate = wxPyBeginAllowThreads();
20068 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20069
20070 wxPyEndAllowThreads(__tstate);
20071 if (PyErr_Occurred()) SWIG_fail;
20072 }
20073 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20074 return resultobj;
20075 fail:
20076 return NULL;
20077 }
20078
20079
20080 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20081 PyObject *resultobj;
20082 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20083 bool result;
20084 PyObject * obj0 = 0 ;
20085 char *kwnames[] = {
20086 (char *) "self", NULL
20087 };
20088
20089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20091 if (SWIG_arg_fail(1)) SWIG_fail;
20092 {
20093 PyThreadState* __tstate = wxPyBeginAllowThreads();
20094 result = (bool)(arg1)->Iconized();
20095
20096 wxPyEndAllowThreads(__tstate);
20097 if (PyErr_Occurred()) SWIG_fail;
20098 }
20099 {
20100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20101 }
20102 return resultobj;
20103 fail:
20104 return NULL;
20105 }
20106
20107
20108 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20109 PyObject *obj;
20110 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20111 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20112 Py_INCREF(obj);
20113 return Py_BuildValue((char *)"");
20114 }
20115 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20116 PyObject *resultobj;
20117 int arg1 = (int) 0 ;
20118 wxMaximizeEvent *result;
20119 PyObject * obj0 = 0 ;
20120 char *kwnames[] = {
20121 (char *) "id", NULL
20122 };
20123
20124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20125 if (obj0) {
20126 {
20127 arg1 = (int)(SWIG_As_int(obj0));
20128 if (SWIG_arg_fail(1)) SWIG_fail;
20129 }
20130 }
20131 {
20132 PyThreadState* __tstate = wxPyBeginAllowThreads();
20133 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20134
20135 wxPyEndAllowThreads(__tstate);
20136 if (PyErr_Occurred()) SWIG_fail;
20137 }
20138 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20139 return resultobj;
20140 fail:
20141 return NULL;
20142 }
20143
20144
20145 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20146 PyObject *obj;
20147 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20148 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20149 Py_INCREF(obj);
20150 return Py_BuildValue((char *)"");
20151 }
20152 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20153 PyObject *resultobj;
20154 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20155 wxPoint result;
20156 PyObject * obj0 = 0 ;
20157 char *kwnames[] = {
20158 (char *) "self", NULL
20159 };
20160
20161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20162 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20163 if (SWIG_arg_fail(1)) SWIG_fail;
20164 {
20165 PyThreadState* __tstate = wxPyBeginAllowThreads();
20166 result = (arg1)->GetPosition();
20167
20168 wxPyEndAllowThreads(__tstate);
20169 if (PyErr_Occurred()) SWIG_fail;
20170 }
20171 {
20172 wxPoint * resultptr;
20173 resultptr = new wxPoint((wxPoint &)(result));
20174 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20175 }
20176 return resultobj;
20177 fail:
20178 return NULL;
20179 }
20180
20181
20182 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20183 PyObject *resultobj;
20184 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20185 int result;
20186 PyObject * obj0 = 0 ;
20187 char *kwnames[] = {
20188 (char *) "self", NULL
20189 };
20190
20191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20193 if (SWIG_arg_fail(1)) SWIG_fail;
20194 {
20195 PyThreadState* __tstate = wxPyBeginAllowThreads();
20196 result = (int)(arg1)->GetNumberOfFiles();
20197
20198 wxPyEndAllowThreads(__tstate);
20199 if (PyErr_Occurred()) SWIG_fail;
20200 }
20201 {
20202 resultobj = SWIG_From_int((int)(result));
20203 }
20204 return resultobj;
20205 fail:
20206 return NULL;
20207 }
20208
20209
20210 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20211 PyObject *resultobj;
20212 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20213 PyObject *result;
20214 PyObject * obj0 = 0 ;
20215 char *kwnames[] = {
20216 (char *) "self", NULL
20217 };
20218
20219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20221 if (SWIG_arg_fail(1)) SWIG_fail;
20222 {
20223 PyThreadState* __tstate = wxPyBeginAllowThreads();
20224 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20225
20226 wxPyEndAllowThreads(__tstate);
20227 if (PyErr_Occurred()) SWIG_fail;
20228 }
20229 resultobj = result;
20230 return resultobj;
20231 fail:
20232 return NULL;
20233 }
20234
20235
20236 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20237 PyObject *obj;
20238 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20239 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20240 Py_INCREF(obj);
20241 return Py_BuildValue((char *)"");
20242 }
20243 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20244 PyObject *resultobj;
20245 int arg1 = (int) 0 ;
20246 wxUpdateUIEvent *result;
20247 PyObject * obj0 = 0 ;
20248 char *kwnames[] = {
20249 (char *) "commandId", NULL
20250 };
20251
20252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20253 if (obj0) {
20254 {
20255 arg1 = (int)(SWIG_As_int(obj0));
20256 if (SWIG_arg_fail(1)) SWIG_fail;
20257 }
20258 }
20259 {
20260 PyThreadState* __tstate = wxPyBeginAllowThreads();
20261 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20262
20263 wxPyEndAllowThreads(__tstate);
20264 if (PyErr_Occurred()) SWIG_fail;
20265 }
20266 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20267 return resultobj;
20268 fail:
20269 return NULL;
20270 }
20271
20272
20273 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20274 PyObject *resultobj;
20275 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20276 bool result;
20277 PyObject * obj0 = 0 ;
20278 char *kwnames[] = {
20279 (char *) "self", NULL
20280 };
20281
20282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20284 if (SWIG_arg_fail(1)) SWIG_fail;
20285 {
20286 PyThreadState* __tstate = wxPyBeginAllowThreads();
20287 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20288
20289 wxPyEndAllowThreads(__tstate);
20290 if (PyErr_Occurred()) SWIG_fail;
20291 }
20292 {
20293 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20294 }
20295 return resultobj;
20296 fail:
20297 return NULL;
20298 }
20299
20300
20301 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20302 PyObject *resultobj;
20303 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20304 bool result;
20305 PyObject * obj0 = 0 ;
20306 char *kwnames[] = {
20307 (char *) "self", NULL
20308 };
20309
20310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20312 if (SWIG_arg_fail(1)) SWIG_fail;
20313 {
20314 PyThreadState* __tstate = wxPyBeginAllowThreads();
20315 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20316
20317 wxPyEndAllowThreads(__tstate);
20318 if (PyErr_Occurred()) SWIG_fail;
20319 }
20320 {
20321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20322 }
20323 return resultobj;
20324 fail:
20325 return NULL;
20326 }
20327
20328
20329 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20330 PyObject *resultobj;
20331 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20332 wxString result;
20333 PyObject * obj0 = 0 ;
20334 char *kwnames[] = {
20335 (char *) "self", NULL
20336 };
20337
20338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20340 if (SWIG_arg_fail(1)) SWIG_fail;
20341 {
20342 PyThreadState* __tstate = wxPyBeginAllowThreads();
20343 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20344
20345 wxPyEndAllowThreads(__tstate);
20346 if (PyErr_Occurred()) SWIG_fail;
20347 }
20348 {
20349 #if wxUSE_UNICODE
20350 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20351 #else
20352 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20353 #endif
20354 }
20355 return resultobj;
20356 fail:
20357 return NULL;
20358 }
20359
20360
20361 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20362 PyObject *resultobj;
20363 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20364 bool result;
20365 PyObject * obj0 = 0 ;
20366 char *kwnames[] = {
20367 (char *) "self", NULL
20368 };
20369
20370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20372 if (SWIG_arg_fail(1)) SWIG_fail;
20373 {
20374 PyThreadState* __tstate = wxPyBeginAllowThreads();
20375 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
20376
20377 wxPyEndAllowThreads(__tstate);
20378 if (PyErr_Occurred()) SWIG_fail;
20379 }
20380 {
20381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20382 }
20383 return resultobj;
20384 fail:
20385 return NULL;
20386 }
20387
20388
20389 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20390 PyObject *resultobj;
20391 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20392 bool result;
20393 PyObject * obj0 = 0 ;
20394 char *kwnames[] = {
20395 (char *) "self", NULL
20396 };
20397
20398 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20399 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20400 if (SWIG_arg_fail(1)) SWIG_fail;
20401 {
20402 PyThreadState* __tstate = wxPyBeginAllowThreads();
20403 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20404
20405 wxPyEndAllowThreads(__tstate);
20406 if (PyErr_Occurred()) SWIG_fail;
20407 }
20408 {
20409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20410 }
20411 return resultobj;
20412 fail:
20413 return NULL;
20414 }
20415
20416
20417 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20418 PyObject *resultobj;
20419 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20420 bool result;
20421 PyObject * obj0 = 0 ;
20422 char *kwnames[] = {
20423 (char *) "self", NULL
20424 };
20425
20426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20428 if (SWIG_arg_fail(1)) SWIG_fail;
20429 {
20430 PyThreadState* __tstate = wxPyBeginAllowThreads();
20431 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20432
20433 wxPyEndAllowThreads(__tstate);
20434 if (PyErr_Occurred()) SWIG_fail;
20435 }
20436 {
20437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20438 }
20439 return resultobj;
20440 fail:
20441 return NULL;
20442 }
20443
20444
20445 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20446 PyObject *resultobj;
20447 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20448 bool arg2 ;
20449 PyObject * obj0 = 0 ;
20450 PyObject * obj1 = 0 ;
20451 char *kwnames[] = {
20452 (char *) "self",(char *) "check", NULL
20453 };
20454
20455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20457 if (SWIG_arg_fail(1)) SWIG_fail;
20458 {
20459 arg2 = (bool)(SWIG_As_bool(obj1));
20460 if (SWIG_arg_fail(2)) SWIG_fail;
20461 }
20462 {
20463 PyThreadState* __tstate = wxPyBeginAllowThreads();
20464 (arg1)->Check(arg2);
20465
20466 wxPyEndAllowThreads(__tstate);
20467 if (PyErr_Occurred()) SWIG_fail;
20468 }
20469 Py_INCREF(Py_None); resultobj = Py_None;
20470 return resultobj;
20471 fail:
20472 return NULL;
20473 }
20474
20475
20476 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
20477 PyObject *resultobj;
20478 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20479 bool arg2 ;
20480 PyObject * obj0 = 0 ;
20481 PyObject * obj1 = 0 ;
20482 char *kwnames[] = {
20483 (char *) "self",(char *) "enable", NULL
20484 };
20485
20486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
20487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20488 if (SWIG_arg_fail(1)) SWIG_fail;
20489 {
20490 arg2 = (bool)(SWIG_As_bool(obj1));
20491 if (SWIG_arg_fail(2)) SWIG_fail;
20492 }
20493 {
20494 PyThreadState* __tstate = wxPyBeginAllowThreads();
20495 (arg1)->Enable(arg2);
20496
20497 wxPyEndAllowThreads(__tstate);
20498 if (PyErr_Occurred()) SWIG_fail;
20499 }
20500 Py_INCREF(Py_None); resultobj = Py_None;
20501 return resultobj;
20502 fail:
20503 return NULL;
20504 }
20505
20506
20507 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
20508 PyObject *resultobj;
20509 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20510 wxString *arg2 = 0 ;
20511 bool temp2 = false ;
20512 PyObject * obj0 = 0 ;
20513 PyObject * obj1 = 0 ;
20514 char *kwnames[] = {
20515 (char *) "self",(char *) "text", NULL
20516 };
20517
20518 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
20519 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20520 if (SWIG_arg_fail(1)) SWIG_fail;
20521 {
20522 arg2 = wxString_in_helper(obj1);
20523 if (arg2 == NULL) SWIG_fail;
20524 temp2 = true;
20525 }
20526 {
20527 PyThreadState* __tstate = wxPyBeginAllowThreads();
20528 (arg1)->SetText((wxString const &)*arg2);
20529
20530 wxPyEndAllowThreads(__tstate);
20531 if (PyErr_Occurred()) SWIG_fail;
20532 }
20533 Py_INCREF(Py_None); resultobj = Py_None;
20534 {
20535 if (temp2)
20536 delete arg2;
20537 }
20538 return resultobj;
20539 fail:
20540 {
20541 if (temp2)
20542 delete arg2;
20543 }
20544 return NULL;
20545 }
20546
20547
20548 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20549 PyObject *resultobj;
20550 long arg1 ;
20551 PyObject * obj0 = 0 ;
20552 char *kwnames[] = {
20553 (char *) "updateInterval", NULL
20554 };
20555
20556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
20557 {
20558 arg1 = (long)(SWIG_As_long(obj0));
20559 if (SWIG_arg_fail(1)) SWIG_fail;
20560 }
20561 {
20562 PyThreadState* __tstate = wxPyBeginAllowThreads();
20563 wxUpdateUIEvent::SetUpdateInterval(arg1);
20564
20565 wxPyEndAllowThreads(__tstate);
20566 if (PyErr_Occurred()) SWIG_fail;
20567 }
20568 Py_INCREF(Py_None); resultobj = Py_None;
20569 return resultobj;
20570 fail:
20571 return NULL;
20572 }
20573
20574
20575 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
20576 PyObject *resultobj;
20577 long result;
20578 char *kwnames[] = {
20579 NULL
20580 };
20581
20582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
20583 {
20584 PyThreadState* __tstate = wxPyBeginAllowThreads();
20585 result = (long)wxUpdateUIEvent::GetUpdateInterval();
20586
20587 wxPyEndAllowThreads(__tstate);
20588 if (PyErr_Occurred()) SWIG_fail;
20589 }
20590 {
20591 resultobj = SWIG_From_long((long)(result));
20592 }
20593 return resultobj;
20594 fail:
20595 return NULL;
20596 }
20597
20598
20599 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
20600 PyObject *resultobj;
20601 wxWindow *arg1 = (wxWindow *) 0 ;
20602 bool result;
20603 PyObject * obj0 = 0 ;
20604 char *kwnames[] = {
20605 (char *) "win", NULL
20606 };
20607
20608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
20609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20610 if (SWIG_arg_fail(1)) SWIG_fail;
20611 {
20612 PyThreadState* __tstate = wxPyBeginAllowThreads();
20613 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
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 *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
20628 PyObject *resultobj;
20629 char *kwnames[] = {
20630 NULL
20631 };
20632
20633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
20634 {
20635 PyThreadState* __tstate = wxPyBeginAllowThreads();
20636 wxUpdateUIEvent::ResetUpdateTime();
20637
20638 wxPyEndAllowThreads(__tstate);
20639 if (PyErr_Occurred()) SWIG_fail;
20640 }
20641 Py_INCREF(Py_None); resultobj = Py_None;
20642 return resultobj;
20643 fail:
20644 return NULL;
20645 }
20646
20647
20648 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20649 PyObject *resultobj;
20650 wxUpdateUIMode arg1 ;
20651 PyObject * obj0 = 0 ;
20652 char *kwnames[] = {
20653 (char *) "mode", NULL
20654 };
20655
20656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
20657 {
20658 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
20659 if (SWIG_arg_fail(1)) SWIG_fail;
20660 }
20661 {
20662 PyThreadState* __tstate = wxPyBeginAllowThreads();
20663 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
20664
20665 wxPyEndAllowThreads(__tstate);
20666 if (PyErr_Occurred()) SWIG_fail;
20667 }
20668 Py_INCREF(Py_None); resultobj = Py_None;
20669 return resultobj;
20670 fail:
20671 return NULL;
20672 }
20673
20674
20675 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
20676 PyObject *resultobj;
20677 wxUpdateUIMode result;
20678 char *kwnames[] = {
20679 NULL
20680 };
20681
20682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
20683 {
20684 PyThreadState* __tstate = wxPyBeginAllowThreads();
20685 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
20686
20687 wxPyEndAllowThreads(__tstate);
20688 if (PyErr_Occurred()) SWIG_fail;
20689 }
20690 resultobj = SWIG_From_int((result));
20691 return resultobj;
20692 fail:
20693 return NULL;
20694 }
20695
20696
20697 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
20698 PyObject *obj;
20699 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20700 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
20701 Py_INCREF(obj);
20702 return Py_BuildValue((char *)"");
20703 }
20704 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20705 PyObject *resultobj;
20706 wxSysColourChangedEvent *result;
20707 char *kwnames[] = {
20708 NULL
20709 };
20710
20711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
20712 {
20713 PyThreadState* __tstate = wxPyBeginAllowThreads();
20714 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
20715
20716 wxPyEndAllowThreads(__tstate);
20717 if (PyErr_Occurred()) SWIG_fail;
20718 }
20719 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
20720 return resultobj;
20721 fail:
20722 return NULL;
20723 }
20724
20725
20726 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
20727 PyObject *obj;
20728 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20729 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
20730 Py_INCREF(obj);
20731 return Py_BuildValue((char *)"");
20732 }
20733 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20734 PyObject *resultobj;
20735 int arg1 = (int) 0 ;
20736 wxWindow *arg2 = (wxWindow *) NULL ;
20737 wxMouseCaptureChangedEvent *result;
20738 PyObject * obj0 = 0 ;
20739 PyObject * obj1 = 0 ;
20740 char *kwnames[] = {
20741 (char *) "winid",(char *) "gainedCapture", NULL
20742 };
20743
20744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
20745 if (obj0) {
20746 {
20747 arg1 = (int)(SWIG_As_int(obj0));
20748 if (SWIG_arg_fail(1)) SWIG_fail;
20749 }
20750 }
20751 if (obj1) {
20752 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20753 if (SWIG_arg_fail(2)) SWIG_fail;
20754 }
20755 {
20756 PyThreadState* __tstate = wxPyBeginAllowThreads();
20757 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
20758
20759 wxPyEndAllowThreads(__tstate);
20760 if (PyErr_Occurred()) SWIG_fail;
20761 }
20762 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
20763 return resultobj;
20764 fail:
20765 return NULL;
20766 }
20767
20768
20769 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20770 PyObject *resultobj;
20771 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
20772 wxWindow *result;
20773 PyObject * obj0 = 0 ;
20774 char *kwnames[] = {
20775 (char *) "self", NULL
20776 };
20777
20778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
20779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20780 if (SWIG_arg_fail(1)) SWIG_fail;
20781 {
20782 PyThreadState* __tstate = wxPyBeginAllowThreads();
20783 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
20784
20785 wxPyEndAllowThreads(__tstate);
20786 if (PyErr_Occurred()) SWIG_fail;
20787 }
20788 {
20789 resultobj = wxPyMake_wxObject(result, 0);
20790 }
20791 return resultobj;
20792 fail:
20793 return NULL;
20794 }
20795
20796
20797 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
20798 PyObject *obj;
20799 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20800 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
20801 Py_INCREF(obj);
20802 return Py_BuildValue((char *)"");
20803 }
20804 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20805 PyObject *resultobj;
20806 wxDisplayChangedEvent *result;
20807 char *kwnames[] = {
20808 NULL
20809 };
20810
20811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
20812 {
20813 PyThreadState* __tstate = wxPyBeginAllowThreads();
20814 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
20815
20816 wxPyEndAllowThreads(__tstate);
20817 if (PyErr_Occurred()) SWIG_fail;
20818 }
20819 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
20820 return resultobj;
20821 fail:
20822 return NULL;
20823 }
20824
20825
20826 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
20827 PyObject *obj;
20828 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20829 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
20830 Py_INCREF(obj);
20831 return Py_BuildValue((char *)"");
20832 }
20833 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20834 PyObject *resultobj;
20835 int arg1 = (int) 0 ;
20836 wxPaletteChangedEvent *result;
20837 PyObject * obj0 = 0 ;
20838 char *kwnames[] = {
20839 (char *) "id", NULL
20840 };
20841
20842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
20843 if (obj0) {
20844 {
20845 arg1 = (int)(SWIG_As_int(obj0));
20846 if (SWIG_arg_fail(1)) SWIG_fail;
20847 }
20848 }
20849 {
20850 PyThreadState* __tstate = wxPyBeginAllowThreads();
20851 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
20852
20853 wxPyEndAllowThreads(__tstate);
20854 if (PyErr_Occurred()) SWIG_fail;
20855 }
20856 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
20857 return resultobj;
20858 fail:
20859 return NULL;
20860 }
20861
20862
20863 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20864 PyObject *resultobj;
20865 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20866 wxWindow *arg2 = (wxWindow *) 0 ;
20867 PyObject * obj0 = 0 ;
20868 PyObject * obj1 = 0 ;
20869 char *kwnames[] = {
20870 (char *) "self",(char *) "win", NULL
20871 };
20872
20873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
20874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20875 if (SWIG_arg_fail(1)) SWIG_fail;
20876 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20877 if (SWIG_arg_fail(2)) SWIG_fail;
20878 {
20879 PyThreadState* __tstate = wxPyBeginAllowThreads();
20880 (arg1)->SetChangedWindow(arg2);
20881
20882 wxPyEndAllowThreads(__tstate);
20883 if (PyErr_Occurred()) SWIG_fail;
20884 }
20885 Py_INCREF(Py_None); resultobj = Py_None;
20886 return resultobj;
20887 fail:
20888 return NULL;
20889 }
20890
20891
20892 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20893 PyObject *resultobj;
20894 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
20895 wxWindow *result;
20896 PyObject * obj0 = 0 ;
20897 char *kwnames[] = {
20898 (char *) "self", NULL
20899 };
20900
20901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
20902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
20903 if (SWIG_arg_fail(1)) SWIG_fail;
20904 {
20905 PyThreadState* __tstate = wxPyBeginAllowThreads();
20906 result = (wxWindow *)(arg1)->GetChangedWindow();
20907
20908 wxPyEndAllowThreads(__tstate);
20909 if (PyErr_Occurred()) SWIG_fail;
20910 }
20911 {
20912 resultobj = wxPyMake_wxObject(result, 0);
20913 }
20914 return resultobj;
20915 fail:
20916 return NULL;
20917 }
20918
20919
20920 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
20921 PyObject *obj;
20922 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20923 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
20924 Py_INCREF(obj);
20925 return Py_BuildValue((char *)"");
20926 }
20927 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20928 PyObject *resultobj;
20929 int arg1 = (int) 0 ;
20930 wxQueryNewPaletteEvent *result;
20931 PyObject * obj0 = 0 ;
20932 char *kwnames[] = {
20933 (char *) "winid", NULL
20934 };
20935
20936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
20937 if (obj0) {
20938 {
20939 arg1 = (int)(SWIG_As_int(obj0));
20940 if (SWIG_arg_fail(1)) SWIG_fail;
20941 }
20942 }
20943 {
20944 PyThreadState* __tstate = wxPyBeginAllowThreads();
20945 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
20946
20947 wxPyEndAllowThreads(__tstate);
20948 if (PyErr_Occurred()) SWIG_fail;
20949 }
20950 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
20951 return resultobj;
20952 fail:
20953 return NULL;
20954 }
20955
20956
20957 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20958 PyObject *resultobj;
20959 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20960 bool arg2 ;
20961 PyObject * obj0 = 0 ;
20962 PyObject * obj1 = 0 ;
20963 char *kwnames[] = {
20964 (char *) "self",(char *) "realized", NULL
20965 };
20966
20967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
20968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
20969 if (SWIG_arg_fail(1)) SWIG_fail;
20970 {
20971 arg2 = (bool)(SWIG_As_bool(obj1));
20972 if (SWIG_arg_fail(2)) SWIG_fail;
20973 }
20974 {
20975 PyThreadState* __tstate = wxPyBeginAllowThreads();
20976 (arg1)->SetPaletteRealized(arg2);
20977
20978 wxPyEndAllowThreads(__tstate);
20979 if (PyErr_Occurred()) SWIG_fail;
20980 }
20981 Py_INCREF(Py_None); resultobj = Py_None;
20982 return resultobj;
20983 fail:
20984 return NULL;
20985 }
20986
20987
20988 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
20989 PyObject *resultobj;
20990 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
20991 bool result;
20992 PyObject * obj0 = 0 ;
20993 char *kwnames[] = {
20994 (char *) "self", NULL
20995 };
20996
20997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
20998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
20999 if (SWIG_arg_fail(1)) SWIG_fail;
21000 {
21001 PyThreadState* __tstate = wxPyBeginAllowThreads();
21002 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21003
21004 wxPyEndAllowThreads(__tstate);
21005 if (PyErr_Occurred()) SWIG_fail;
21006 }
21007 {
21008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21009 }
21010 return resultobj;
21011 fail:
21012 return NULL;
21013 }
21014
21015
21016 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21017 PyObject *obj;
21018 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21019 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21020 Py_INCREF(obj);
21021 return Py_BuildValue((char *)"");
21022 }
21023 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21024 PyObject *resultobj;
21025 wxNavigationKeyEvent *result;
21026 char *kwnames[] = {
21027 NULL
21028 };
21029
21030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21031 {
21032 PyThreadState* __tstate = wxPyBeginAllowThreads();
21033 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21034
21035 wxPyEndAllowThreads(__tstate);
21036 if (PyErr_Occurred()) SWIG_fail;
21037 }
21038 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21039 return resultobj;
21040 fail:
21041 return NULL;
21042 }
21043
21044
21045 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21046 PyObject *resultobj;
21047 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21048 bool result;
21049 PyObject * obj0 = 0 ;
21050 char *kwnames[] = {
21051 (char *) "self", NULL
21052 };
21053
21054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21056 if (SWIG_arg_fail(1)) SWIG_fail;
21057 {
21058 PyThreadState* __tstate = wxPyBeginAllowThreads();
21059 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21060
21061 wxPyEndAllowThreads(__tstate);
21062 if (PyErr_Occurred()) SWIG_fail;
21063 }
21064 {
21065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21066 }
21067 return resultobj;
21068 fail:
21069 return NULL;
21070 }
21071
21072
21073 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21074 PyObject *resultobj;
21075 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21076 bool arg2 ;
21077 PyObject * obj0 = 0 ;
21078 PyObject * obj1 = 0 ;
21079 char *kwnames[] = {
21080 (char *) "self",(char *) "forward", NULL
21081 };
21082
21083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21085 if (SWIG_arg_fail(1)) SWIG_fail;
21086 {
21087 arg2 = (bool)(SWIG_As_bool(obj1));
21088 if (SWIG_arg_fail(2)) SWIG_fail;
21089 }
21090 {
21091 PyThreadState* __tstate = wxPyBeginAllowThreads();
21092 (arg1)->SetDirection(arg2);
21093
21094 wxPyEndAllowThreads(__tstate);
21095 if (PyErr_Occurred()) SWIG_fail;
21096 }
21097 Py_INCREF(Py_None); resultobj = Py_None;
21098 return resultobj;
21099 fail:
21100 return NULL;
21101 }
21102
21103
21104 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21105 PyObject *resultobj;
21106 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21107 bool result;
21108 PyObject * obj0 = 0 ;
21109 char *kwnames[] = {
21110 (char *) "self", NULL
21111 };
21112
21113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21115 if (SWIG_arg_fail(1)) SWIG_fail;
21116 {
21117 PyThreadState* __tstate = wxPyBeginAllowThreads();
21118 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21119
21120 wxPyEndAllowThreads(__tstate);
21121 if (PyErr_Occurred()) SWIG_fail;
21122 }
21123 {
21124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21125 }
21126 return resultobj;
21127 fail:
21128 return NULL;
21129 }
21130
21131
21132 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21133 PyObject *resultobj;
21134 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21135 bool arg2 ;
21136 PyObject * obj0 = 0 ;
21137 PyObject * obj1 = 0 ;
21138 char *kwnames[] = {
21139 (char *) "self",(char *) "ischange", NULL
21140 };
21141
21142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21144 if (SWIG_arg_fail(1)) SWIG_fail;
21145 {
21146 arg2 = (bool)(SWIG_As_bool(obj1));
21147 if (SWIG_arg_fail(2)) SWIG_fail;
21148 }
21149 {
21150 PyThreadState* __tstate = wxPyBeginAllowThreads();
21151 (arg1)->SetWindowChange(arg2);
21152
21153 wxPyEndAllowThreads(__tstate);
21154 if (PyErr_Occurred()) SWIG_fail;
21155 }
21156 Py_INCREF(Py_None); resultobj = Py_None;
21157 return resultobj;
21158 fail:
21159 return NULL;
21160 }
21161
21162
21163 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21164 PyObject *resultobj;
21165 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21166 long arg2 ;
21167 PyObject * obj0 = 0 ;
21168 PyObject * obj1 = 0 ;
21169 char *kwnames[] = {
21170 (char *) "self",(char *) "flags", NULL
21171 };
21172
21173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21175 if (SWIG_arg_fail(1)) SWIG_fail;
21176 {
21177 arg2 = (long)(SWIG_As_long(obj1));
21178 if (SWIG_arg_fail(2)) SWIG_fail;
21179 }
21180 {
21181 PyThreadState* __tstate = wxPyBeginAllowThreads();
21182 (arg1)->SetFlags(arg2);
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_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21195 PyObject *resultobj;
21196 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21197 wxWindow *result;
21198 PyObject * obj0 = 0 ;
21199 char *kwnames[] = {
21200 (char *) "self", NULL
21201 };
21202
21203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21205 if (SWIG_arg_fail(1)) SWIG_fail;
21206 {
21207 PyThreadState* __tstate = wxPyBeginAllowThreads();
21208 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21209
21210 wxPyEndAllowThreads(__tstate);
21211 if (PyErr_Occurred()) SWIG_fail;
21212 }
21213 {
21214 resultobj = wxPyMake_wxObject(result, 0);
21215 }
21216 return resultobj;
21217 fail:
21218 return NULL;
21219 }
21220
21221
21222 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21223 PyObject *resultobj;
21224 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21225 wxWindow *arg2 = (wxWindow *) 0 ;
21226 PyObject * obj0 = 0 ;
21227 PyObject * obj1 = 0 ;
21228 char *kwnames[] = {
21229 (char *) "self",(char *) "win", NULL
21230 };
21231
21232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21234 if (SWIG_arg_fail(1)) SWIG_fail;
21235 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21236 if (SWIG_arg_fail(2)) SWIG_fail;
21237 {
21238 PyThreadState* __tstate = wxPyBeginAllowThreads();
21239 (arg1)->SetCurrentFocus(arg2);
21240
21241 wxPyEndAllowThreads(__tstate);
21242 if (PyErr_Occurred()) SWIG_fail;
21243 }
21244 Py_INCREF(Py_None); resultobj = Py_None;
21245 return resultobj;
21246 fail:
21247 return NULL;
21248 }
21249
21250
21251 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21252 PyObject *obj;
21253 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21254 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21255 Py_INCREF(obj);
21256 return Py_BuildValue((char *)"");
21257 }
21258 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21259 PyObject *resultobj;
21260 wxWindow *arg1 = (wxWindow *) NULL ;
21261 wxWindowCreateEvent *result;
21262 PyObject * obj0 = 0 ;
21263 char *kwnames[] = {
21264 (char *) "win", NULL
21265 };
21266
21267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21268 if (obj0) {
21269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21270 if (SWIG_arg_fail(1)) SWIG_fail;
21271 }
21272 {
21273 PyThreadState* __tstate = wxPyBeginAllowThreads();
21274 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21275
21276 wxPyEndAllowThreads(__tstate);
21277 if (PyErr_Occurred()) SWIG_fail;
21278 }
21279 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21280 return resultobj;
21281 fail:
21282 return NULL;
21283 }
21284
21285
21286 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21287 PyObject *resultobj;
21288 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21289 wxWindow *result;
21290 PyObject * obj0 = 0 ;
21291 char *kwnames[] = {
21292 (char *) "self", NULL
21293 };
21294
21295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21297 if (SWIG_arg_fail(1)) SWIG_fail;
21298 {
21299 PyThreadState* __tstate = wxPyBeginAllowThreads();
21300 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21301
21302 wxPyEndAllowThreads(__tstate);
21303 if (PyErr_Occurred()) SWIG_fail;
21304 }
21305 {
21306 resultobj = wxPyMake_wxObject(result, 0);
21307 }
21308 return resultobj;
21309 fail:
21310 return NULL;
21311 }
21312
21313
21314 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21315 PyObject *obj;
21316 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21317 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21318 Py_INCREF(obj);
21319 return Py_BuildValue((char *)"");
21320 }
21321 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21322 PyObject *resultobj;
21323 wxWindow *arg1 = (wxWindow *) NULL ;
21324 wxWindowDestroyEvent *result;
21325 PyObject * obj0 = 0 ;
21326 char *kwnames[] = {
21327 (char *) "win", NULL
21328 };
21329
21330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21331 if (obj0) {
21332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21333 if (SWIG_arg_fail(1)) SWIG_fail;
21334 }
21335 {
21336 PyThreadState* __tstate = wxPyBeginAllowThreads();
21337 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21338
21339 wxPyEndAllowThreads(__tstate);
21340 if (PyErr_Occurred()) SWIG_fail;
21341 }
21342 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21343 return resultobj;
21344 fail:
21345 return NULL;
21346 }
21347
21348
21349 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21350 PyObject *resultobj;
21351 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21352 wxWindow *result;
21353 PyObject * obj0 = 0 ;
21354 char *kwnames[] = {
21355 (char *) "self", NULL
21356 };
21357
21358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21360 if (SWIG_arg_fail(1)) SWIG_fail;
21361 {
21362 PyThreadState* __tstate = wxPyBeginAllowThreads();
21363 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21364
21365 wxPyEndAllowThreads(__tstate);
21366 if (PyErr_Occurred()) SWIG_fail;
21367 }
21368 {
21369 resultobj = wxPyMake_wxObject(result, 0);
21370 }
21371 return resultobj;
21372 fail:
21373 return NULL;
21374 }
21375
21376
21377 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21378 PyObject *obj;
21379 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21380 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21381 Py_INCREF(obj);
21382 return Py_BuildValue((char *)"");
21383 }
21384 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21385 PyObject *resultobj;
21386 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21387 int arg2 = (int) 0 ;
21388 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21389 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21390 wxContextMenuEvent *result;
21391 wxPoint temp3 ;
21392 PyObject * obj0 = 0 ;
21393 PyObject * obj1 = 0 ;
21394 PyObject * obj2 = 0 ;
21395 char *kwnames[] = {
21396 (char *) "type",(char *) "winid",(char *) "pt", NULL
21397 };
21398
21399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21400 if (obj0) {
21401 {
21402 arg1 = (wxEventType)(SWIG_As_int(obj0));
21403 if (SWIG_arg_fail(1)) SWIG_fail;
21404 }
21405 }
21406 if (obj1) {
21407 {
21408 arg2 = (int)(SWIG_As_int(obj1));
21409 if (SWIG_arg_fail(2)) SWIG_fail;
21410 }
21411 }
21412 if (obj2) {
21413 {
21414 arg3 = &temp3;
21415 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
21416 }
21417 }
21418 {
21419 PyThreadState* __tstate = wxPyBeginAllowThreads();
21420 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
21421
21422 wxPyEndAllowThreads(__tstate);
21423 if (PyErr_Occurred()) SWIG_fail;
21424 }
21425 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
21426 return resultobj;
21427 fail:
21428 return NULL;
21429 }
21430
21431
21432 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21433 PyObject *resultobj;
21434 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21435 wxPoint *result;
21436 PyObject * obj0 = 0 ;
21437 char *kwnames[] = {
21438 (char *) "self", NULL
21439 };
21440
21441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
21442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21443 if (SWIG_arg_fail(1)) SWIG_fail;
21444 {
21445 PyThreadState* __tstate = wxPyBeginAllowThreads();
21446 {
21447 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
21448 result = (wxPoint *) &_result_ref;
21449 }
21450
21451 wxPyEndAllowThreads(__tstate);
21452 if (PyErr_Occurred()) SWIG_fail;
21453 }
21454 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
21455 return resultobj;
21456 fail:
21457 return NULL;
21458 }
21459
21460
21461 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21462 PyObject *resultobj;
21463 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
21464 wxPoint *arg2 = 0 ;
21465 wxPoint temp2 ;
21466 PyObject * obj0 = 0 ;
21467 PyObject * obj1 = 0 ;
21468 char *kwnames[] = {
21469 (char *) "self",(char *) "pos", NULL
21470 };
21471
21472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
21473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
21474 if (SWIG_arg_fail(1)) SWIG_fail;
21475 {
21476 arg2 = &temp2;
21477 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
21478 }
21479 {
21480 PyThreadState* __tstate = wxPyBeginAllowThreads();
21481 (arg1)->SetPosition((wxPoint const &)*arg2);
21482
21483 wxPyEndAllowThreads(__tstate);
21484 if (PyErr_Occurred()) SWIG_fail;
21485 }
21486 Py_INCREF(Py_None); resultobj = Py_None;
21487 return resultobj;
21488 fail:
21489 return NULL;
21490 }
21491
21492
21493 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
21494 PyObject *obj;
21495 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21496 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
21497 Py_INCREF(obj);
21498 return Py_BuildValue((char *)"");
21499 }
21500 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21501 PyObject *resultobj;
21502 wxIdleEvent *result;
21503 char *kwnames[] = {
21504 NULL
21505 };
21506
21507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
21508 {
21509 PyThreadState* __tstate = wxPyBeginAllowThreads();
21510 result = (wxIdleEvent *)new wxIdleEvent();
21511
21512 wxPyEndAllowThreads(__tstate);
21513 if (PyErr_Occurred()) SWIG_fail;
21514 }
21515 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
21516 return resultobj;
21517 fail:
21518 return NULL;
21519 }
21520
21521
21522 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
21523 PyObject *resultobj;
21524 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21525 bool arg2 = (bool) true ;
21526 PyObject * obj0 = 0 ;
21527 PyObject * obj1 = 0 ;
21528 char *kwnames[] = {
21529 (char *) "self",(char *) "needMore", NULL
21530 };
21531
21532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
21533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21534 if (SWIG_arg_fail(1)) SWIG_fail;
21535 if (obj1) {
21536 {
21537 arg2 = (bool)(SWIG_As_bool(obj1));
21538 if (SWIG_arg_fail(2)) SWIG_fail;
21539 }
21540 }
21541 {
21542 PyThreadState* __tstate = wxPyBeginAllowThreads();
21543 (arg1)->RequestMore(arg2);
21544
21545 wxPyEndAllowThreads(__tstate);
21546 if (PyErr_Occurred()) SWIG_fail;
21547 }
21548 Py_INCREF(Py_None); resultobj = Py_None;
21549 return resultobj;
21550 fail:
21551 return NULL;
21552 }
21553
21554
21555 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
21556 PyObject *resultobj;
21557 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
21558 bool result;
21559 PyObject * obj0 = 0 ;
21560 char *kwnames[] = {
21561 (char *) "self", NULL
21562 };
21563
21564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
21565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
21566 if (SWIG_arg_fail(1)) SWIG_fail;
21567 {
21568 PyThreadState* __tstate = wxPyBeginAllowThreads();
21569 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
21570
21571 wxPyEndAllowThreads(__tstate);
21572 if (PyErr_Occurred()) SWIG_fail;
21573 }
21574 {
21575 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21576 }
21577 return resultobj;
21578 fail:
21579 return NULL;
21580 }
21581
21582
21583 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21584 PyObject *resultobj;
21585 wxIdleMode arg1 ;
21586 PyObject * obj0 = 0 ;
21587 char *kwnames[] = {
21588 (char *) "mode", NULL
21589 };
21590
21591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
21592 {
21593 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
21594 if (SWIG_arg_fail(1)) SWIG_fail;
21595 }
21596 {
21597 PyThreadState* __tstate = wxPyBeginAllowThreads();
21598 wxIdleEvent::SetMode((wxIdleMode )arg1);
21599
21600 wxPyEndAllowThreads(__tstate);
21601 if (PyErr_Occurred()) SWIG_fail;
21602 }
21603 Py_INCREF(Py_None); resultobj = Py_None;
21604 return resultobj;
21605 fail:
21606 return NULL;
21607 }
21608
21609
21610 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21611 PyObject *resultobj;
21612 wxIdleMode result;
21613 char *kwnames[] = {
21614 NULL
21615 };
21616
21617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
21618 {
21619 PyThreadState* __tstate = wxPyBeginAllowThreads();
21620 result = (wxIdleMode)wxIdleEvent::GetMode();
21621
21622 wxPyEndAllowThreads(__tstate);
21623 if (PyErr_Occurred()) SWIG_fail;
21624 }
21625 resultobj = SWIG_From_int((result));
21626 return resultobj;
21627 fail:
21628 return NULL;
21629 }
21630
21631
21632 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
21633 PyObject *resultobj;
21634 wxWindow *arg1 = (wxWindow *) 0 ;
21635 bool result;
21636 PyObject * obj0 = 0 ;
21637 char *kwnames[] = {
21638 (char *) "win", NULL
21639 };
21640
21641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
21642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21643 if (SWIG_arg_fail(1)) SWIG_fail;
21644 {
21645 PyThreadState* __tstate = wxPyBeginAllowThreads();
21646 result = (bool)wxIdleEvent::CanSend(arg1);
21647
21648 wxPyEndAllowThreads(__tstate);
21649 if (PyErr_Occurred()) SWIG_fail;
21650 }
21651 {
21652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21653 }
21654 return resultobj;
21655 fail:
21656 return NULL;
21657 }
21658
21659
21660 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
21661 PyObject *obj;
21662 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21663 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
21664 Py_INCREF(obj);
21665 return Py_BuildValue((char *)"");
21666 }
21667 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21668 PyObject *resultobj;
21669 int arg1 = (int) 0 ;
21670 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
21671 wxPyEvent *result;
21672 PyObject * obj0 = 0 ;
21673 PyObject * obj1 = 0 ;
21674 char *kwnames[] = {
21675 (char *) "winid",(char *) "commandType", NULL
21676 };
21677
21678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
21679 if (obj0) {
21680 {
21681 arg1 = (int)(SWIG_As_int(obj0));
21682 if (SWIG_arg_fail(1)) SWIG_fail;
21683 }
21684 }
21685 if (obj1) {
21686 {
21687 arg2 = (wxEventType)(SWIG_As_int(obj1));
21688 if (SWIG_arg_fail(2)) SWIG_fail;
21689 }
21690 }
21691 {
21692 PyThreadState* __tstate = wxPyBeginAllowThreads();
21693 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
21694
21695 wxPyEndAllowThreads(__tstate);
21696 if (PyErr_Occurred()) SWIG_fail;
21697 }
21698 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
21699 return resultobj;
21700 fail:
21701 return NULL;
21702 }
21703
21704
21705 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21706 PyObject *resultobj;
21707 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21708 PyObject * obj0 = 0 ;
21709 char *kwnames[] = {
21710 (char *) "self", NULL
21711 };
21712
21713 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
21714 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21715 if (SWIG_arg_fail(1)) SWIG_fail;
21716 {
21717 PyThreadState* __tstate = wxPyBeginAllowThreads();
21718 delete arg1;
21719
21720 wxPyEndAllowThreads(__tstate);
21721 if (PyErr_Occurred()) SWIG_fail;
21722 }
21723 Py_INCREF(Py_None); resultobj = Py_None;
21724 return resultobj;
21725 fail:
21726 return NULL;
21727 }
21728
21729
21730 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21731 PyObject *resultobj;
21732 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21733 PyObject *arg2 = (PyObject *) 0 ;
21734 PyObject * obj0 = 0 ;
21735 PyObject * obj1 = 0 ;
21736 char *kwnames[] = {
21737 (char *) "self",(char *) "self", NULL
21738 };
21739
21740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21742 if (SWIG_arg_fail(1)) SWIG_fail;
21743 arg2 = obj1;
21744 {
21745 PyThreadState* __tstate = wxPyBeginAllowThreads();
21746 (arg1)->SetSelf(arg2);
21747
21748 wxPyEndAllowThreads(__tstate);
21749 if (PyErr_Occurred()) SWIG_fail;
21750 }
21751 Py_INCREF(Py_None); resultobj = Py_None;
21752 return resultobj;
21753 fail:
21754 return NULL;
21755 }
21756
21757
21758 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21759 PyObject *resultobj;
21760 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
21761 PyObject *result;
21762 PyObject * obj0 = 0 ;
21763 char *kwnames[] = {
21764 (char *) "self", NULL
21765 };
21766
21767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
21768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
21769 if (SWIG_arg_fail(1)) SWIG_fail;
21770 {
21771 PyThreadState* __tstate = wxPyBeginAllowThreads();
21772 result = (PyObject *)(arg1)->GetSelf();
21773
21774 wxPyEndAllowThreads(__tstate);
21775 if (PyErr_Occurred()) SWIG_fail;
21776 }
21777 resultobj = result;
21778 return resultobj;
21779 fail:
21780 return NULL;
21781 }
21782
21783
21784 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
21785 PyObject *obj;
21786 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21787 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
21788 Py_INCREF(obj);
21789 return Py_BuildValue((char *)"");
21790 }
21791 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21792 PyObject *resultobj;
21793 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21794 int arg2 = (int) 0 ;
21795 wxPyCommandEvent *result;
21796 PyObject * obj0 = 0 ;
21797 PyObject * obj1 = 0 ;
21798 char *kwnames[] = {
21799 (char *) "commandType",(char *) "id", NULL
21800 };
21801
21802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
21803 if (obj0) {
21804 {
21805 arg1 = (wxEventType)(SWIG_As_int(obj0));
21806 if (SWIG_arg_fail(1)) SWIG_fail;
21807 }
21808 }
21809 if (obj1) {
21810 {
21811 arg2 = (int)(SWIG_As_int(obj1));
21812 if (SWIG_arg_fail(2)) SWIG_fail;
21813 }
21814 }
21815 {
21816 PyThreadState* __tstate = wxPyBeginAllowThreads();
21817 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
21818
21819 wxPyEndAllowThreads(__tstate);
21820 if (PyErr_Occurred()) SWIG_fail;
21821 }
21822 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
21823 return resultobj;
21824 fail:
21825 return NULL;
21826 }
21827
21828
21829 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21830 PyObject *resultobj;
21831 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21832 PyObject * obj0 = 0 ;
21833 char *kwnames[] = {
21834 (char *) "self", NULL
21835 };
21836
21837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
21838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21839 if (SWIG_arg_fail(1)) SWIG_fail;
21840 {
21841 PyThreadState* __tstate = wxPyBeginAllowThreads();
21842 delete arg1;
21843
21844 wxPyEndAllowThreads(__tstate);
21845 if (PyErr_Occurred()) SWIG_fail;
21846 }
21847 Py_INCREF(Py_None); resultobj = Py_None;
21848 return resultobj;
21849 fail:
21850 return NULL;
21851 }
21852
21853
21854 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21855 PyObject *resultobj;
21856 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21857 PyObject *arg2 = (PyObject *) 0 ;
21858 PyObject * obj0 = 0 ;
21859 PyObject * obj1 = 0 ;
21860 char *kwnames[] = {
21861 (char *) "self",(char *) "self", NULL
21862 };
21863
21864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
21865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21866 if (SWIG_arg_fail(1)) SWIG_fail;
21867 arg2 = obj1;
21868 {
21869 PyThreadState* __tstate = wxPyBeginAllowThreads();
21870 (arg1)->SetSelf(arg2);
21871
21872 wxPyEndAllowThreads(__tstate);
21873 if (PyErr_Occurred()) SWIG_fail;
21874 }
21875 Py_INCREF(Py_None); resultobj = Py_None;
21876 return resultobj;
21877 fail:
21878 return NULL;
21879 }
21880
21881
21882 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
21883 PyObject *resultobj;
21884 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
21885 PyObject *result;
21886 PyObject * obj0 = 0 ;
21887 char *kwnames[] = {
21888 (char *) "self", NULL
21889 };
21890
21891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
21892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
21893 if (SWIG_arg_fail(1)) SWIG_fail;
21894 {
21895 PyThreadState* __tstate = wxPyBeginAllowThreads();
21896 result = (PyObject *)(arg1)->GetSelf();
21897
21898 wxPyEndAllowThreads(__tstate);
21899 if (PyErr_Occurred()) SWIG_fail;
21900 }
21901 resultobj = result;
21902 return resultobj;
21903 fail:
21904 return NULL;
21905 }
21906
21907
21908 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
21909 PyObject *obj;
21910 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21911 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
21912 Py_INCREF(obj);
21913 return Py_BuildValue((char *)"");
21914 }
21915 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21916 PyObject *resultobj;
21917 wxWindow *arg1 = (wxWindow *) 0 ;
21918 wxDateTime *arg2 = 0 ;
21919 wxEventType arg3 ;
21920 wxDateEvent *result;
21921 PyObject * obj0 = 0 ;
21922 PyObject * obj1 = 0 ;
21923 PyObject * obj2 = 0 ;
21924 char *kwnames[] = {
21925 (char *) "win",(char *) "dt",(char *) "type", NULL
21926 };
21927
21928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21930 if (SWIG_arg_fail(1)) SWIG_fail;
21931 {
21932 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
21933 if (SWIG_arg_fail(2)) SWIG_fail;
21934 if (arg2 == NULL) {
21935 SWIG_null_ref("wxDateTime");
21936 }
21937 if (SWIG_arg_fail(2)) SWIG_fail;
21938 }
21939 {
21940 arg3 = (wxEventType)(SWIG_As_int(obj2));
21941 if (SWIG_arg_fail(3)) SWIG_fail;
21942 }
21943 {
21944 PyThreadState* __tstate = wxPyBeginAllowThreads();
21945 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
21946
21947 wxPyEndAllowThreads(__tstate);
21948 if (PyErr_Occurred()) SWIG_fail;
21949 }
21950 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
21951 return resultobj;
21952 fail:
21953 return NULL;
21954 }
21955
21956
21957 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
21958 PyObject *resultobj;
21959 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
21960 wxDateTime *result;
21961 PyObject * obj0 = 0 ;
21962 char *kwnames[] = {
21963 (char *) "self", NULL
21964 };
21965
21966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
21967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
21968 if (SWIG_arg_fail(1)) SWIG_fail;
21969 {
21970 PyThreadState* __tstate = wxPyBeginAllowThreads();
21971 {
21972 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
21973 result = (wxDateTime *) &_result_ref;
21974 }
21975
21976 wxPyEndAllowThreads(__tstate);
21977 if (PyErr_Occurred()) SWIG_fail;
21978 }
21979 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
21980 return resultobj;
21981 fail:
21982 return NULL;
21983 }
21984
21985
21986 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
21987 PyObject *resultobj;
21988 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
21989 wxDateTime *arg2 = 0 ;
21990 PyObject * obj0 = 0 ;
21991 PyObject * obj1 = 0 ;
21992 char *kwnames[] = {
21993 (char *) "self",(char *) "date", NULL
21994 };
21995
21996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
21997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
21998 if (SWIG_arg_fail(1)) SWIG_fail;
21999 {
22000 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22001 if (SWIG_arg_fail(2)) SWIG_fail;
22002 if (arg2 == NULL) {
22003 SWIG_null_ref("wxDateTime");
22004 }
22005 if (SWIG_arg_fail(2)) SWIG_fail;
22006 }
22007 {
22008 PyThreadState* __tstate = wxPyBeginAllowThreads();
22009 (arg1)->SetDate((wxDateTime const &)*arg2);
22010
22011 wxPyEndAllowThreads(__tstate);
22012 if (PyErr_Occurred()) SWIG_fail;
22013 }
22014 Py_INCREF(Py_None); resultobj = Py_None;
22015 return resultobj;
22016 fail:
22017 return NULL;
22018 }
22019
22020
22021 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22022 PyObject *obj;
22023 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22024 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22025 Py_INCREF(obj);
22026 return Py_BuildValue((char *)"");
22027 }
22028 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22029 PyObject *resultobj;
22030 wxPyApp *result;
22031 char *kwnames[] = {
22032 NULL
22033 };
22034
22035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22036 {
22037 PyThreadState* __tstate = wxPyBeginAllowThreads();
22038 result = (wxPyApp *)new_wxPyApp();
22039
22040 wxPyEndAllowThreads(__tstate);
22041 if (PyErr_Occurred()) SWIG_fail;
22042 }
22043 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22044 return resultobj;
22045 fail:
22046 return NULL;
22047 }
22048
22049
22050 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22051 PyObject *resultobj;
22052 wxPyApp *arg1 = (wxPyApp *) 0 ;
22053 PyObject * obj0 = 0 ;
22054 char *kwnames[] = {
22055 (char *) "self", NULL
22056 };
22057
22058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22060 if (SWIG_arg_fail(1)) SWIG_fail;
22061 {
22062 PyThreadState* __tstate = wxPyBeginAllowThreads();
22063 delete arg1;
22064
22065 wxPyEndAllowThreads(__tstate);
22066 if (PyErr_Occurred()) SWIG_fail;
22067 }
22068 Py_INCREF(Py_None); resultobj = Py_None;
22069 return resultobj;
22070 fail:
22071 return NULL;
22072 }
22073
22074
22075 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22076 PyObject *resultobj;
22077 wxPyApp *arg1 = (wxPyApp *) 0 ;
22078 PyObject *arg2 = (PyObject *) 0 ;
22079 PyObject *arg3 = (PyObject *) 0 ;
22080 PyObject * obj0 = 0 ;
22081 PyObject * obj1 = 0 ;
22082 PyObject * obj2 = 0 ;
22083 char *kwnames[] = {
22084 (char *) "self",(char *) "self",(char *) "_class", NULL
22085 };
22086
22087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22089 if (SWIG_arg_fail(1)) SWIG_fail;
22090 arg2 = obj1;
22091 arg3 = obj2;
22092 {
22093 PyThreadState* __tstate = wxPyBeginAllowThreads();
22094 (arg1)->_setCallbackInfo(arg2,arg3);
22095
22096 wxPyEndAllowThreads(__tstate);
22097 if (PyErr_Occurred()) SWIG_fail;
22098 }
22099 Py_INCREF(Py_None); resultobj = Py_None;
22100 return resultobj;
22101 fail:
22102 return NULL;
22103 }
22104
22105
22106 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22107 PyObject *resultobj;
22108 wxPyApp *arg1 = (wxPyApp *) 0 ;
22109 wxString result;
22110 PyObject * obj0 = 0 ;
22111 char *kwnames[] = {
22112 (char *) "self", NULL
22113 };
22114
22115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22117 if (SWIG_arg_fail(1)) SWIG_fail;
22118 {
22119 PyThreadState* __tstate = wxPyBeginAllowThreads();
22120 result = ((wxPyApp const *)arg1)->GetAppName();
22121
22122 wxPyEndAllowThreads(__tstate);
22123 if (PyErr_Occurred()) SWIG_fail;
22124 }
22125 {
22126 #if wxUSE_UNICODE
22127 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22128 #else
22129 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22130 #endif
22131 }
22132 return resultobj;
22133 fail:
22134 return NULL;
22135 }
22136
22137
22138 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22139 PyObject *resultobj;
22140 wxPyApp *arg1 = (wxPyApp *) 0 ;
22141 wxString *arg2 = 0 ;
22142 bool temp2 = false ;
22143 PyObject * obj0 = 0 ;
22144 PyObject * obj1 = 0 ;
22145 char *kwnames[] = {
22146 (char *) "self",(char *) "name", NULL
22147 };
22148
22149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22151 if (SWIG_arg_fail(1)) SWIG_fail;
22152 {
22153 arg2 = wxString_in_helper(obj1);
22154 if (arg2 == NULL) SWIG_fail;
22155 temp2 = true;
22156 }
22157 {
22158 PyThreadState* __tstate = wxPyBeginAllowThreads();
22159 (arg1)->SetAppName((wxString const &)*arg2);
22160
22161 wxPyEndAllowThreads(__tstate);
22162 if (PyErr_Occurred()) SWIG_fail;
22163 }
22164 Py_INCREF(Py_None); resultobj = Py_None;
22165 {
22166 if (temp2)
22167 delete arg2;
22168 }
22169 return resultobj;
22170 fail:
22171 {
22172 if (temp2)
22173 delete arg2;
22174 }
22175 return NULL;
22176 }
22177
22178
22179 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22180 PyObject *resultobj;
22181 wxPyApp *arg1 = (wxPyApp *) 0 ;
22182 wxString result;
22183 PyObject * obj0 = 0 ;
22184 char *kwnames[] = {
22185 (char *) "self", NULL
22186 };
22187
22188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22190 if (SWIG_arg_fail(1)) SWIG_fail;
22191 {
22192 PyThreadState* __tstate = wxPyBeginAllowThreads();
22193 result = ((wxPyApp const *)arg1)->GetClassName();
22194
22195 wxPyEndAllowThreads(__tstate);
22196 if (PyErr_Occurred()) SWIG_fail;
22197 }
22198 {
22199 #if wxUSE_UNICODE
22200 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22201 #else
22202 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22203 #endif
22204 }
22205 return resultobj;
22206 fail:
22207 return NULL;
22208 }
22209
22210
22211 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22212 PyObject *resultobj;
22213 wxPyApp *arg1 = (wxPyApp *) 0 ;
22214 wxString *arg2 = 0 ;
22215 bool temp2 = false ;
22216 PyObject * obj0 = 0 ;
22217 PyObject * obj1 = 0 ;
22218 char *kwnames[] = {
22219 (char *) "self",(char *) "name", NULL
22220 };
22221
22222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22224 if (SWIG_arg_fail(1)) SWIG_fail;
22225 {
22226 arg2 = wxString_in_helper(obj1);
22227 if (arg2 == NULL) SWIG_fail;
22228 temp2 = true;
22229 }
22230 {
22231 PyThreadState* __tstate = wxPyBeginAllowThreads();
22232 (arg1)->SetClassName((wxString const &)*arg2);
22233
22234 wxPyEndAllowThreads(__tstate);
22235 if (PyErr_Occurred()) SWIG_fail;
22236 }
22237 Py_INCREF(Py_None); resultobj = Py_None;
22238 {
22239 if (temp2)
22240 delete arg2;
22241 }
22242 return resultobj;
22243 fail:
22244 {
22245 if (temp2)
22246 delete arg2;
22247 }
22248 return NULL;
22249 }
22250
22251
22252 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22253 PyObject *resultobj;
22254 wxPyApp *arg1 = (wxPyApp *) 0 ;
22255 wxString *result;
22256 PyObject * obj0 = 0 ;
22257 char *kwnames[] = {
22258 (char *) "self", NULL
22259 };
22260
22261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22263 if (SWIG_arg_fail(1)) SWIG_fail;
22264 {
22265 PyThreadState* __tstate = wxPyBeginAllowThreads();
22266 {
22267 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22268 result = (wxString *) &_result_ref;
22269 }
22270
22271 wxPyEndAllowThreads(__tstate);
22272 if (PyErr_Occurred()) SWIG_fail;
22273 }
22274 {
22275 #if wxUSE_UNICODE
22276 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22277 #else
22278 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22279 #endif
22280 }
22281 return resultobj;
22282 fail:
22283 return NULL;
22284 }
22285
22286
22287 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22288 PyObject *resultobj;
22289 wxPyApp *arg1 = (wxPyApp *) 0 ;
22290 wxString *arg2 = 0 ;
22291 bool temp2 = false ;
22292 PyObject * obj0 = 0 ;
22293 PyObject * obj1 = 0 ;
22294 char *kwnames[] = {
22295 (char *) "self",(char *) "name", NULL
22296 };
22297
22298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22300 if (SWIG_arg_fail(1)) SWIG_fail;
22301 {
22302 arg2 = wxString_in_helper(obj1);
22303 if (arg2 == NULL) SWIG_fail;
22304 temp2 = true;
22305 }
22306 {
22307 PyThreadState* __tstate = wxPyBeginAllowThreads();
22308 (arg1)->SetVendorName((wxString const &)*arg2);
22309
22310 wxPyEndAllowThreads(__tstate);
22311 if (PyErr_Occurred()) SWIG_fail;
22312 }
22313 Py_INCREF(Py_None); resultobj = Py_None;
22314 {
22315 if (temp2)
22316 delete arg2;
22317 }
22318 return resultobj;
22319 fail:
22320 {
22321 if (temp2)
22322 delete arg2;
22323 }
22324 return NULL;
22325 }
22326
22327
22328 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22329 PyObject *resultobj;
22330 wxPyApp *arg1 = (wxPyApp *) 0 ;
22331 wxAppTraits *result;
22332 PyObject * obj0 = 0 ;
22333 char *kwnames[] = {
22334 (char *) "self", NULL
22335 };
22336
22337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22339 if (SWIG_arg_fail(1)) SWIG_fail;
22340 {
22341 PyThreadState* __tstate = wxPyBeginAllowThreads();
22342 result = (wxAppTraits *)(arg1)->GetTraits();
22343
22344 wxPyEndAllowThreads(__tstate);
22345 if (PyErr_Occurred()) SWIG_fail;
22346 }
22347 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22348 return resultobj;
22349 fail:
22350 return NULL;
22351 }
22352
22353
22354 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22355 PyObject *resultobj;
22356 wxPyApp *arg1 = (wxPyApp *) 0 ;
22357 PyObject * obj0 = 0 ;
22358 char *kwnames[] = {
22359 (char *) "self", NULL
22360 };
22361
22362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22364 if (SWIG_arg_fail(1)) SWIG_fail;
22365 {
22366 PyThreadState* __tstate = wxPyBeginAllowThreads();
22367 (arg1)->ProcessPendingEvents();
22368
22369 wxPyEndAllowThreads(__tstate);
22370 if (PyErr_Occurred()) SWIG_fail;
22371 }
22372 Py_INCREF(Py_None); resultobj = Py_None;
22373 return resultobj;
22374 fail:
22375 return NULL;
22376 }
22377
22378
22379 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22380 PyObject *resultobj;
22381 wxPyApp *arg1 = (wxPyApp *) 0 ;
22382 bool arg2 = (bool) false ;
22383 bool result;
22384 PyObject * obj0 = 0 ;
22385 PyObject * obj1 = 0 ;
22386 char *kwnames[] = {
22387 (char *) "self",(char *) "onlyIfNeeded", NULL
22388 };
22389
22390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22392 if (SWIG_arg_fail(1)) SWIG_fail;
22393 if (obj1) {
22394 {
22395 arg2 = (bool)(SWIG_As_bool(obj1));
22396 if (SWIG_arg_fail(2)) SWIG_fail;
22397 }
22398 }
22399 {
22400 PyThreadState* __tstate = wxPyBeginAllowThreads();
22401 result = (bool)(arg1)->Yield(arg2);
22402
22403 wxPyEndAllowThreads(__tstate);
22404 if (PyErr_Occurred()) SWIG_fail;
22405 }
22406 {
22407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22408 }
22409 return resultobj;
22410 fail:
22411 return NULL;
22412 }
22413
22414
22415 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22416 PyObject *resultobj;
22417 wxPyApp *arg1 = (wxPyApp *) 0 ;
22418 PyObject * obj0 = 0 ;
22419 char *kwnames[] = {
22420 (char *) "self", NULL
22421 };
22422
22423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
22424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22425 if (SWIG_arg_fail(1)) SWIG_fail;
22426 {
22427 PyThreadState* __tstate = wxPyBeginAllowThreads();
22428 (arg1)->WakeUpIdle();
22429
22430 wxPyEndAllowThreads(__tstate);
22431 if (PyErr_Occurred()) SWIG_fail;
22432 }
22433 Py_INCREF(Py_None); resultobj = Py_None;
22434 return resultobj;
22435 fail:
22436 return NULL;
22437 }
22438
22439
22440 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
22441 PyObject *resultobj;
22442 bool result;
22443 char *kwnames[] = {
22444 NULL
22445 };
22446
22447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
22448 {
22449 PyThreadState* __tstate = wxPyBeginAllowThreads();
22450 result = (bool)wxPyApp::IsMainLoopRunning();
22451
22452 wxPyEndAllowThreads(__tstate);
22453 if (PyErr_Occurred()) SWIG_fail;
22454 }
22455 {
22456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22457 }
22458 return resultobj;
22459 fail:
22460 return NULL;
22461 }
22462
22463
22464 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22465 PyObject *resultobj;
22466 wxPyApp *arg1 = (wxPyApp *) 0 ;
22467 int result;
22468 PyObject * obj0 = 0 ;
22469 char *kwnames[] = {
22470 (char *) "self", NULL
22471 };
22472
22473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
22474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22475 if (SWIG_arg_fail(1)) SWIG_fail;
22476 {
22477 PyThreadState* __tstate = wxPyBeginAllowThreads();
22478 result = (int)(arg1)->MainLoop();
22479
22480 wxPyEndAllowThreads(__tstate);
22481 if (PyErr_Occurred()) SWIG_fail;
22482 }
22483 {
22484 resultobj = SWIG_From_int((int)(result));
22485 }
22486 return resultobj;
22487 fail:
22488 return NULL;
22489 }
22490
22491
22492 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
22493 PyObject *resultobj;
22494 wxPyApp *arg1 = (wxPyApp *) 0 ;
22495 PyObject * obj0 = 0 ;
22496 char *kwnames[] = {
22497 (char *) "self", NULL
22498 };
22499
22500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
22501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22502 if (SWIG_arg_fail(1)) SWIG_fail;
22503 {
22504 PyThreadState* __tstate = wxPyBeginAllowThreads();
22505 (arg1)->Exit();
22506
22507 wxPyEndAllowThreads(__tstate);
22508 if (PyErr_Occurred()) SWIG_fail;
22509 }
22510 Py_INCREF(Py_None); resultobj = Py_None;
22511 return resultobj;
22512 fail:
22513 return NULL;
22514 }
22515
22516
22517 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
22518 PyObject *resultobj;
22519 wxPyApp *arg1 = (wxPyApp *) 0 ;
22520 PyObject * obj0 = 0 ;
22521 char *kwnames[] = {
22522 (char *) "self", NULL
22523 };
22524
22525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
22526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22527 if (SWIG_arg_fail(1)) SWIG_fail;
22528 {
22529 PyThreadState* __tstate = wxPyBeginAllowThreads();
22530 (arg1)->ExitMainLoop();
22531
22532 wxPyEndAllowThreads(__tstate);
22533 if (PyErr_Occurred()) SWIG_fail;
22534 }
22535 Py_INCREF(Py_None); resultobj = Py_None;
22536 return resultobj;
22537 fail:
22538 return NULL;
22539 }
22540
22541
22542 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
22543 PyObject *resultobj;
22544 wxPyApp *arg1 = (wxPyApp *) 0 ;
22545 bool result;
22546 PyObject * obj0 = 0 ;
22547 char *kwnames[] = {
22548 (char *) "self", NULL
22549 };
22550
22551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
22552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22553 if (SWIG_arg_fail(1)) SWIG_fail;
22554 {
22555 PyThreadState* __tstate = wxPyBeginAllowThreads();
22556 result = (bool)(arg1)->Pending();
22557
22558 wxPyEndAllowThreads(__tstate);
22559 if (PyErr_Occurred()) SWIG_fail;
22560 }
22561 {
22562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22563 }
22564 return resultobj;
22565 fail:
22566 return NULL;
22567 }
22568
22569
22570 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
22571 PyObject *resultobj;
22572 wxPyApp *arg1 = (wxPyApp *) 0 ;
22573 bool result;
22574 PyObject * obj0 = 0 ;
22575 char *kwnames[] = {
22576 (char *) "self", NULL
22577 };
22578
22579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
22580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22581 if (SWIG_arg_fail(1)) SWIG_fail;
22582 {
22583 PyThreadState* __tstate = wxPyBeginAllowThreads();
22584 result = (bool)(arg1)->Dispatch();
22585
22586 wxPyEndAllowThreads(__tstate);
22587 if (PyErr_Occurred()) SWIG_fail;
22588 }
22589 {
22590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22591 }
22592 return resultobj;
22593 fail:
22594 return NULL;
22595 }
22596
22597
22598 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
22599 PyObject *resultobj;
22600 wxPyApp *arg1 = (wxPyApp *) 0 ;
22601 bool result;
22602 PyObject * obj0 = 0 ;
22603 char *kwnames[] = {
22604 (char *) "self", NULL
22605 };
22606
22607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
22608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22609 if (SWIG_arg_fail(1)) SWIG_fail;
22610 {
22611 PyThreadState* __tstate = wxPyBeginAllowThreads();
22612 result = (bool)(arg1)->ProcessIdle();
22613
22614 wxPyEndAllowThreads(__tstate);
22615 if (PyErr_Occurred()) SWIG_fail;
22616 }
22617 {
22618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22619 }
22620 return resultobj;
22621 fail:
22622 return NULL;
22623 }
22624
22625
22626 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22627 PyObject *resultobj;
22628 wxPyApp *arg1 = (wxPyApp *) 0 ;
22629 wxWindow *arg2 = (wxWindow *) 0 ;
22630 wxIdleEvent *arg3 = 0 ;
22631 bool result;
22632 PyObject * obj0 = 0 ;
22633 PyObject * obj1 = 0 ;
22634 PyObject * obj2 = 0 ;
22635 char *kwnames[] = {
22636 (char *) "self",(char *) "win",(char *) "event", NULL
22637 };
22638
22639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
22640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22641 if (SWIG_arg_fail(1)) SWIG_fail;
22642 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22643 if (SWIG_arg_fail(2)) SWIG_fail;
22644 {
22645 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22646 if (SWIG_arg_fail(3)) SWIG_fail;
22647 if (arg3 == NULL) {
22648 SWIG_null_ref("wxIdleEvent");
22649 }
22650 if (SWIG_arg_fail(3)) SWIG_fail;
22651 }
22652 {
22653 PyThreadState* __tstate = wxPyBeginAllowThreads();
22654 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
22655
22656 wxPyEndAllowThreads(__tstate);
22657 if (PyErr_Occurred()) SWIG_fail;
22658 }
22659 {
22660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22661 }
22662 return resultobj;
22663 fail:
22664 return NULL;
22665 }
22666
22667
22668 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
22669 PyObject *resultobj;
22670 wxPyApp *arg1 = (wxPyApp *) 0 ;
22671 bool result;
22672 PyObject * obj0 = 0 ;
22673 char *kwnames[] = {
22674 (char *) "self", NULL
22675 };
22676
22677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
22678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22679 if (SWIG_arg_fail(1)) SWIG_fail;
22680 {
22681 PyThreadState* __tstate = wxPyBeginAllowThreads();
22682 result = (bool)((wxPyApp const *)arg1)->IsActive();
22683
22684 wxPyEndAllowThreads(__tstate);
22685 if (PyErr_Occurred()) SWIG_fail;
22686 }
22687 {
22688 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22689 }
22690 return resultobj;
22691 fail:
22692 return NULL;
22693 }
22694
22695
22696 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22697 PyObject *resultobj;
22698 wxPyApp *arg1 = (wxPyApp *) 0 ;
22699 wxWindow *arg2 = (wxWindow *) 0 ;
22700 PyObject * obj0 = 0 ;
22701 PyObject * obj1 = 0 ;
22702 char *kwnames[] = {
22703 (char *) "self",(char *) "win", NULL
22704 };
22705
22706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
22707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22708 if (SWIG_arg_fail(1)) SWIG_fail;
22709 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22710 if (SWIG_arg_fail(2)) SWIG_fail;
22711 {
22712 PyThreadState* __tstate = wxPyBeginAllowThreads();
22713 (arg1)->SetTopWindow(arg2);
22714
22715 wxPyEndAllowThreads(__tstate);
22716 if (PyErr_Occurred()) SWIG_fail;
22717 }
22718 Py_INCREF(Py_None); resultobj = Py_None;
22719 return resultobj;
22720 fail:
22721 return NULL;
22722 }
22723
22724
22725 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22726 PyObject *resultobj;
22727 wxPyApp *arg1 = (wxPyApp *) 0 ;
22728 wxWindow *result;
22729 PyObject * obj0 = 0 ;
22730 char *kwnames[] = {
22731 (char *) "self", NULL
22732 };
22733
22734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
22735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22736 if (SWIG_arg_fail(1)) SWIG_fail;
22737 {
22738 PyThreadState* __tstate = wxPyBeginAllowThreads();
22739 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
22740
22741 wxPyEndAllowThreads(__tstate);
22742 if (PyErr_Occurred()) SWIG_fail;
22743 }
22744 {
22745 resultobj = wxPyMake_wxObject(result, 0);
22746 }
22747 return resultobj;
22748 fail:
22749 return NULL;
22750 }
22751
22752
22753 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22754 PyObject *resultobj;
22755 wxPyApp *arg1 = (wxPyApp *) 0 ;
22756 bool arg2 ;
22757 PyObject * obj0 = 0 ;
22758 PyObject * obj1 = 0 ;
22759 char *kwnames[] = {
22760 (char *) "self",(char *) "flag", NULL
22761 };
22762
22763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
22764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22765 if (SWIG_arg_fail(1)) SWIG_fail;
22766 {
22767 arg2 = (bool)(SWIG_As_bool(obj1));
22768 if (SWIG_arg_fail(2)) SWIG_fail;
22769 }
22770 {
22771 PyThreadState* __tstate = wxPyBeginAllowThreads();
22772 (arg1)->SetExitOnFrameDelete(arg2);
22773
22774 wxPyEndAllowThreads(__tstate);
22775 if (PyErr_Occurred()) SWIG_fail;
22776 }
22777 Py_INCREF(Py_None); resultobj = Py_None;
22778 return resultobj;
22779 fail:
22780 return NULL;
22781 }
22782
22783
22784 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
22785 PyObject *resultobj;
22786 wxPyApp *arg1 = (wxPyApp *) 0 ;
22787 bool result;
22788 PyObject * obj0 = 0 ;
22789 char *kwnames[] = {
22790 (char *) "self", NULL
22791 };
22792
22793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
22794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22795 if (SWIG_arg_fail(1)) SWIG_fail;
22796 {
22797 PyThreadState* __tstate = wxPyBeginAllowThreads();
22798 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
22799
22800 wxPyEndAllowThreads(__tstate);
22801 if (PyErr_Occurred()) SWIG_fail;
22802 }
22803 {
22804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22805 }
22806 return resultobj;
22807 fail:
22808 return NULL;
22809 }
22810
22811
22812 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22813 PyObject *resultobj;
22814 wxPyApp *arg1 = (wxPyApp *) 0 ;
22815 bool arg2 ;
22816 PyObject * obj0 = 0 ;
22817 PyObject * obj1 = 0 ;
22818 char *kwnames[] = {
22819 (char *) "self",(char *) "flag", NULL
22820 };
22821
22822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
22823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22824 if (SWIG_arg_fail(1)) SWIG_fail;
22825 {
22826 arg2 = (bool)(SWIG_As_bool(obj1));
22827 if (SWIG_arg_fail(2)) SWIG_fail;
22828 }
22829 {
22830 PyThreadState* __tstate = wxPyBeginAllowThreads();
22831 (arg1)->SetUseBestVisual(arg2);
22832
22833 wxPyEndAllowThreads(__tstate);
22834 if (PyErr_Occurred()) SWIG_fail;
22835 }
22836 Py_INCREF(Py_None); resultobj = Py_None;
22837 return resultobj;
22838 fail:
22839 return NULL;
22840 }
22841
22842
22843 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
22844 PyObject *resultobj;
22845 wxPyApp *arg1 = (wxPyApp *) 0 ;
22846 bool result;
22847 PyObject * obj0 = 0 ;
22848 char *kwnames[] = {
22849 (char *) "self", NULL
22850 };
22851
22852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
22853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22854 if (SWIG_arg_fail(1)) SWIG_fail;
22855 {
22856 PyThreadState* __tstate = wxPyBeginAllowThreads();
22857 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
22858
22859 wxPyEndAllowThreads(__tstate);
22860 if (PyErr_Occurred()) SWIG_fail;
22861 }
22862 {
22863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22864 }
22865 return resultobj;
22866 fail:
22867 return NULL;
22868 }
22869
22870
22871 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22872 PyObject *resultobj;
22873 wxPyApp *arg1 = (wxPyApp *) 0 ;
22874 int arg2 ;
22875 PyObject * obj0 = 0 ;
22876 PyObject * obj1 = 0 ;
22877 char *kwnames[] = {
22878 (char *) "self",(char *) "mode", NULL
22879 };
22880
22881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
22882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22883 if (SWIG_arg_fail(1)) SWIG_fail;
22884 {
22885 arg2 = (int)(SWIG_As_int(obj1));
22886 if (SWIG_arg_fail(2)) SWIG_fail;
22887 }
22888 {
22889 PyThreadState* __tstate = wxPyBeginAllowThreads();
22890 (arg1)->SetPrintMode(arg2);
22891
22892 wxPyEndAllowThreads(__tstate);
22893 if (PyErr_Occurred()) SWIG_fail;
22894 }
22895 Py_INCREF(Py_None); resultobj = Py_None;
22896 return resultobj;
22897 fail:
22898 return NULL;
22899 }
22900
22901
22902 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
22903 PyObject *resultobj;
22904 wxPyApp *arg1 = (wxPyApp *) 0 ;
22905 int result;
22906 PyObject * obj0 = 0 ;
22907 char *kwnames[] = {
22908 (char *) "self", NULL
22909 };
22910
22911 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
22912 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22913 if (SWIG_arg_fail(1)) SWIG_fail;
22914 {
22915 PyThreadState* __tstate = wxPyBeginAllowThreads();
22916 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
22917
22918 wxPyEndAllowThreads(__tstate);
22919 if (PyErr_Occurred()) SWIG_fail;
22920 }
22921 {
22922 resultobj = SWIG_From_int((int)(result));
22923 }
22924 return resultobj;
22925 fail:
22926 return NULL;
22927 }
22928
22929
22930 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
22931 PyObject *resultobj;
22932 wxPyApp *arg1 = (wxPyApp *) 0 ;
22933 int arg2 ;
22934 PyObject * obj0 = 0 ;
22935 PyObject * obj1 = 0 ;
22936 char *kwnames[] = {
22937 (char *) "self",(char *) "mode", NULL
22938 };
22939
22940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
22945 if (SWIG_arg_fail(2)) SWIG_fail;
22946 }
22947 {
22948 PyThreadState* __tstate = wxPyBeginAllowThreads();
22949 (arg1)->SetAssertMode(arg2);
22950
22951 wxPyEndAllowThreads(__tstate);
22952 if (PyErr_Occurred()) SWIG_fail;
22953 }
22954 Py_INCREF(Py_None); resultobj = Py_None;
22955 return resultobj;
22956 fail:
22957 return NULL;
22958 }
22959
22960
22961 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
22962 PyObject *resultobj;
22963 wxPyApp *arg1 = (wxPyApp *) 0 ;
22964 int result;
22965 PyObject * obj0 = 0 ;
22966 char *kwnames[] = {
22967 (char *) "self", NULL
22968 };
22969
22970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
22971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22972 if (SWIG_arg_fail(1)) SWIG_fail;
22973 {
22974 PyThreadState* __tstate = wxPyBeginAllowThreads();
22975 result = (int)(arg1)->GetAssertMode();
22976
22977 wxPyEndAllowThreads(__tstate);
22978 if (PyErr_Occurred()) SWIG_fail;
22979 }
22980 {
22981 resultobj = SWIG_From_int((int)(result));
22982 }
22983 return resultobj;
22984 fail:
22985 return NULL;
22986 }
22987
22988
22989 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
22990 PyObject *resultobj;
22991 bool result;
22992 char *kwnames[] = {
22993 NULL
22994 };
22995
22996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
22997 {
22998 PyThreadState* __tstate = wxPyBeginAllowThreads();
22999 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23000
23001 wxPyEndAllowThreads(__tstate);
23002 if (PyErr_Occurred()) SWIG_fail;
23003 }
23004 {
23005 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23006 }
23007 return resultobj;
23008 fail:
23009 return NULL;
23010 }
23011
23012
23013 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23014 PyObject *resultobj;
23015 long result;
23016 char *kwnames[] = {
23017 NULL
23018 };
23019
23020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23021 {
23022 PyThreadState* __tstate = wxPyBeginAllowThreads();
23023 result = (long)wxPyApp::GetMacAboutMenuItemId();
23024
23025 wxPyEndAllowThreads(__tstate);
23026 if (PyErr_Occurred()) SWIG_fail;
23027 }
23028 {
23029 resultobj = SWIG_From_long((long)(result));
23030 }
23031 return resultobj;
23032 fail:
23033 return NULL;
23034 }
23035
23036
23037 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23038 PyObject *resultobj;
23039 long result;
23040 char *kwnames[] = {
23041 NULL
23042 };
23043
23044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23045 {
23046 PyThreadState* __tstate = wxPyBeginAllowThreads();
23047 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23048
23049 wxPyEndAllowThreads(__tstate);
23050 if (PyErr_Occurred()) SWIG_fail;
23051 }
23052 {
23053 resultobj = SWIG_From_long((long)(result));
23054 }
23055 return resultobj;
23056 fail:
23057 return NULL;
23058 }
23059
23060
23061 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23062 PyObject *resultobj;
23063 long result;
23064 char *kwnames[] = {
23065 NULL
23066 };
23067
23068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23069 {
23070 PyThreadState* __tstate = wxPyBeginAllowThreads();
23071 result = (long)wxPyApp::GetMacExitMenuItemId();
23072
23073 wxPyEndAllowThreads(__tstate);
23074 if (PyErr_Occurred()) SWIG_fail;
23075 }
23076 {
23077 resultobj = SWIG_From_long((long)(result));
23078 }
23079 return resultobj;
23080 fail:
23081 return NULL;
23082 }
23083
23084
23085 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23086 PyObject *resultobj;
23087 wxString result;
23088 char *kwnames[] = {
23089 NULL
23090 };
23091
23092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23093 {
23094 PyThreadState* __tstate = wxPyBeginAllowThreads();
23095 result = wxPyApp::GetMacHelpMenuTitleName();
23096
23097 wxPyEndAllowThreads(__tstate);
23098 if (PyErr_Occurred()) SWIG_fail;
23099 }
23100 {
23101 #if wxUSE_UNICODE
23102 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23103 #else
23104 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23105 #endif
23106 }
23107 return resultobj;
23108 fail:
23109 return NULL;
23110 }
23111
23112
23113 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23114 PyObject *resultobj;
23115 bool arg1 ;
23116 PyObject * obj0 = 0 ;
23117 char *kwnames[] = {
23118 (char *) "val", NULL
23119 };
23120
23121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23122 {
23123 arg1 = (bool)(SWIG_As_bool(obj0));
23124 if (SWIG_arg_fail(1)) SWIG_fail;
23125 }
23126 {
23127 PyThreadState* __tstate = wxPyBeginAllowThreads();
23128 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23129
23130 wxPyEndAllowThreads(__tstate);
23131 if (PyErr_Occurred()) SWIG_fail;
23132 }
23133 Py_INCREF(Py_None); resultobj = Py_None;
23134 return resultobj;
23135 fail:
23136 return NULL;
23137 }
23138
23139
23140 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23141 PyObject *resultobj;
23142 long arg1 ;
23143 PyObject * obj0 = 0 ;
23144 char *kwnames[] = {
23145 (char *) "val", NULL
23146 };
23147
23148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23149 {
23150 arg1 = (long)(SWIG_As_long(obj0));
23151 if (SWIG_arg_fail(1)) SWIG_fail;
23152 }
23153 {
23154 PyThreadState* __tstate = wxPyBeginAllowThreads();
23155 wxPyApp::SetMacAboutMenuItemId(arg1);
23156
23157 wxPyEndAllowThreads(__tstate);
23158 if (PyErr_Occurred()) SWIG_fail;
23159 }
23160 Py_INCREF(Py_None); resultobj = Py_None;
23161 return resultobj;
23162 fail:
23163 return NULL;
23164 }
23165
23166
23167 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23168 PyObject *resultobj;
23169 long arg1 ;
23170 PyObject * obj0 = 0 ;
23171 char *kwnames[] = {
23172 (char *) "val", NULL
23173 };
23174
23175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23176 {
23177 arg1 = (long)(SWIG_As_long(obj0));
23178 if (SWIG_arg_fail(1)) SWIG_fail;
23179 }
23180 {
23181 PyThreadState* __tstate = wxPyBeginAllowThreads();
23182 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23183
23184 wxPyEndAllowThreads(__tstate);
23185 if (PyErr_Occurred()) SWIG_fail;
23186 }
23187 Py_INCREF(Py_None); resultobj = Py_None;
23188 return resultobj;
23189 fail:
23190 return NULL;
23191 }
23192
23193
23194 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23195 PyObject *resultobj;
23196 long arg1 ;
23197 PyObject * obj0 = 0 ;
23198 char *kwnames[] = {
23199 (char *) "val", NULL
23200 };
23201
23202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23203 {
23204 arg1 = (long)(SWIG_As_long(obj0));
23205 if (SWIG_arg_fail(1)) SWIG_fail;
23206 }
23207 {
23208 PyThreadState* __tstate = wxPyBeginAllowThreads();
23209 wxPyApp::SetMacExitMenuItemId(arg1);
23210
23211 wxPyEndAllowThreads(__tstate);
23212 if (PyErr_Occurred()) SWIG_fail;
23213 }
23214 Py_INCREF(Py_None); resultobj = Py_None;
23215 return resultobj;
23216 fail:
23217 return NULL;
23218 }
23219
23220
23221 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23222 PyObject *resultobj;
23223 wxString *arg1 = 0 ;
23224 bool temp1 = false ;
23225 PyObject * obj0 = 0 ;
23226 char *kwnames[] = {
23227 (char *) "val", NULL
23228 };
23229
23230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23231 {
23232 arg1 = wxString_in_helper(obj0);
23233 if (arg1 == NULL) SWIG_fail;
23234 temp1 = true;
23235 }
23236 {
23237 PyThreadState* __tstate = wxPyBeginAllowThreads();
23238 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23239
23240 wxPyEndAllowThreads(__tstate);
23241 if (PyErr_Occurred()) SWIG_fail;
23242 }
23243 Py_INCREF(Py_None); resultobj = Py_None;
23244 {
23245 if (temp1)
23246 delete arg1;
23247 }
23248 return resultobj;
23249 fail:
23250 {
23251 if (temp1)
23252 delete arg1;
23253 }
23254 return NULL;
23255 }
23256
23257
23258 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23259 PyObject *resultobj;
23260 wxPyApp *arg1 = (wxPyApp *) 0 ;
23261 PyObject * obj0 = 0 ;
23262 char *kwnames[] = {
23263 (char *) "self", NULL
23264 };
23265
23266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23268 if (SWIG_arg_fail(1)) SWIG_fail;
23269 {
23270 PyThreadState* __tstate = wxPyBeginAllowThreads();
23271 (arg1)->_BootstrapApp();
23272
23273 wxPyEndAllowThreads(__tstate);
23274 if (PyErr_Occurred()) SWIG_fail;
23275 }
23276 Py_INCREF(Py_None); resultobj = Py_None;
23277 return resultobj;
23278 fail:
23279 return NULL;
23280 }
23281
23282
23283 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23284 PyObject *resultobj;
23285 int result;
23286 char *kwnames[] = {
23287 NULL
23288 };
23289
23290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23291 {
23292 PyThreadState* __tstate = wxPyBeginAllowThreads();
23293 result = (int)PyApp_GetComCtl32Version();
23294
23295 wxPyEndAllowThreads(__tstate);
23296 if (PyErr_Occurred()) SWIG_fail;
23297 }
23298 {
23299 resultobj = SWIG_From_int((int)(result));
23300 }
23301 return resultobj;
23302 fail:
23303 return NULL;
23304 }
23305
23306
23307 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23308 PyObject *obj;
23309 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23310 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23311 Py_INCREF(obj);
23312 return Py_BuildValue((char *)"");
23313 }
23314 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23315 PyObject *resultobj;
23316 char *kwnames[] = {
23317 NULL
23318 };
23319
23320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23321 {
23322 PyThreadState* __tstate = wxPyBeginAllowThreads();
23323 wxExit();
23324
23325 wxPyEndAllowThreads(__tstate);
23326 if (PyErr_Occurred()) SWIG_fail;
23327 }
23328 Py_INCREF(Py_None); resultobj = Py_None;
23329 return resultobj;
23330 fail:
23331 return NULL;
23332 }
23333
23334
23335 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23336 PyObject *resultobj;
23337 bool result;
23338 char *kwnames[] = {
23339 NULL
23340 };
23341
23342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23343 {
23344 PyThreadState* __tstate = wxPyBeginAllowThreads();
23345 result = (bool)wxYield();
23346
23347 wxPyEndAllowThreads(__tstate);
23348 if (PyErr_Occurred()) SWIG_fail;
23349 }
23350 {
23351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23352 }
23353 return resultobj;
23354 fail:
23355 return NULL;
23356 }
23357
23358
23359 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23360 PyObject *resultobj;
23361 bool result;
23362 char *kwnames[] = {
23363 NULL
23364 };
23365
23366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23367 {
23368 PyThreadState* __tstate = wxPyBeginAllowThreads();
23369 result = (bool)wxYieldIfNeeded();
23370
23371 wxPyEndAllowThreads(__tstate);
23372 if (PyErr_Occurred()) SWIG_fail;
23373 }
23374 {
23375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23376 }
23377 return resultobj;
23378 fail:
23379 return NULL;
23380 }
23381
23382
23383 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23384 PyObject *resultobj;
23385 wxWindow *arg1 = (wxWindow *) NULL ;
23386 bool arg2 = (bool) false ;
23387 bool result;
23388 PyObject * obj0 = 0 ;
23389 PyObject * obj1 = 0 ;
23390 char *kwnames[] = {
23391 (char *) "win",(char *) "onlyIfNeeded", NULL
23392 };
23393
23394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23395 if (obj0) {
23396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23397 if (SWIG_arg_fail(1)) SWIG_fail;
23398 }
23399 if (obj1) {
23400 {
23401 arg2 = (bool)(SWIG_As_bool(obj1));
23402 if (SWIG_arg_fail(2)) SWIG_fail;
23403 }
23404 }
23405 {
23406 PyThreadState* __tstate = wxPyBeginAllowThreads();
23407 result = (bool)wxSafeYield(arg1,arg2);
23408
23409 wxPyEndAllowThreads(__tstate);
23410 if (PyErr_Occurred()) SWIG_fail;
23411 }
23412 {
23413 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23414 }
23415 return resultobj;
23416 fail:
23417 return NULL;
23418 }
23419
23420
23421 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23422 PyObject *resultobj;
23423 char *kwnames[] = {
23424 NULL
23425 };
23426
23427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
23428 {
23429 PyThreadState* __tstate = wxPyBeginAllowThreads();
23430 wxWakeUpIdle();
23431
23432 wxPyEndAllowThreads(__tstate);
23433 if (PyErr_Occurred()) SWIG_fail;
23434 }
23435 Py_INCREF(Py_None); resultobj = Py_None;
23436 return resultobj;
23437 fail:
23438 return NULL;
23439 }
23440
23441
23442 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23443 PyObject *resultobj;
23444 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
23445 wxEvent *arg2 = 0 ;
23446 PyObject * obj0 = 0 ;
23447 PyObject * obj1 = 0 ;
23448 char *kwnames[] = {
23449 (char *) "dest",(char *) "event", NULL
23450 };
23451
23452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
23453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
23454 if (SWIG_arg_fail(1)) SWIG_fail;
23455 {
23456 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
23457 if (SWIG_arg_fail(2)) SWIG_fail;
23458 if (arg2 == NULL) {
23459 SWIG_null_ref("wxEvent");
23460 }
23461 if (SWIG_arg_fail(2)) SWIG_fail;
23462 }
23463 {
23464 PyThreadState* __tstate = wxPyBeginAllowThreads();
23465 wxPostEvent(arg1,*arg2);
23466
23467 wxPyEndAllowThreads(__tstate);
23468 if (PyErr_Occurred()) SWIG_fail;
23469 }
23470 Py_INCREF(Py_None); resultobj = Py_None;
23471 return resultobj;
23472 fail:
23473 return NULL;
23474 }
23475
23476
23477 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
23478 PyObject *resultobj;
23479 char *kwnames[] = {
23480 NULL
23481 };
23482
23483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
23484 {
23485 PyThreadState* __tstate = wxPyBeginAllowThreads();
23486 wxApp_CleanUp();
23487
23488 wxPyEndAllowThreads(__tstate);
23489 if (PyErr_Occurred()) SWIG_fail;
23490 }
23491 Py_INCREF(Py_None); resultobj = Py_None;
23492 return resultobj;
23493 fail:
23494 return NULL;
23495 }
23496
23497
23498 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
23499 PyObject *resultobj;
23500 wxPyApp *result;
23501 char *kwnames[] = {
23502 NULL
23503 };
23504
23505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
23506 {
23507 PyThreadState* __tstate = wxPyBeginAllowThreads();
23508 result = (wxPyApp *)wxPyGetApp();
23509
23510 wxPyEndAllowThreads(__tstate);
23511 if (PyErr_Occurred()) SWIG_fail;
23512 }
23513 {
23514 resultobj = wxPyMake_wxObject(result, 0);
23515 }
23516 return resultobj;
23517 fail:
23518 return NULL;
23519 }
23520
23521
23522 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23523 PyObject *resultobj;
23524 char *arg1 = (char *) 0 ;
23525 PyObject * obj0 = 0 ;
23526 char *kwnames[] = {
23527 (char *) "encoding", NULL
23528 };
23529
23530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
23531 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
23532 SWIG_arg_fail(1);SWIG_fail;
23533 }
23534 {
23535 PyThreadState* __tstate = wxPyBeginAllowThreads();
23536 wxSetDefaultPyEncoding((char const *)arg1);
23537
23538 wxPyEndAllowThreads(__tstate);
23539 if (PyErr_Occurred()) SWIG_fail;
23540 }
23541 Py_INCREF(Py_None); resultobj = Py_None;
23542 return resultobj;
23543 fail:
23544 return NULL;
23545 }
23546
23547
23548 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
23549 PyObject *resultobj;
23550 char *result;
23551 char *kwnames[] = {
23552 NULL
23553 };
23554
23555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
23556 {
23557 PyThreadState* __tstate = wxPyBeginAllowThreads();
23558 result = (char *)wxGetDefaultPyEncoding();
23559
23560 wxPyEndAllowThreads(__tstate);
23561 if (PyErr_Occurred()) SWIG_fail;
23562 }
23563 resultobj = SWIG_FromCharPtr(result);
23564 return resultobj;
23565 fail:
23566 return NULL;
23567 }
23568
23569
23570 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23571 PyObject *resultobj;
23572 wxEventLoop *result;
23573 char *kwnames[] = {
23574 NULL
23575 };
23576
23577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
23578 {
23579 PyThreadState* __tstate = wxPyBeginAllowThreads();
23580 result = (wxEventLoop *)new wxEventLoop();
23581
23582 wxPyEndAllowThreads(__tstate);
23583 if (PyErr_Occurred()) SWIG_fail;
23584 }
23585 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
23586 return resultobj;
23587 fail:
23588 return NULL;
23589 }
23590
23591
23592 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23593 PyObject *resultobj;
23594 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23595 PyObject * obj0 = 0 ;
23596 char *kwnames[] = {
23597 (char *) "self", NULL
23598 };
23599
23600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
23601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23602 if (SWIG_arg_fail(1)) SWIG_fail;
23603 {
23604 PyThreadState* __tstate = wxPyBeginAllowThreads();
23605 delete arg1;
23606
23607 wxPyEndAllowThreads(__tstate);
23608 if (PyErr_Occurred()) SWIG_fail;
23609 }
23610 Py_INCREF(Py_None); resultobj = Py_None;
23611 return resultobj;
23612 fail:
23613 return NULL;
23614 }
23615
23616
23617 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
23618 PyObject *resultobj;
23619 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23620 int result;
23621 PyObject * obj0 = 0 ;
23622 char *kwnames[] = {
23623 (char *) "self", NULL
23624 };
23625
23626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
23627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23628 if (SWIG_arg_fail(1)) SWIG_fail;
23629 {
23630 PyThreadState* __tstate = wxPyBeginAllowThreads();
23631 result = (int)(arg1)->Run();
23632
23633 wxPyEndAllowThreads(__tstate);
23634 if (PyErr_Occurred()) SWIG_fail;
23635 }
23636 {
23637 resultobj = SWIG_From_int((int)(result));
23638 }
23639 return resultobj;
23640 fail:
23641 return NULL;
23642 }
23643
23644
23645 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23646 PyObject *resultobj;
23647 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23648 int arg2 = (int) 0 ;
23649 PyObject * obj0 = 0 ;
23650 PyObject * obj1 = 0 ;
23651 char *kwnames[] = {
23652 (char *) "self",(char *) "rc", NULL
23653 };
23654
23655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
23656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23657 if (SWIG_arg_fail(1)) SWIG_fail;
23658 if (obj1) {
23659 {
23660 arg2 = (int)(SWIG_As_int(obj1));
23661 if (SWIG_arg_fail(2)) SWIG_fail;
23662 }
23663 }
23664 {
23665 PyThreadState* __tstate = wxPyBeginAllowThreads();
23666 (arg1)->Exit(arg2);
23667
23668 wxPyEndAllowThreads(__tstate);
23669 if (PyErr_Occurred()) SWIG_fail;
23670 }
23671 Py_INCREF(Py_None); resultobj = Py_None;
23672 return resultobj;
23673 fail:
23674 return NULL;
23675 }
23676
23677
23678 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23679 PyObject *resultobj;
23680 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23681 bool result;
23682 PyObject * obj0 = 0 ;
23683 char *kwnames[] = {
23684 (char *) "self", NULL
23685 };
23686
23687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
23688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23689 if (SWIG_arg_fail(1)) SWIG_fail;
23690 {
23691 PyThreadState* __tstate = wxPyBeginAllowThreads();
23692 result = (bool)((wxEventLoop const *)arg1)->Pending();
23693
23694 wxPyEndAllowThreads(__tstate);
23695 if (PyErr_Occurred()) SWIG_fail;
23696 }
23697 {
23698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23699 }
23700 return resultobj;
23701 fail:
23702 return NULL;
23703 }
23704
23705
23706 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23707 PyObject *resultobj;
23708 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23709 bool result;
23710 PyObject * obj0 = 0 ;
23711 char *kwnames[] = {
23712 (char *) "self", NULL
23713 };
23714
23715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
23716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23717 if (SWIG_arg_fail(1)) SWIG_fail;
23718 {
23719 PyThreadState* __tstate = wxPyBeginAllowThreads();
23720 result = (bool)(arg1)->Dispatch();
23721
23722 wxPyEndAllowThreads(__tstate);
23723 if (PyErr_Occurred()) SWIG_fail;
23724 }
23725 {
23726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23727 }
23728 return resultobj;
23729 fail:
23730 return NULL;
23731 }
23732
23733
23734 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23735 PyObject *resultobj;
23736 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23737 bool result;
23738 PyObject * obj0 = 0 ;
23739 char *kwnames[] = {
23740 (char *) "self", NULL
23741 };
23742
23743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
23744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23745 if (SWIG_arg_fail(1)) SWIG_fail;
23746 {
23747 PyThreadState* __tstate = wxPyBeginAllowThreads();
23748 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
23749
23750 wxPyEndAllowThreads(__tstate);
23751 if (PyErr_Occurred()) SWIG_fail;
23752 }
23753 {
23754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23755 }
23756 return resultobj;
23757 fail:
23758 return NULL;
23759 }
23760
23761
23762 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23763 PyObject *resultobj;
23764 wxEventLoop *result;
23765 char *kwnames[] = {
23766 NULL
23767 };
23768
23769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
23770 {
23771 PyThreadState* __tstate = wxPyBeginAllowThreads();
23772 result = (wxEventLoop *)wxEventLoop::GetActive();
23773
23774 wxPyEndAllowThreads(__tstate);
23775 if (PyErr_Occurred()) SWIG_fail;
23776 }
23777 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
23778 return resultobj;
23779 fail:
23780 return NULL;
23781 }
23782
23783
23784 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
23785 PyObject *resultobj;
23786 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
23787 PyObject * obj0 = 0 ;
23788 char *kwnames[] = {
23789 (char *) "loop", NULL
23790 };
23791
23792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
23793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
23794 if (SWIG_arg_fail(1)) SWIG_fail;
23795 {
23796 PyThreadState* __tstate = wxPyBeginAllowThreads();
23797 wxEventLoop::SetActive(arg1);
23798
23799 wxPyEndAllowThreads(__tstate);
23800 if (PyErr_Occurred()) SWIG_fail;
23801 }
23802 Py_INCREF(Py_None); resultobj = Py_None;
23803 return resultobj;
23804 fail:
23805 return NULL;
23806 }
23807
23808
23809 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
23810 PyObject *obj;
23811 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23812 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
23813 Py_INCREF(obj);
23814 return Py_BuildValue((char *)"");
23815 }
23816 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23817 PyObject *resultobj;
23818 int arg1 = (int) 0 ;
23819 int arg2 = (int) 0 ;
23820 int arg3 = (int) 0 ;
23821 wxAcceleratorEntry *result;
23822 PyObject * obj0 = 0 ;
23823 PyObject * obj1 = 0 ;
23824 PyObject * obj2 = 0 ;
23825 char *kwnames[] = {
23826 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
23827 };
23828
23829 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
23830 if (obj0) {
23831 {
23832 arg1 = (int)(SWIG_As_int(obj0));
23833 if (SWIG_arg_fail(1)) SWIG_fail;
23834 }
23835 }
23836 if (obj1) {
23837 {
23838 arg2 = (int)(SWIG_As_int(obj1));
23839 if (SWIG_arg_fail(2)) SWIG_fail;
23840 }
23841 }
23842 if (obj2) {
23843 {
23844 arg3 = (int)(SWIG_As_int(obj2));
23845 if (SWIG_arg_fail(3)) SWIG_fail;
23846 }
23847 }
23848 {
23849 PyThreadState* __tstate = wxPyBeginAllowThreads();
23850 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
23851
23852 wxPyEndAllowThreads(__tstate);
23853 if (PyErr_Occurred()) SWIG_fail;
23854 }
23855 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
23856 return resultobj;
23857 fail:
23858 return NULL;
23859 }
23860
23861
23862 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
23863 PyObject *resultobj;
23864 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23865 PyObject * obj0 = 0 ;
23866 char *kwnames[] = {
23867 (char *) "self", NULL
23868 };
23869
23870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
23871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23872 if (SWIG_arg_fail(1)) SWIG_fail;
23873 {
23874 PyThreadState* __tstate = wxPyBeginAllowThreads();
23875 delete arg1;
23876
23877 wxPyEndAllowThreads(__tstate);
23878 if (PyErr_Occurred()) SWIG_fail;
23879 }
23880 Py_INCREF(Py_None); resultobj = Py_None;
23881 return resultobj;
23882 fail:
23883 return NULL;
23884 }
23885
23886
23887 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
23888 PyObject *resultobj;
23889 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23890 int arg2 ;
23891 int arg3 ;
23892 int arg4 ;
23893 PyObject * obj0 = 0 ;
23894 PyObject * obj1 = 0 ;
23895 PyObject * obj2 = 0 ;
23896 PyObject * obj3 = 0 ;
23897 char *kwnames[] = {
23898 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
23899 };
23900
23901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23903 if (SWIG_arg_fail(1)) SWIG_fail;
23904 {
23905 arg2 = (int)(SWIG_As_int(obj1));
23906 if (SWIG_arg_fail(2)) SWIG_fail;
23907 }
23908 {
23909 arg3 = (int)(SWIG_As_int(obj2));
23910 if (SWIG_arg_fail(3)) SWIG_fail;
23911 }
23912 {
23913 arg4 = (int)(SWIG_As_int(obj3));
23914 if (SWIG_arg_fail(4)) SWIG_fail;
23915 }
23916 {
23917 PyThreadState* __tstate = wxPyBeginAllowThreads();
23918 (arg1)->Set(arg2,arg3,arg4);
23919
23920 wxPyEndAllowThreads(__tstate);
23921 if (PyErr_Occurred()) SWIG_fail;
23922 }
23923 Py_INCREF(Py_None); resultobj = Py_None;
23924 return resultobj;
23925 fail:
23926 return NULL;
23927 }
23928
23929
23930 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
23931 PyObject *resultobj;
23932 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23933 int result;
23934 PyObject * obj0 = 0 ;
23935 char *kwnames[] = {
23936 (char *) "self", NULL
23937 };
23938
23939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
23940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23941 if (SWIG_arg_fail(1)) SWIG_fail;
23942 {
23943 PyThreadState* __tstate = wxPyBeginAllowThreads();
23944 result = (int)(arg1)->GetFlags();
23945
23946 wxPyEndAllowThreads(__tstate);
23947 if (PyErr_Occurred()) SWIG_fail;
23948 }
23949 {
23950 resultobj = SWIG_From_int((int)(result));
23951 }
23952 return resultobj;
23953 fail:
23954 return NULL;
23955 }
23956
23957
23958 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
23959 PyObject *resultobj;
23960 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23961 int result;
23962 PyObject * obj0 = 0 ;
23963 char *kwnames[] = {
23964 (char *) "self", NULL
23965 };
23966
23967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
23968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23969 if (SWIG_arg_fail(1)) SWIG_fail;
23970 {
23971 PyThreadState* __tstate = wxPyBeginAllowThreads();
23972 result = (int)(arg1)->GetKeyCode();
23973
23974 wxPyEndAllowThreads(__tstate);
23975 if (PyErr_Occurred()) SWIG_fail;
23976 }
23977 {
23978 resultobj = SWIG_From_int((int)(result));
23979 }
23980 return resultobj;
23981 fail:
23982 return NULL;
23983 }
23984
23985
23986 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
23987 PyObject *resultobj;
23988 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
23989 int result;
23990 PyObject * obj0 = 0 ;
23991 char *kwnames[] = {
23992 (char *) "self", NULL
23993 };
23994
23995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
23996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
23997 if (SWIG_arg_fail(1)) SWIG_fail;
23998 {
23999 PyThreadState* __tstate = wxPyBeginAllowThreads();
24000 result = (int)(arg1)->GetCommand();
24001
24002 wxPyEndAllowThreads(__tstate);
24003 if (PyErr_Occurred()) SWIG_fail;
24004 }
24005 {
24006 resultobj = SWIG_From_int((int)(result));
24007 }
24008 return resultobj;
24009 fail:
24010 return NULL;
24011 }
24012
24013
24014 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24015 PyObject *obj;
24016 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24017 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24018 Py_INCREF(obj);
24019 return Py_BuildValue((char *)"");
24020 }
24021 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24022 PyObject *resultobj;
24023 int arg1 ;
24024 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24025 wxAcceleratorTable *result;
24026 PyObject * obj0 = 0 ;
24027 char *kwnames[] = {
24028 (char *) "n", NULL
24029 };
24030
24031 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24032 {
24033 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24034 if (arg2) arg1 = PyList_Size(obj0);
24035 else arg1 = 0;
24036 }
24037 {
24038 PyThreadState* __tstate = wxPyBeginAllowThreads();
24039 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24040
24041 wxPyEndAllowThreads(__tstate);
24042 if (PyErr_Occurred()) SWIG_fail;
24043 }
24044 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24045 {
24046 delete [] arg2;
24047 }
24048 return resultobj;
24049 fail:
24050 {
24051 delete [] arg2;
24052 }
24053 return NULL;
24054 }
24055
24056
24057 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24058 PyObject *resultobj;
24059 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24060 PyObject * obj0 = 0 ;
24061 char *kwnames[] = {
24062 (char *) "self", NULL
24063 };
24064
24065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24067 if (SWIG_arg_fail(1)) SWIG_fail;
24068 {
24069 PyThreadState* __tstate = wxPyBeginAllowThreads();
24070 delete arg1;
24071
24072 wxPyEndAllowThreads(__tstate);
24073 if (PyErr_Occurred()) SWIG_fail;
24074 }
24075 Py_INCREF(Py_None); resultobj = Py_None;
24076 return resultobj;
24077 fail:
24078 return NULL;
24079 }
24080
24081
24082 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24083 PyObject *resultobj;
24084 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24085 bool result;
24086 PyObject * obj0 = 0 ;
24087 char *kwnames[] = {
24088 (char *) "self", NULL
24089 };
24090
24091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24092 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24093 if (SWIG_arg_fail(1)) SWIG_fail;
24094 {
24095 PyThreadState* __tstate = wxPyBeginAllowThreads();
24096 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24097
24098 wxPyEndAllowThreads(__tstate);
24099 if (PyErr_Occurred()) SWIG_fail;
24100 }
24101 {
24102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24103 }
24104 return resultobj;
24105 fail:
24106 return NULL;
24107 }
24108
24109
24110 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24111 PyObject *obj;
24112 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24113 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24114 Py_INCREF(obj);
24115 return Py_BuildValue((char *)"");
24116 }
24117 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24118 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24119 return 1;
24120 }
24121
24122
24123 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24124 PyObject *pyobj;
24125
24126 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24127 return pyobj;
24128 }
24129
24130
24131 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24132 PyObject *resultobj;
24133 wxString *arg1 = 0 ;
24134 wxAcceleratorEntry *result;
24135 bool temp1 = false ;
24136 PyObject * obj0 = 0 ;
24137 char *kwnames[] = {
24138 (char *) "label", NULL
24139 };
24140
24141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24142 {
24143 arg1 = wxString_in_helper(obj0);
24144 if (arg1 == NULL) SWIG_fail;
24145 temp1 = true;
24146 }
24147 {
24148 PyThreadState* __tstate = wxPyBeginAllowThreads();
24149 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24150
24151 wxPyEndAllowThreads(__tstate);
24152 if (PyErr_Occurred()) SWIG_fail;
24153 }
24154 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24155 {
24156 if (temp1)
24157 delete arg1;
24158 }
24159 return resultobj;
24160 fail:
24161 {
24162 if (temp1)
24163 delete arg1;
24164 }
24165 return NULL;
24166 }
24167
24168
24169 static int _wrap_PanelNameStr_set(PyObject *) {
24170 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24171 return 1;
24172 }
24173
24174
24175 static PyObject *_wrap_PanelNameStr_get(void) {
24176 PyObject *pyobj;
24177
24178 {
24179 #if wxUSE_UNICODE
24180 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24181 #else
24182 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24183 #endif
24184 }
24185 return pyobj;
24186 }
24187
24188
24189 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24190 PyObject *resultobj;
24191 wxVisualAttributes *result;
24192 char *kwnames[] = {
24193 NULL
24194 };
24195
24196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24197 {
24198 PyThreadState* __tstate = wxPyBeginAllowThreads();
24199 result = (wxVisualAttributes *)new_wxVisualAttributes();
24200
24201 wxPyEndAllowThreads(__tstate);
24202 if (PyErr_Occurred()) SWIG_fail;
24203 }
24204 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24205 return resultobj;
24206 fail:
24207 return NULL;
24208 }
24209
24210
24211 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24212 PyObject *resultobj;
24213 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24214 PyObject * obj0 = 0 ;
24215 char *kwnames[] = {
24216 (char *) "self", NULL
24217 };
24218
24219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24221 if (SWIG_arg_fail(1)) SWIG_fail;
24222 {
24223 PyThreadState* __tstate = wxPyBeginAllowThreads();
24224 delete_wxVisualAttributes(arg1);
24225
24226 wxPyEndAllowThreads(__tstate);
24227 if (PyErr_Occurred()) SWIG_fail;
24228 }
24229 Py_INCREF(Py_None); resultobj = Py_None;
24230 return resultobj;
24231 fail:
24232 return NULL;
24233 }
24234
24235
24236 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24237 PyObject *resultobj;
24238 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24239 wxFont *arg2 = (wxFont *) 0 ;
24240 PyObject * obj0 = 0 ;
24241 PyObject * obj1 = 0 ;
24242 char *kwnames[] = {
24243 (char *) "self",(char *) "font", NULL
24244 };
24245
24246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24248 if (SWIG_arg_fail(1)) SWIG_fail;
24249 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24250 if (SWIG_arg_fail(2)) SWIG_fail;
24251 if (arg1) (arg1)->font = *arg2;
24252
24253 Py_INCREF(Py_None); resultobj = Py_None;
24254 return resultobj;
24255 fail:
24256 return NULL;
24257 }
24258
24259
24260 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24261 PyObject *resultobj;
24262 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24263 wxFont *result;
24264 PyObject * obj0 = 0 ;
24265 char *kwnames[] = {
24266 (char *) "self", NULL
24267 };
24268
24269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24271 if (SWIG_arg_fail(1)) SWIG_fail;
24272 result = (wxFont *)& ((arg1)->font);
24273
24274 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24275 return resultobj;
24276 fail:
24277 return NULL;
24278 }
24279
24280
24281 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24282 PyObject *resultobj;
24283 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24284 wxColour *arg2 = (wxColour *) 0 ;
24285 PyObject * obj0 = 0 ;
24286 PyObject * obj1 = 0 ;
24287 char *kwnames[] = {
24288 (char *) "self",(char *) "colFg", NULL
24289 };
24290
24291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24293 if (SWIG_arg_fail(1)) SWIG_fail;
24294 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24295 if (SWIG_arg_fail(2)) SWIG_fail;
24296 if (arg1) (arg1)->colFg = *arg2;
24297
24298 Py_INCREF(Py_None); resultobj = Py_None;
24299 return resultobj;
24300 fail:
24301 return NULL;
24302 }
24303
24304
24305 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24306 PyObject *resultobj;
24307 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24308 wxColour *result;
24309 PyObject * obj0 = 0 ;
24310 char *kwnames[] = {
24311 (char *) "self", NULL
24312 };
24313
24314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24316 if (SWIG_arg_fail(1)) SWIG_fail;
24317 result = (wxColour *)& ((arg1)->colFg);
24318
24319 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24320 return resultobj;
24321 fail:
24322 return NULL;
24323 }
24324
24325
24326 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24327 PyObject *resultobj;
24328 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24329 wxColour *arg2 = (wxColour *) 0 ;
24330 PyObject * obj0 = 0 ;
24331 PyObject * obj1 = 0 ;
24332 char *kwnames[] = {
24333 (char *) "self",(char *) "colBg", NULL
24334 };
24335
24336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24338 if (SWIG_arg_fail(1)) SWIG_fail;
24339 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24340 if (SWIG_arg_fail(2)) SWIG_fail;
24341 if (arg1) (arg1)->colBg = *arg2;
24342
24343 Py_INCREF(Py_None); resultobj = Py_None;
24344 return resultobj;
24345 fail:
24346 return NULL;
24347 }
24348
24349
24350 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24351 PyObject *resultobj;
24352 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24353 wxColour *result;
24354 PyObject * obj0 = 0 ;
24355 char *kwnames[] = {
24356 (char *) "self", NULL
24357 };
24358
24359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24361 if (SWIG_arg_fail(1)) SWIG_fail;
24362 result = (wxColour *)& ((arg1)->colBg);
24363
24364 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24365 return resultobj;
24366 fail:
24367 return NULL;
24368 }
24369
24370
24371 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24372 PyObject *obj;
24373 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24374 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24375 Py_INCREF(obj);
24376 return Py_BuildValue((char *)"");
24377 }
24378 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24379 PyObject *resultobj;
24380 wxWindow *arg1 = (wxWindow *) 0 ;
24381 int arg2 = (int) (int)-1 ;
24382 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24383 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24384 wxSize const &arg4_defvalue = wxDefaultSize ;
24385 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24386 long arg5 = (long) 0 ;
24387 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24388 wxString *arg6 = (wxString *) &arg6_defvalue ;
24389 wxWindow *result;
24390 wxPoint temp3 ;
24391 wxSize temp4 ;
24392 bool temp6 = false ;
24393 PyObject * obj0 = 0 ;
24394 PyObject * obj1 = 0 ;
24395 PyObject * obj2 = 0 ;
24396 PyObject * obj3 = 0 ;
24397 PyObject * obj4 = 0 ;
24398 PyObject * obj5 = 0 ;
24399 char *kwnames[] = {
24400 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24401 };
24402
24403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24405 if (SWIG_arg_fail(1)) SWIG_fail;
24406 if (obj1) {
24407 {
24408 arg2 = (int const)(SWIG_As_int(obj1));
24409 if (SWIG_arg_fail(2)) SWIG_fail;
24410 }
24411 }
24412 if (obj2) {
24413 {
24414 arg3 = &temp3;
24415 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
24416 }
24417 }
24418 if (obj3) {
24419 {
24420 arg4 = &temp4;
24421 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
24422 }
24423 }
24424 if (obj4) {
24425 {
24426 arg5 = (long)(SWIG_As_long(obj4));
24427 if (SWIG_arg_fail(5)) SWIG_fail;
24428 }
24429 }
24430 if (obj5) {
24431 {
24432 arg6 = wxString_in_helper(obj5);
24433 if (arg6 == NULL) SWIG_fail;
24434 temp6 = true;
24435 }
24436 }
24437 {
24438 if (!wxPyCheckForApp()) SWIG_fail;
24439 PyThreadState* __tstate = wxPyBeginAllowThreads();
24440 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
24441
24442 wxPyEndAllowThreads(__tstate);
24443 if (PyErr_Occurred()) SWIG_fail;
24444 }
24445 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24446 {
24447 if (temp6)
24448 delete arg6;
24449 }
24450 return resultobj;
24451 fail:
24452 {
24453 if (temp6)
24454 delete arg6;
24455 }
24456 return NULL;
24457 }
24458
24459
24460 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
24461 PyObject *resultobj;
24462 wxWindow *result;
24463 char *kwnames[] = {
24464 NULL
24465 };
24466
24467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
24468 {
24469 if (!wxPyCheckForApp()) SWIG_fail;
24470 PyThreadState* __tstate = wxPyBeginAllowThreads();
24471 result = (wxWindow *)new wxWindow();
24472
24473 wxPyEndAllowThreads(__tstate);
24474 if (PyErr_Occurred()) SWIG_fail;
24475 }
24476 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
24477 return resultobj;
24478 fail:
24479 return NULL;
24480 }
24481
24482
24483 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
24484 PyObject *resultobj;
24485 wxWindow *arg1 = (wxWindow *) 0 ;
24486 wxWindow *arg2 = (wxWindow *) 0 ;
24487 int arg3 = (int) (int)-1 ;
24488 wxPoint const &arg4_defvalue = wxDefaultPosition ;
24489 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
24490 wxSize const &arg5_defvalue = wxDefaultSize ;
24491 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
24492 long arg6 = (long) 0 ;
24493 wxString const &arg7_defvalue = wxPyPanelNameStr ;
24494 wxString *arg7 = (wxString *) &arg7_defvalue ;
24495 bool result;
24496 wxPoint temp4 ;
24497 wxSize temp5 ;
24498 bool temp7 = false ;
24499 PyObject * obj0 = 0 ;
24500 PyObject * obj1 = 0 ;
24501 PyObject * obj2 = 0 ;
24502 PyObject * obj3 = 0 ;
24503 PyObject * obj4 = 0 ;
24504 PyObject * obj5 = 0 ;
24505 PyObject * obj6 = 0 ;
24506 char *kwnames[] = {
24507 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24508 };
24509
24510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
24511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24512 if (SWIG_arg_fail(1)) SWIG_fail;
24513 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24514 if (SWIG_arg_fail(2)) SWIG_fail;
24515 if (obj2) {
24516 {
24517 arg3 = (int const)(SWIG_As_int(obj2));
24518 if (SWIG_arg_fail(3)) SWIG_fail;
24519 }
24520 }
24521 if (obj3) {
24522 {
24523 arg4 = &temp4;
24524 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
24525 }
24526 }
24527 if (obj4) {
24528 {
24529 arg5 = &temp5;
24530 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
24531 }
24532 }
24533 if (obj5) {
24534 {
24535 arg6 = (long)(SWIG_As_long(obj5));
24536 if (SWIG_arg_fail(6)) SWIG_fail;
24537 }
24538 }
24539 if (obj6) {
24540 {
24541 arg7 = wxString_in_helper(obj6);
24542 if (arg7 == NULL) SWIG_fail;
24543 temp7 = true;
24544 }
24545 }
24546 {
24547 PyThreadState* __tstate = wxPyBeginAllowThreads();
24548 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
24549
24550 wxPyEndAllowThreads(__tstate);
24551 if (PyErr_Occurred()) SWIG_fail;
24552 }
24553 {
24554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24555 }
24556 {
24557 if (temp7)
24558 delete arg7;
24559 }
24560 return resultobj;
24561 fail:
24562 {
24563 if (temp7)
24564 delete arg7;
24565 }
24566 return NULL;
24567 }
24568
24569
24570 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
24571 PyObject *resultobj;
24572 wxWindow *arg1 = (wxWindow *) 0 ;
24573 bool arg2 = (bool) false ;
24574 bool result;
24575 PyObject * obj0 = 0 ;
24576 PyObject * obj1 = 0 ;
24577 char *kwnames[] = {
24578 (char *) "self",(char *) "force", NULL
24579 };
24580
24581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
24582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24583 if (SWIG_arg_fail(1)) SWIG_fail;
24584 if (obj1) {
24585 {
24586 arg2 = (bool)(SWIG_As_bool(obj1));
24587 if (SWIG_arg_fail(2)) SWIG_fail;
24588 }
24589 }
24590 {
24591 PyThreadState* __tstate = wxPyBeginAllowThreads();
24592 result = (bool)(arg1)->Close(arg2);
24593
24594 wxPyEndAllowThreads(__tstate);
24595 if (PyErr_Occurred()) SWIG_fail;
24596 }
24597 {
24598 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24599 }
24600 return resultobj;
24601 fail:
24602 return NULL;
24603 }
24604
24605
24606 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
24607 PyObject *resultobj;
24608 wxWindow *arg1 = (wxWindow *) 0 ;
24609 bool result;
24610 PyObject * obj0 = 0 ;
24611 char *kwnames[] = {
24612 (char *) "self", NULL
24613 };
24614
24615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
24616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24617 if (SWIG_arg_fail(1)) SWIG_fail;
24618 {
24619 PyThreadState* __tstate = wxPyBeginAllowThreads();
24620 result = (bool)(arg1)->Destroy();
24621
24622 wxPyEndAllowThreads(__tstate);
24623 if (PyErr_Occurred()) SWIG_fail;
24624 }
24625 {
24626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24627 }
24628 return resultobj;
24629 fail:
24630 return NULL;
24631 }
24632
24633
24634 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
24635 PyObject *resultobj;
24636 wxWindow *arg1 = (wxWindow *) 0 ;
24637 bool result;
24638 PyObject * obj0 = 0 ;
24639 char *kwnames[] = {
24640 (char *) "self", NULL
24641 };
24642
24643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
24644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24645 if (SWIG_arg_fail(1)) SWIG_fail;
24646 {
24647 PyThreadState* __tstate = wxPyBeginAllowThreads();
24648 result = (bool)(arg1)->DestroyChildren();
24649
24650 wxPyEndAllowThreads(__tstate);
24651 if (PyErr_Occurred()) SWIG_fail;
24652 }
24653 {
24654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24655 }
24656 return resultobj;
24657 fail:
24658 return NULL;
24659 }
24660
24661
24662 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
24663 PyObject *resultobj;
24664 wxWindow *arg1 = (wxWindow *) 0 ;
24665 bool result;
24666 PyObject * obj0 = 0 ;
24667 char *kwnames[] = {
24668 (char *) "self", NULL
24669 };
24670
24671 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
24672 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24673 if (SWIG_arg_fail(1)) SWIG_fail;
24674 {
24675 PyThreadState* __tstate = wxPyBeginAllowThreads();
24676 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
24677
24678 wxPyEndAllowThreads(__tstate);
24679 if (PyErr_Occurred()) SWIG_fail;
24680 }
24681 {
24682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24683 }
24684 return resultobj;
24685 fail:
24686 return NULL;
24687 }
24688
24689
24690 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24691 PyObject *resultobj;
24692 wxWindow *arg1 = (wxWindow *) 0 ;
24693 wxString *arg2 = 0 ;
24694 bool temp2 = false ;
24695 PyObject * obj0 = 0 ;
24696 PyObject * obj1 = 0 ;
24697 char *kwnames[] = {
24698 (char *) "self",(char *) "title", NULL
24699 };
24700
24701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
24702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24703 if (SWIG_arg_fail(1)) SWIG_fail;
24704 {
24705 arg2 = wxString_in_helper(obj1);
24706 if (arg2 == NULL) SWIG_fail;
24707 temp2 = true;
24708 }
24709 {
24710 PyThreadState* __tstate = wxPyBeginAllowThreads();
24711 (arg1)->SetTitle((wxString const &)*arg2);
24712
24713 wxPyEndAllowThreads(__tstate);
24714 if (PyErr_Occurred()) SWIG_fail;
24715 }
24716 Py_INCREF(Py_None); resultobj = Py_None;
24717 {
24718 if (temp2)
24719 delete arg2;
24720 }
24721 return resultobj;
24722 fail:
24723 {
24724 if (temp2)
24725 delete arg2;
24726 }
24727 return NULL;
24728 }
24729
24730
24731 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
24732 PyObject *resultobj;
24733 wxWindow *arg1 = (wxWindow *) 0 ;
24734 wxString result;
24735 PyObject * obj0 = 0 ;
24736 char *kwnames[] = {
24737 (char *) "self", NULL
24738 };
24739
24740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
24741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24742 if (SWIG_arg_fail(1)) SWIG_fail;
24743 {
24744 PyThreadState* __tstate = wxPyBeginAllowThreads();
24745 result = ((wxWindow const *)arg1)->GetTitle();
24746
24747 wxPyEndAllowThreads(__tstate);
24748 if (PyErr_Occurred()) SWIG_fail;
24749 }
24750 {
24751 #if wxUSE_UNICODE
24752 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24753 #else
24754 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24755 #endif
24756 }
24757 return resultobj;
24758 fail:
24759 return NULL;
24760 }
24761
24762
24763 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24764 PyObject *resultobj;
24765 wxWindow *arg1 = (wxWindow *) 0 ;
24766 wxString *arg2 = 0 ;
24767 bool temp2 = false ;
24768 PyObject * obj0 = 0 ;
24769 PyObject * obj1 = 0 ;
24770 char *kwnames[] = {
24771 (char *) "self",(char *) "label", NULL
24772 };
24773
24774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
24775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24776 if (SWIG_arg_fail(1)) SWIG_fail;
24777 {
24778 arg2 = wxString_in_helper(obj1);
24779 if (arg2 == NULL) SWIG_fail;
24780 temp2 = true;
24781 }
24782 {
24783 PyThreadState* __tstate = wxPyBeginAllowThreads();
24784 (arg1)->SetLabel((wxString const &)*arg2);
24785
24786 wxPyEndAllowThreads(__tstate);
24787 if (PyErr_Occurred()) SWIG_fail;
24788 }
24789 Py_INCREF(Py_None); resultobj = Py_None;
24790 {
24791 if (temp2)
24792 delete arg2;
24793 }
24794 return resultobj;
24795 fail:
24796 {
24797 if (temp2)
24798 delete arg2;
24799 }
24800 return NULL;
24801 }
24802
24803
24804 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
24805 PyObject *resultobj;
24806 wxWindow *arg1 = (wxWindow *) 0 ;
24807 wxString result;
24808 PyObject * obj0 = 0 ;
24809 char *kwnames[] = {
24810 (char *) "self", NULL
24811 };
24812
24813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
24814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24815 if (SWIG_arg_fail(1)) SWIG_fail;
24816 {
24817 PyThreadState* __tstate = wxPyBeginAllowThreads();
24818 result = ((wxWindow const *)arg1)->GetLabel();
24819
24820 wxPyEndAllowThreads(__tstate);
24821 if (PyErr_Occurred()) SWIG_fail;
24822 }
24823 {
24824 #if wxUSE_UNICODE
24825 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24826 #else
24827 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24828 #endif
24829 }
24830 return resultobj;
24831 fail:
24832 return NULL;
24833 }
24834
24835
24836 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
24837 PyObject *resultobj;
24838 wxWindow *arg1 = (wxWindow *) 0 ;
24839 wxString *arg2 = 0 ;
24840 bool temp2 = false ;
24841 PyObject * obj0 = 0 ;
24842 PyObject * obj1 = 0 ;
24843 char *kwnames[] = {
24844 (char *) "self",(char *) "name", NULL
24845 };
24846
24847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
24848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24849 if (SWIG_arg_fail(1)) SWIG_fail;
24850 {
24851 arg2 = wxString_in_helper(obj1);
24852 if (arg2 == NULL) SWIG_fail;
24853 temp2 = true;
24854 }
24855 {
24856 PyThreadState* __tstate = wxPyBeginAllowThreads();
24857 (arg1)->SetName((wxString const &)*arg2);
24858
24859 wxPyEndAllowThreads(__tstate);
24860 if (PyErr_Occurred()) SWIG_fail;
24861 }
24862 Py_INCREF(Py_None); resultobj = Py_None;
24863 {
24864 if (temp2)
24865 delete arg2;
24866 }
24867 return resultobj;
24868 fail:
24869 {
24870 if (temp2)
24871 delete arg2;
24872 }
24873 return NULL;
24874 }
24875
24876
24877 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
24878 PyObject *resultobj;
24879 wxWindow *arg1 = (wxWindow *) 0 ;
24880 wxString result;
24881 PyObject * obj0 = 0 ;
24882 char *kwnames[] = {
24883 (char *) "self", NULL
24884 };
24885
24886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
24887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24888 if (SWIG_arg_fail(1)) SWIG_fail;
24889 {
24890 PyThreadState* __tstate = wxPyBeginAllowThreads();
24891 result = ((wxWindow const *)arg1)->GetName();
24892
24893 wxPyEndAllowThreads(__tstate);
24894 if (PyErr_Occurred()) SWIG_fail;
24895 }
24896 {
24897 #if wxUSE_UNICODE
24898 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24899 #else
24900 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24901 #endif
24902 }
24903 return resultobj;
24904 fail:
24905 return NULL;
24906 }
24907
24908
24909 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
24910 PyObject *resultobj;
24911 wxWindow *arg1 = (wxWindow *) 0 ;
24912 wxWindowVariant arg2 ;
24913 PyObject * obj0 = 0 ;
24914 PyObject * obj1 = 0 ;
24915 char *kwnames[] = {
24916 (char *) "self",(char *) "variant", NULL
24917 };
24918
24919 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
24920 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24921 if (SWIG_arg_fail(1)) SWIG_fail;
24922 {
24923 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
24924 if (SWIG_arg_fail(2)) SWIG_fail;
24925 }
24926 {
24927 PyThreadState* __tstate = wxPyBeginAllowThreads();
24928 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
24929
24930 wxPyEndAllowThreads(__tstate);
24931 if (PyErr_Occurred()) SWIG_fail;
24932 }
24933 Py_INCREF(Py_None); resultobj = Py_None;
24934 return resultobj;
24935 fail:
24936 return NULL;
24937 }
24938
24939
24940 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
24941 PyObject *resultobj;
24942 wxWindow *arg1 = (wxWindow *) 0 ;
24943 wxWindowVariant result;
24944 PyObject * obj0 = 0 ;
24945 char *kwnames[] = {
24946 (char *) "self", NULL
24947 };
24948
24949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
24950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24951 if (SWIG_arg_fail(1)) SWIG_fail;
24952 {
24953 PyThreadState* __tstate = wxPyBeginAllowThreads();
24954 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
24955
24956 wxPyEndAllowThreads(__tstate);
24957 if (PyErr_Occurred()) SWIG_fail;
24958 }
24959 resultobj = SWIG_From_int((result));
24960 return resultobj;
24961 fail:
24962 return NULL;
24963 }
24964
24965
24966 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
24967 PyObject *resultobj;
24968 wxWindow *arg1 = (wxWindow *) 0 ;
24969 int arg2 ;
24970 PyObject * obj0 = 0 ;
24971 PyObject * obj1 = 0 ;
24972 char *kwnames[] = {
24973 (char *) "self",(char *) "winid", NULL
24974 };
24975
24976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
24977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24978 if (SWIG_arg_fail(1)) SWIG_fail;
24979 {
24980 arg2 = (int)(SWIG_As_int(obj1));
24981 if (SWIG_arg_fail(2)) SWIG_fail;
24982 }
24983 {
24984 PyThreadState* __tstate = wxPyBeginAllowThreads();
24985 (arg1)->SetId(arg2);
24986
24987 wxPyEndAllowThreads(__tstate);
24988 if (PyErr_Occurred()) SWIG_fail;
24989 }
24990 Py_INCREF(Py_None); resultobj = Py_None;
24991 return resultobj;
24992 fail:
24993 return NULL;
24994 }
24995
24996
24997 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
24998 PyObject *resultobj;
24999 wxWindow *arg1 = (wxWindow *) 0 ;
25000 int result;
25001 PyObject * obj0 = 0 ;
25002 char *kwnames[] = {
25003 (char *) "self", NULL
25004 };
25005
25006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25008 if (SWIG_arg_fail(1)) SWIG_fail;
25009 {
25010 PyThreadState* __tstate = wxPyBeginAllowThreads();
25011 result = (int)((wxWindow const *)arg1)->GetId();
25012
25013 wxPyEndAllowThreads(__tstate);
25014 if (PyErr_Occurred()) SWIG_fail;
25015 }
25016 {
25017 resultobj = SWIG_From_int((int)(result));
25018 }
25019 return resultobj;
25020 fail:
25021 return NULL;
25022 }
25023
25024
25025 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25026 PyObject *resultobj;
25027 int result;
25028 char *kwnames[] = {
25029 NULL
25030 };
25031
25032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25033 {
25034 PyThreadState* __tstate = wxPyBeginAllowThreads();
25035 result = (int)wxWindow::NewControlId();
25036
25037 wxPyEndAllowThreads(__tstate);
25038 if (PyErr_Occurred()) SWIG_fail;
25039 }
25040 {
25041 resultobj = SWIG_From_int((int)(result));
25042 }
25043 return resultobj;
25044 fail:
25045 return NULL;
25046 }
25047
25048
25049 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25050 PyObject *resultobj;
25051 int arg1 ;
25052 int result;
25053 PyObject * obj0 = 0 ;
25054 char *kwnames[] = {
25055 (char *) "winid", NULL
25056 };
25057
25058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25059 {
25060 arg1 = (int)(SWIG_As_int(obj0));
25061 if (SWIG_arg_fail(1)) SWIG_fail;
25062 }
25063 {
25064 PyThreadState* __tstate = wxPyBeginAllowThreads();
25065 result = (int)wxWindow::NextControlId(arg1);
25066
25067 wxPyEndAllowThreads(__tstate);
25068 if (PyErr_Occurred()) SWIG_fail;
25069 }
25070 {
25071 resultobj = SWIG_From_int((int)(result));
25072 }
25073 return resultobj;
25074 fail:
25075 return NULL;
25076 }
25077
25078
25079 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25080 PyObject *resultobj;
25081 int arg1 ;
25082 int result;
25083 PyObject * obj0 = 0 ;
25084 char *kwnames[] = {
25085 (char *) "winid", NULL
25086 };
25087
25088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25089 {
25090 arg1 = (int)(SWIG_As_int(obj0));
25091 if (SWIG_arg_fail(1)) SWIG_fail;
25092 }
25093 {
25094 PyThreadState* __tstate = wxPyBeginAllowThreads();
25095 result = (int)wxWindow::PrevControlId(arg1);
25096
25097 wxPyEndAllowThreads(__tstate);
25098 if (PyErr_Occurred()) SWIG_fail;
25099 }
25100 {
25101 resultobj = SWIG_From_int((int)(result));
25102 }
25103 return resultobj;
25104 fail:
25105 return NULL;
25106 }
25107
25108
25109 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25110 PyObject *resultobj;
25111 wxWindow *arg1 = (wxWindow *) 0 ;
25112 wxSize *arg2 = 0 ;
25113 wxSize temp2 ;
25114 PyObject * obj0 = 0 ;
25115 PyObject * obj1 = 0 ;
25116 char *kwnames[] = {
25117 (char *) "self",(char *) "size", NULL
25118 };
25119
25120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25122 if (SWIG_arg_fail(1)) SWIG_fail;
25123 {
25124 arg2 = &temp2;
25125 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25126 }
25127 {
25128 PyThreadState* __tstate = wxPyBeginAllowThreads();
25129 (arg1)->SetSize((wxSize const &)*arg2);
25130
25131 wxPyEndAllowThreads(__tstate);
25132 if (PyErr_Occurred()) SWIG_fail;
25133 }
25134 Py_INCREF(Py_None); resultobj = Py_None;
25135 return resultobj;
25136 fail:
25137 return NULL;
25138 }
25139
25140
25141 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25142 PyObject *resultobj;
25143 wxWindow *arg1 = (wxWindow *) 0 ;
25144 int arg2 ;
25145 int arg3 ;
25146 int arg4 ;
25147 int arg5 ;
25148 int arg6 = (int) wxSIZE_AUTO ;
25149 PyObject * obj0 = 0 ;
25150 PyObject * obj1 = 0 ;
25151 PyObject * obj2 = 0 ;
25152 PyObject * obj3 = 0 ;
25153 PyObject * obj4 = 0 ;
25154 PyObject * obj5 = 0 ;
25155 char *kwnames[] = {
25156 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25157 };
25158
25159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) 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 {
25163 arg2 = (int)(SWIG_As_int(obj1));
25164 if (SWIG_arg_fail(2)) SWIG_fail;
25165 }
25166 {
25167 arg3 = (int)(SWIG_As_int(obj2));
25168 if (SWIG_arg_fail(3)) SWIG_fail;
25169 }
25170 {
25171 arg4 = (int)(SWIG_As_int(obj3));
25172 if (SWIG_arg_fail(4)) SWIG_fail;
25173 }
25174 {
25175 arg5 = (int)(SWIG_As_int(obj4));
25176 if (SWIG_arg_fail(5)) SWIG_fail;
25177 }
25178 if (obj5) {
25179 {
25180 arg6 = (int)(SWIG_As_int(obj5));
25181 if (SWIG_arg_fail(6)) SWIG_fail;
25182 }
25183 }
25184 {
25185 PyThreadState* __tstate = wxPyBeginAllowThreads();
25186 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25187
25188 wxPyEndAllowThreads(__tstate);
25189 if (PyErr_Occurred()) SWIG_fail;
25190 }
25191 Py_INCREF(Py_None); resultobj = Py_None;
25192 return resultobj;
25193 fail:
25194 return NULL;
25195 }
25196
25197
25198 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25199 PyObject *resultobj;
25200 wxWindow *arg1 = (wxWindow *) 0 ;
25201 wxRect *arg2 = 0 ;
25202 int arg3 = (int) wxSIZE_AUTO ;
25203 wxRect temp2 ;
25204 PyObject * obj0 = 0 ;
25205 PyObject * obj1 = 0 ;
25206 PyObject * obj2 = 0 ;
25207 char *kwnames[] = {
25208 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25209 };
25210
25211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25213 if (SWIG_arg_fail(1)) SWIG_fail;
25214 {
25215 arg2 = &temp2;
25216 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25217 }
25218 if (obj2) {
25219 {
25220 arg3 = (int)(SWIG_As_int(obj2));
25221 if (SWIG_arg_fail(3)) SWIG_fail;
25222 }
25223 }
25224 {
25225 PyThreadState* __tstate = wxPyBeginAllowThreads();
25226 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25227
25228 wxPyEndAllowThreads(__tstate);
25229 if (PyErr_Occurred()) SWIG_fail;
25230 }
25231 Py_INCREF(Py_None); resultobj = Py_None;
25232 return resultobj;
25233 fail:
25234 return NULL;
25235 }
25236
25237
25238 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25239 PyObject *resultobj;
25240 wxWindow *arg1 = (wxWindow *) 0 ;
25241 int arg2 ;
25242 int arg3 ;
25243 PyObject * obj0 = 0 ;
25244 PyObject * obj1 = 0 ;
25245 PyObject * obj2 = 0 ;
25246 char *kwnames[] = {
25247 (char *) "self",(char *) "width",(char *) "height", NULL
25248 };
25249
25250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25252 if (SWIG_arg_fail(1)) SWIG_fail;
25253 {
25254 arg2 = (int)(SWIG_As_int(obj1));
25255 if (SWIG_arg_fail(2)) SWIG_fail;
25256 }
25257 {
25258 arg3 = (int)(SWIG_As_int(obj2));
25259 if (SWIG_arg_fail(3)) SWIG_fail;
25260 }
25261 {
25262 PyThreadState* __tstate = wxPyBeginAllowThreads();
25263 (arg1)->SetSize(arg2,arg3);
25264
25265 wxPyEndAllowThreads(__tstate);
25266 if (PyErr_Occurred()) SWIG_fail;
25267 }
25268 Py_INCREF(Py_None); resultobj = Py_None;
25269 return resultobj;
25270 fail:
25271 return NULL;
25272 }
25273
25274
25275 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25276 PyObject *resultobj;
25277 wxWindow *arg1 = (wxWindow *) 0 ;
25278 wxPoint *arg2 = 0 ;
25279 int arg3 = (int) wxSIZE_USE_EXISTING ;
25280 wxPoint temp2 ;
25281 PyObject * obj0 = 0 ;
25282 PyObject * obj1 = 0 ;
25283 PyObject * obj2 = 0 ;
25284 char *kwnames[] = {
25285 (char *) "self",(char *) "pt",(char *) "flags", NULL
25286 };
25287
25288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25290 if (SWIG_arg_fail(1)) SWIG_fail;
25291 {
25292 arg2 = &temp2;
25293 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25294 }
25295 if (obj2) {
25296 {
25297 arg3 = (int)(SWIG_As_int(obj2));
25298 if (SWIG_arg_fail(3)) SWIG_fail;
25299 }
25300 }
25301 {
25302 PyThreadState* __tstate = wxPyBeginAllowThreads();
25303 (arg1)->Move((wxPoint const &)*arg2,arg3);
25304
25305 wxPyEndAllowThreads(__tstate);
25306 if (PyErr_Occurred()) SWIG_fail;
25307 }
25308 Py_INCREF(Py_None); resultobj = Py_None;
25309 return resultobj;
25310 fail:
25311 return NULL;
25312 }
25313
25314
25315 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25316 PyObject *resultobj;
25317 wxWindow *arg1 = (wxWindow *) 0 ;
25318 int arg2 ;
25319 int arg3 ;
25320 int arg4 = (int) wxSIZE_USE_EXISTING ;
25321 PyObject * obj0 = 0 ;
25322 PyObject * obj1 = 0 ;
25323 PyObject * obj2 = 0 ;
25324 PyObject * obj3 = 0 ;
25325 char *kwnames[] = {
25326 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25327 };
25328
25329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25331 if (SWIG_arg_fail(1)) SWIG_fail;
25332 {
25333 arg2 = (int)(SWIG_As_int(obj1));
25334 if (SWIG_arg_fail(2)) SWIG_fail;
25335 }
25336 {
25337 arg3 = (int)(SWIG_As_int(obj2));
25338 if (SWIG_arg_fail(3)) SWIG_fail;
25339 }
25340 if (obj3) {
25341 {
25342 arg4 = (int)(SWIG_As_int(obj3));
25343 if (SWIG_arg_fail(4)) SWIG_fail;
25344 }
25345 }
25346 {
25347 PyThreadState* __tstate = wxPyBeginAllowThreads();
25348 (arg1)->Move(arg2,arg3,arg4);
25349
25350 wxPyEndAllowThreads(__tstate);
25351 if (PyErr_Occurred()) SWIG_fail;
25352 }
25353 Py_INCREF(Py_None); resultobj = Py_None;
25354 return resultobj;
25355 fail:
25356 return NULL;
25357 }
25358
25359
25360 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25361 PyObject *resultobj;
25362 wxWindow *arg1 = (wxWindow *) 0 ;
25363 wxSize const &arg2_defvalue = wxDefaultSize ;
25364 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25365 wxSize temp2 ;
25366 PyObject * obj0 = 0 ;
25367 PyObject * obj1 = 0 ;
25368 char *kwnames[] = {
25369 (char *) "self",(char *) "size", NULL
25370 };
25371
25372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25374 if (SWIG_arg_fail(1)) SWIG_fail;
25375 if (obj1) {
25376 {
25377 arg2 = &temp2;
25378 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25379 }
25380 }
25381 {
25382 PyThreadState* __tstate = wxPyBeginAllowThreads();
25383 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25384
25385 wxPyEndAllowThreads(__tstate);
25386 if (PyErr_Occurred()) SWIG_fail;
25387 }
25388 Py_INCREF(Py_None); resultobj = Py_None;
25389 return resultobj;
25390 fail:
25391 return NULL;
25392 }
25393
25394
25395 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25396 PyObject *resultobj;
25397 wxWindow *arg1 = (wxWindow *) 0 ;
25398 PyObject * obj0 = 0 ;
25399 char *kwnames[] = {
25400 (char *) "self", NULL
25401 };
25402
25403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25405 if (SWIG_arg_fail(1)) SWIG_fail;
25406 {
25407 PyThreadState* __tstate = wxPyBeginAllowThreads();
25408 (arg1)->Raise();
25409
25410 wxPyEndAllowThreads(__tstate);
25411 if (PyErr_Occurred()) SWIG_fail;
25412 }
25413 Py_INCREF(Py_None); resultobj = Py_None;
25414 return resultobj;
25415 fail:
25416 return NULL;
25417 }
25418
25419
25420 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
25421 PyObject *resultobj;
25422 wxWindow *arg1 = (wxWindow *) 0 ;
25423 PyObject * obj0 = 0 ;
25424 char *kwnames[] = {
25425 (char *) "self", NULL
25426 };
25427
25428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
25429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25430 if (SWIG_arg_fail(1)) SWIG_fail;
25431 {
25432 PyThreadState* __tstate = wxPyBeginAllowThreads();
25433 (arg1)->Lower();
25434
25435 wxPyEndAllowThreads(__tstate);
25436 if (PyErr_Occurred()) SWIG_fail;
25437 }
25438 Py_INCREF(Py_None); resultobj = Py_None;
25439 return resultobj;
25440 fail:
25441 return NULL;
25442 }
25443
25444
25445 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25446 PyObject *resultobj;
25447 wxWindow *arg1 = (wxWindow *) 0 ;
25448 wxSize *arg2 = 0 ;
25449 wxSize temp2 ;
25450 PyObject * obj0 = 0 ;
25451 PyObject * obj1 = 0 ;
25452 char *kwnames[] = {
25453 (char *) "self",(char *) "size", NULL
25454 };
25455
25456 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
25457 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25458 if (SWIG_arg_fail(1)) SWIG_fail;
25459 {
25460 arg2 = &temp2;
25461 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25462 }
25463 {
25464 PyThreadState* __tstate = wxPyBeginAllowThreads();
25465 (arg1)->SetClientSize((wxSize const &)*arg2);
25466
25467 wxPyEndAllowThreads(__tstate);
25468 if (PyErr_Occurred()) SWIG_fail;
25469 }
25470 Py_INCREF(Py_None); resultobj = Py_None;
25471 return resultobj;
25472 fail:
25473 return NULL;
25474 }
25475
25476
25477 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25478 PyObject *resultobj;
25479 wxWindow *arg1 = (wxWindow *) 0 ;
25480 int arg2 ;
25481 int arg3 ;
25482 PyObject * obj0 = 0 ;
25483 PyObject * obj1 = 0 ;
25484 PyObject * obj2 = 0 ;
25485 char *kwnames[] = {
25486 (char *) "self",(char *) "width",(char *) "height", NULL
25487 };
25488
25489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25491 if (SWIG_arg_fail(1)) SWIG_fail;
25492 {
25493 arg2 = (int)(SWIG_As_int(obj1));
25494 if (SWIG_arg_fail(2)) SWIG_fail;
25495 }
25496 {
25497 arg3 = (int)(SWIG_As_int(obj2));
25498 if (SWIG_arg_fail(3)) SWIG_fail;
25499 }
25500 {
25501 PyThreadState* __tstate = wxPyBeginAllowThreads();
25502 (arg1)->SetClientSize(arg2,arg3);
25503
25504 wxPyEndAllowThreads(__tstate);
25505 if (PyErr_Occurred()) SWIG_fail;
25506 }
25507 Py_INCREF(Py_None); resultobj = Py_None;
25508 return resultobj;
25509 fail:
25510 return NULL;
25511 }
25512
25513
25514 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25515 PyObject *resultobj;
25516 wxWindow *arg1 = (wxWindow *) 0 ;
25517 wxRect *arg2 = 0 ;
25518 wxRect temp2 ;
25519 PyObject * obj0 = 0 ;
25520 PyObject * obj1 = 0 ;
25521 char *kwnames[] = {
25522 (char *) "self",(char *) "rect", NULL
25523 };
25524
25525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
25526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25527 if (SWIG_arg_fail(1)) SWIG_fail;
25528 {
25529 arg2 = &temp2;
25530 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25531 }
25532 {
25533 PyThreadState* __tstate = wxPyBeginAllowThreads();
25534 (arg1)->SetClientSize((wxRect const &)*arg2);
25535
25536 wxPyEndAllowThreads(__tstate);
25537 if (PyErr_Occurred()) SWIG_fail;
25538 }
25539 Py_INCREF(Py_None); resultobj = Py_None;
25540 return resultobj;
25541 fail:
25542 return NULL;
25543 }
25544
25545
25546 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
25547 PyObject *resultobj;
25548 wxWindow *arg1 = (wxWindow *) 0 ;
25549 wxPoint result;
25550 PyObject * obj0 = 0 ;
25551 char *kwnames[] = {
25552 (char *) "self", NULL
25553 };
25554
25555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
25556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25557 if (SWIG_arg_fail(1)) SWIG_fail;
25558 {
25559 PyThreadState* __tstate = wxPyBeginAllowThreads();
25560 result = (arg1)->GetPosition();
25561
25562 wxPyEndAllowThreads(__tstate);
25563 if (PyErr_Occurred()) SWIG_fail;
25564 }
25565 {
25566 wxPoint * resultptr;
25567 resultptr = new wxPoint((wxPoint &)(result));
25568 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25569 }
25570 return resultobj;
25571 fail:
25572 return NULL;
25573 }
25574
25575
25576 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25577 PyObject *resultobj;
25578 wxWindow *arg1 = (wxWindow *) 0 ;
25579 int *arg2 = (int *) 0 ;
25580 int *arg3 = (int *) 0 ;
25581 int temp2 ;
25582 int res2 = 0 ;
25583 int temp3 ;
25584 int res3 = 0 ;
25585 PyObject * obj0 = 0 ;
25586 char *kwnames[] = {
25587 (char *) "self", NULL
25588 };
25589
25590 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25591 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
25593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25594 if (SWIG_arg_fail(1)) SWIG_fail;
25595 {
25596 PyThreadState* __tstate = wxPyBeginAllowThreads();
25597 (arg1)->GetPosition(arg2,arg3);
25598
25599 wxPyEndAllowThreads(__tstate);
25600 if (PyErr_Occurred()) SWIG_fail;
25601 }
25602 Py_INCREF(Py_None); resultobj = Py_None;
25603 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25604 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25605 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25606 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25607 return resultobj;
25608 fail:
25609 return NULL;
25610 }
25611
25612
25613 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25614 PyObject *resultobj;
25615 wxWindow *arg1 = (wxWindow *) 0 ;
25616 wxSize result;
25617 PyObject * obj0 = 0 ;
25618 char *kwnames[] = {
25619 (char *) "self", NULL
25620 };
25621
25622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
25623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25624 if (SWIG_arg_fail(1)) SWIG_fail;
25625 {
25626 PyThreadState* __tstate = wxPyBeginAllowThreads();
25627 result = ((wxWindow const *)arg1)->GetSize();
25628
25629 wxPyEndAllowThreads(__tstate);
25630 if (PyErr_Occurred()) SWIG_fail;
25631 }
25632 {
25633 wxSize * resultptr;
25634 resultptr = new wxSize((wxSize &)(result));
25635 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25636 }
25637 return resultobj;
25638 fail:
25639 return NULL;
25640 }
25641
25642
25643 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25644 PyObject *resultobj;
25645 wxWindow *arg1 = (wxWindow *) 0 ;
25646 int *arg2 = (int *) 0 ;
25647 int *arg3 = (int *) 0 ;
25648 int temp2 ;
25649 int res2 = 0 ;
25650 int temp3 ;
25651 int res3 = 0 ;
25652 PyObject * obj0 = 0 ;
25653 char *kwnames[] = {
25654 (char *) "self", NULL
25655 };
25656
25657 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25658 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
25660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25661 if (SWIG_arg_fail(1)) SWIG_fail;
25662 {
25663 PyThreadState* __tstate = wxPyBeginAllowThreads();
25664 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
25665
25666 wxPyEndAllowThreads(__tstate);
25667 if (PyErr_Occurred()) SWIG_fail;
25668 }
25669 Py_INCREF(Py_None); resultobj = Py_None;
25670 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25671 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25672 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25673 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25674 return resultobj;
25675 fail:
25676 return NULL;
25677 }
25678
25679
25680 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25681 PyObject *resultobj;
25682 wxWindow *arg1 = (wxWindow *) 0 ;
25683 wxRect result;
25684 PyObject * obj0 = 0 ;
25685 char *kwnames[] = {
25686 (char *) "self", NULL
25687 };
25688
25689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
25690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25691 if (SWIG_arg_fail(1)) SWIG_fail;
25692 {
25693 PyThreadState* __tstate = wxPyBeginAllowThreads();
25694 result = ((wxWindow const *)arg1)->GetRect();
25695
25696 wxPyEndAllowThreads(__tstate);
25697 if (PyErr_Occurred()) SWIG_fail;
25698 }
25699 {
25700 wxRect * resultptr;
25701 resultptr = new wxRect((wxRect &)(result));
25702 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25703 }
25704 return resultobj;
25705 fail:
25706 return NULL;
25707 }
25708
25709
25710 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
25711 PyObject *resultobj;
25712 wxWindow *arg1 = (wxWindow *) 0 ;
25713 wxSize result;
25714 PyObject * obj0 = 0 ;
25715 char *kwnames[] = {
25716 (char *) "self", NULL
25717 };
25718
25719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
25720 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25721 if (SWIG_arg_fail(1)) SWIG_fail;
25722 {
25723 PyThreadState* __tstate = wxPyBeginAllowThreads();
25724 result = ((wxWindow const *)arg1)->GetClientSize();
25725
25726 wxPyEndAllowThreads(__tstate);
25727 if (PyErr_Occurred()) SWIG_fail;
25728 }
25729 {
25730 wxSize * resultptr;
25731 resultptr = new wxSize((wxSize &)(result));
25732 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25733 }
25734 return resultobj;
25735 fail:
25736 return NULL;
25737 }
25738
25739
25740 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25741 PyObject *resultobj;
25742 wxWindow *arg1 = (wxWindow *) 0 ;
25743 int *arg2 = (int *) 0 ;
25744 int *arg3 = (int *) 0 ;
25745 int temp2 ;
25746 int res2 = 0 ;
25747 int temp3 ;
25748 int res3 = 0 ;
25749 PyObject * obj0 = 0 ;
25750 char *kwnames[] = {
25751 (char *) "self", NULL
25752 };
25753
25754 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25755 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
25757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25758 if (SWIG_arg_fail(1)) SWIG_fail;
25759 {
25760 PyThreadState* __tstate = wxPyBeginAllowThreads();
25761 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
25762
25763 wxPyEndAllowThreads(__tstate);
25764 if (PyErr_Occurred()) SWIG_fail;
25765 }
25766 Py_INCREF(Py_None); resultobj = Py_None;
25767 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25768 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25769 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25770 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25771 return resultobj;
25772 fail:
25773 return NULL;
25774 }
25775
25776
25777 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
25778 PyObject *resultobj;
25779 wxWindow *arg1 = (wxWindow *) 0 ;
25780 wxPoint result;
25781 PyObject * obj0 = 0 ;
25782 char *kwnames[] = {
25783 (char *) "self", NULL
25784 };
25785
25786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
25787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25788 if (SWIG_arg_fail(1)) SWIG_fail;
25789 {
25790 PyThreadState* __tstate = wxPyBeginAllowThreads();
25791 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
25792
25793 wxPyEndAllowThreads(__tstate);
25794 if (PyErr_Occurred()) SWIG_fail;
25795 }
25796 {
25797 wxPoint * resultptr;
25798 resultptr = new wxPoint((wxPoint &)(result));
25799 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
25800 }
25801 return resultobj;
25802 fail:
25803 return NULL;
25804 }
25805
25806
25807 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
25808 PyObject *resultobj;
25809 wxWindow *arg1 = (wxWindow *) 0 ;
25810 wxRect result;
25811 PyObject * obj0 = 0 ;
25812 char *kwnames[] = {
25813 (char *) "self", NULL
25814 };
25815
25816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
25817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25818 if (SWIG_arg_fail(1)) SWIG_fail;
25819 {
25820 PyThreadState* __tstate = wxPyBeginAllowThreads();
25821 result = ((wxWindow const *)arg1)->GetClientRect();
25822
25823 wxPyEndAllowThreads(__tstate);
25824 if (PyErr_Occurred()) SWIG_fail;
25825 }
25826 {
25827 wxRect * resultptr;
25828 resultptr = new wxRect((wxRect &)(result));
25829 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
25830 }
25831 return resultobj;
25832 fail:
25833 return NULL;
25834 }
25835
25836
25837 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25838 PyObject *resultobj;
25839 wxWindow *arg1 = (wxWindow *) 0 ;
25840 wxSize result;
25841 PyObject * obj0 = 0 ;
25842 char *kwnames[] = {
25843 (char *) "self", NULL
25844 };
25845
25846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
25847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25848 if (SWIG_arg_fail(1)) SWIG_fail;
25849 {
25850 PyThreadState* __tstate = wxPyBeginAllowThreads();
25851 result = ((wxWindow const *)arg1)->GetBestSize();
25852
25853 wxPyEndAllowThreads(__tstate);
25854 if (PyErr_Occurred()) SWIG_fail;
25855 }
25856 {
25857 wxSize * resultptr;
25858 resultptr = new wxSize((wxSize &)(result));
25859 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25860 }
25861 return resultobj;
25862 fail:
25863 return NULL;
25864 }
25865
25866
25867 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
25868 PyObject *resultobj;
25869 wxWindow *arg1 = (wxWindow *) 0 ;
25870 int *arg2 = (int *) 0 ;
25871 int *arg3 = (int *) 0 ;
25872 int temp2 ;
25873 int res2 = 0 ;
25874 int temp3 ;
25875 int res3 = 0 ;
25876 PyObject * obj0 = 0 ;
25877 char *kwnames[] = {
25878 (char *) "self", NULL
25879 };
25880
25881 arg2 = &temp2; res2 = SWIG_NEWOBJ;
25882 arg3 = &temp3; res3 = SWIG_NEWOBJ;
25883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
25884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25885 if (SWIG_arg_fail(1)) SWIG_fail;
25886 {
25887 PyThreadState* __tstate = wxPyBeginAllowThreads();
25888 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
25889
25890 wxPyEndAllowThreads(__tstate);
25891 if (PyErr_Occurred()) SWIG_fail;
25892 }
25893 Py_INCREF(Py_None); resultobj = Py_None;
25894 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
25895 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
25896 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
25897 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
25898 return resultobj;
25899 fail:
25900 return NULL;
25901 }
25902
25903
25904 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25905 PyObject *resultobj;
25906 wxWindow *arg1 = (wxWindow *) 0 ;
25907 PyObject * obj0 = 0 ;
25908 char *kwnames[] = {
25909 (char *) "self", NULL
25910 };
25911
25912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
25913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25914 if (SWIG_arg_fail(1)) SWIG_fail;
25915 {
25916 PyThreadState* __tstate = wxPyBeginAllowThreads();
25917 (arg1)->InvalidateBestSize();
25918
25919 wxPyEndAllowThreads(__tstate);
25920 if (PyErr_Occurred()) SWIG_fail;
25921 }
25922 Py_INCREF(Py_None); resultobj = Py_None;
25923 return resultobj;
25924 fail:
25925 return NULL;
25926 }
25927
25928
25929 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25930 PyObject *resultobj;
25931 wxWindow *arg1 = (wxWindow *) 0 ;
25932 wxSize result;
25933 PyObject * obj0 = 0 ;
25934 char *kwnames[] = {
25935 (char *) "self", NULL
25936 };
25937
25938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
25939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25940 if (SWIG_arg_fail(1)) SWIG_fail;
25941 {
25942 PyThreadState* __tstate = wxPyBeginAllowThreads();
25943 result = ((wxWindow const *)arg1)->GetBestFittingSize();
25944
25945 wxPyEndAllowThreads(__tstate);
25946 if (PyErr_Occurred()) SWIG_fail;
25947 }
25948 {
25949 wxSize * resultptr;
25950 resultptr = new wxSize((wxSize &)(result));
25951 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25952 }
25953 return resultobj;
25954 fail:
25955 return NULL;
25956 }
25957
25958
25959 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
25960 PyObject *resultobj;
25961 wxWindow *arg1 = (wxWindow *) 0 ;
25962 wxSize result;
25963 PyObject * obj0 = 0 ;
25964 char *kwnames[] = {
25965 (char *) "self", NULL
25966 };
25967
25968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
25969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25970 if (SWIG_arg_fail(1)) SWIG_fail;
25971 {
25972 PyThreadState* __tstate = wxPyBeginAllowThreads();
25973 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
25974
25975 wxPyEndAllowThreads(__tstate);
25976 if (PyErr_Occurred()) SWIG_fail;
25977 }
25978 {
25979 wxSize * resultptr;
25980 resultptr = new wxSize((wxSize &)(result));
25981 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
25982 }
25983 return resultobj;
25984 fail:
25985 return NULL;
25986 }
25987
25988
25989 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
25990 PyObject *resultobj;
25991 wxWindow *arg1 = (wxWindow *) 0 ;
25992 int arg2 = (int) wxBOTH ;
25993 PyObject * obj0 = 0 ;
25994 PyObject * obj1 = 0 ;
25995 char *kwnames[] = {
25996 (char *) "self",(char *) "direction", NULL
25997 };
25998
25999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26001 if (SWIG_arg_fail(1)) SWIG_fail;
26002 if (obj1) {
26003 {
26004 arg2 = (int)(SWIG_As_int(obj1));
26005 if (SWIG_arg_fail(2)) SWIG_fail;
26006 }
26007 }
26008 {
26009 PyThreadState* __tstate = wxPyBeginAllowThreads();
26010 (arg1)->Center(arg2);
26011
26012 wxPyEndAllowThreads(__tstate);
26013 if (PyErr_Occurred()) SWIG_fail;
26014 }
26015 Py_INCREF(Py_None); resultobj = Py_None;
26016 return resultobj;
26017 fail:
26018 return NULL;
26019 }
26020
26021
26022 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26023 PyObject *resultobj;
26024 wxWindow *arg1 = (wxWindow *) 0 ;
26025 int arg2 = (int) wxBOTH ;
26026 PyObject * obj0 = 0 ;
26027 PyObject * obj1 = 0 ;
26028 char *kwnames[] = {
26029 (char *) "self",(char *) "dir", NULL
26030 };
26031
26032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26034 if (SWIG_arg_fail(1)) SWIG_fail;
26035 if (obj1) {
26036 {
26037 arg2 = (int)(SWIG_As_int(obj1));
26038 if (SWIG_arg_fail(2)) SWIG_fail;
26039 }
26040 }
26041 {
26042 PyThreadState* __tstate = wxPyBeginAllowThreads();
26043 (arg1)->CenterOnScreen(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_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26056 PyObject *resultobj;
26057 wxWindow *arg1 = (wxWindow *) 0 ;
26058 int arg2 = (int) wxBOTH ;
26059 PyObject * obj0 = 0 ;
26060 PyObject * obj1 = 0 ;
26061 char *kwnames[] = {
26062 (char *) "self",(char *) "dir", NULL
26063 };
26064
26065 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26066 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26067 if (SWIG_arg_fail(1)) SWIG_fail;
26068 if (obj1) {
26069 {
26070 arg2 = (int)(SWIG_As_int(obj1));
26071 if (SWIG_arg_fail(2)) SWIG_fail;
26072 }
26073 }
26074 {
26075 PyThreadState* __tstate = wxPyBeginAllowThreads();
26076 (arg1)->CenterOnParent(arg2);
26077
26078 wxPyEndAllowThreads(__tstate);
26079 if (PyErr_Occurred()) SWIG_fail;
26080 }
26081 Py_INCREF(Py_None); resultobj = Py_None;
26082 return resultobj;
26083 fail:
26084 return NULL;
26085 }
26086
26087
26088 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26089 PyObject *resultobj;
26090 wxWindow *arg1 = (wxWindow *) 0 ;
26091 PyObject * obj0 = 0 ;
26092 char *kwnames[] = {
26093 (char *) "self", NULL
26094 };
26095
26096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26098 if (SWIG_arg_fail(1)) SWIG_fail;
26099 {
26100 PyThreadState* __tstate = wxPyBeginAllowThreads();
26101 (arg1)->Fit();
26102
26103 wxPyEndAllowThreads(__tstate);
26104 if (PyErr_Occurred()) SWIG_fail;
26105 }
26106 Py_INCREF(Py_None); resultobj = Py_None;
26107 return resultobj;
26108 fail:
26109 return NULL;
26110 }
26111
26112
26113 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26114 PyObject *resultobj;
26115 wxWindow *arg1 = (wxWindow *) 0 ;
26116 PyObject * obj0 = 0 ;
26117 char *kwnames[] = {
26118 (char *) "self", NULL
26119 };
26120
26121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26123 if (SWIG_arg_fail(1)) SWIG_fail;
26124 {
26125 PyThreadState* __tstate = wxPyBeginAllowThreads();
26126 (arg1)->FitInside();
26127
26128 wxPyEndAllowThreads(__tstate);
26129 if (PyErr_Occurred()) SWIG_fail;
26130 }
26131 Py_INCREF(Py_None); resultobj = Py_None;
26132 return resultobj;
26133 fail:
26134 return NULL;
26135 }
26136
26137
26138 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26139 PyObject *resultobj;
26140 wxWindow *arg1 = (wxWindow *) 0 ;
26141 int arg2 ;
26142 int arg3 ;
26143 int arg4 = (int) -1 ;
26144 int arg5 = (int) -1 ;
26145 int arg6 = (int) -1 ;
26146 int arg7 = (int) -1 ;
26147 PyObject * obj0 = 0 ;
26148 PyObject * obj1 = 0 ;
26149 PyObject * obj2 = 0 ;
26150 PyObject * obj3 = 0 ;
26151 PyObject * obj4 = 0 ;
26152 PyObject * obj5 = 0 ;
26153 PyObject * obj6 = 0 ;
26154 char *kwnames[] = {
26155 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26156 };
26157
26158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26160 if (SWIG_arg_fail(1)) SWIG_fail;
26161 {
26162 arg2 = (int)(SWIG_As_int(obj1));
26163 if (SWIG_arg_fail(2)) SWIG_fail;
26164 }
26165 {
26166 arg3 = (int)(SWIG_As_int(obj2));
26167 if (SWIG_arg_fail(3)) SWIG_fail;
26168 }
26169 if (obj3) {
26170 {
26171 arg4 = (int)(SWIG_As_int(obj3));
26172 if (SWIG_arg_fail(4)) SWIG_fail;
26173 }
26174 }
26175 if (obj4) {
26176 {
26177 arg5 = (int)(SWIG_As_int(obj4));
26178 if (SWIG_arg_fail(5)) SWIG_fail;
26179 }
26180 }
26181 if (obj5) {
26182 {
26183 arg6 = (int)(SWIG_As_int(obj5));
26184 if (SWIG_arg_fail(6)) SWIG_fail;
26185 }
26186 }
26187 if (obj6) {
26188 {
26189 arg7 = (int)(SWIG_As_int(obj6));
26190 if (SWIG_arg_fail(7)) SWIG_fail;
26191 }
26192 }
26193 {
26194 PyThreadState* __tstate = wxPyBeginAllowThreads();
26195 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26196
26197 wxPyEndAllowThreads(__tstate);
26198 if (PyErr_Occurred()) SWIG_fail;
26199 }
26200 Py_INCREF(Py_None); resultobj = Py_None;
26201 return resultobj;
26202 fail:
26203 return NULL;
26204 }
26205
26206
26207 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26208 PyObject *resultobj;
26209 wxWindow *arg1 = (wxWindow *) 0 ;
26210 wxSize *arg2 = 0 ;
26211 wxSize const &arg3_defvalue = wxDefaultSize ;
26212 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26213 wxSize const &arg4_defvalue = wxDefaultSize ;
26214 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26215 wxSize temp2 ;
26216 wxSize temp3 ;
26217 wxSize temp4 ;
26218 PyObject * obj0 = 0 ;
26219 PyObject * obj1 = 0 ;
26220 PyObject * obj2 = 0 ;
26221 PyObject * obj3 = 0 ;
26222 char *kwnames[] = {
26223 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26224 };
26225
26226 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26227 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26228 if (SWIG_arg_fail(1)) SWIG_fail;
26229 {
26230 arg2 = &temp2;
26231 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26232 }
26233 if (obj2) {
26234 {
26235 arg3 = &temp3;
26236 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26237 }
26238 }
26239 if (obj3) {
26240 {
26241 arg4 = &temp4;
26242 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26243 }
26244 }
26245 {
26246 PyThreadState* __tstate = wxPyBeginAllowThreads();
26247 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26248
26249 wxPyEndAllowThreads(__tstate);
26250 if (PyErr_Occurred()) SWIG_fail;
26251 }
26252 Py_INCREF(Py_None); resultobj = Py_None;
26253 return resultobj;
26254 fail:
26255 return NULL;
26256 }
26257
26258
26259 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26260 PyObject *resultobj;
26261 wxWindow *arg1 = (wxWindow *) 0 ;
26262 int arg2 ;
26263 int arg3 ;
26264 int arg4 = (int) -1 ;
26265 int arg5 = (int) -1 ;
26266 PyObject * obj0 = 0 ;
26267 PyObject * obj1 = 0 ;
26268 PyObject * obj2 = 0 ;
26269 PyObject * obj3 = 0 ;
26270 PyObject * obj4 = 0 ;
26271 char *kwnames[] = {
26272 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26273 };
26274
26275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26277 if (SWIG_arg_fail(1)) SWIG_fail;
26278 {
26279 arg2 = (int)(SWIG_As_int(obj1));
26280 if (SWIG_arg_fail(2)) SWIG_fail;
26281 }
26282 {
26283 arg3 = (int)(SWIG_As_int(obj2));
26284 if (SWIG_arg_fail(3)) SWIG_fail;
26285 }
26286 if (obj3) {
26287 {
26288 arg4 = (int)(SWIG_As_int(obj3));
26289 if (SWIG_arg_fail(4)) SWIG_fail;
26290 }
26291 }
26292 if (obj4) {
26293 {
26294 arg5 = (int)(SWIG_As_int(obj4));
26295 if (SWIG_arg_fail(5)) SWIG_fail;
26296 }
26297 }
26298 {
26299 PyThreadState* __tstate = wxPyBeginAllowThreads();
26300 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26301
26302 wxPyEndAllowThreads(__tstate);
26303 if (PyErr_Occurred()) SWIG_fail;
26304 }
26305 Py_INCREF(Py_None); resultobj = Py_None;
26306 return resultobj;
26307 fail:
26308 return NULL;
26309 }
26310
26311
26312 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26313 PyObject *resultobj;
26314 wxWindow *arg1 = (wxWindow *) 0 ;
26315 wxSize *arg2 = 0 ;
26316 wxSize const &arg3_defvalue = wxDefaultSize ;
26317 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26318 wxSize temp2 ;
26319 wxSize temp3 ;
26320 PyObject * obj0 = 0 ;
26321 PyObject * obj1 = 0 ;
26322 PyObject * obj2 = 0 ;
26323 char *kwnames[] = {
26324 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26325 };
26326
26327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26329 if (SWIG_arg_fail(1)) SWIG_fail;
26330 {
26331 arg2 = &temp2;
26332 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26333 }
26334 if (obj2) {
26335 {
26336 arg3 = &temp3;
26337 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26338 }
26339 }
26340 {
26341 PyThreadState* __tstate = wxPyBeginAllowThreads();
26342 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26343
26344 wxPyEndAllowThreads(__tstate);
26345 if (PyErr_Occurred()) SWIG_fail;
26346 }
26347 Py_INCREF(Py_None); resultobj = Py_None;
26348 return resultobj;
26349 fail:
26350 return NULL;
26351 }
26352
26353
26354 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26355 PyObject *resultobj;
26356 wxWindow *arg1 = (wxWindow *) 0 ;
26357 wxSize result;
26358 PyObject * obj0 = 0 ;
26359 char *kwnames[] = {
26360 (char *) "self", NULL
26361 };
26362
26363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26365 if (SWIG_arg_fail(1)) SWIG_fail;
26366 {
26367 PyThreadState* __tstate = wxPyBeginAllowThreads();
26368 result = ((wxWindow const *)arg1)->GetMaxSize();
26369
26370 wxPyEndAllowThreads(__tstate);
26371 if (PyErr_Occurred()) SWIG_fail;
26372 }
26373 {
26374 wxSize * resultptr;
26375 resultptr = new wxSize((wxSize &)(result));
26376 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26377 }
26378 return resultobj;
26379 fail:
26380 return NULL;
26381 }
26382
26383
26384 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26385 PyObject *resultobj;
26386 wxWindow *arg1 = (wxWindow *) 0 ;
26387 wxSize result;
26388 PyObject * obj0 = 0 ;
26389 char *kwnames[] = {
26390 (char *) "self", NULL
26391 };
26392
26393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26395 if (SWIG_arg_fail(1)) SWIG_fail;
26396 {
26397 PyThreadState* __tstate = wxPyBeginAllowThreads();
26398 result = ((wxWindow const *)arg1)->GetMinSize();
26399
26400 wxPyEndAllowThreads(__tstate);
26401 if (PyErr_Occurred()) SWIG_fail;
26402 }
26403 {
26404 wxSize * resultptr;
26405 resultptr = new wxSize((wxSize &)(result));
26406 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26407 }
26408 return resultobj;
26409 fail:
26410 return NULL;
26411 }
26412
26413
26414 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26415 PyObject *resultobj;
26416 wxWindow *arg1 = (wxWindow *) 0 ;
26417 wxSize *arg2 = 0 ;
26418 wxSize temp2 ;
26419 PyObject * obj0 = 0 ;
26420 PyObject * obj1 = 0 ;
26421 char *kwnames[] = {
26422 (char *) "self",(char *) "minSize", NULL
26423 };
26424
26425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
26426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26427 if (SWIG_arg_fail(1)) SWIG_fail;
26428 {
26429 arg2 = &temp2;
26430 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26431 }
26432 {
26433 PyThreadState* __tstate = wxPyBeginAllowThreads();
26434 (arg1)->SetMinSize((wxSize const &)*arg2);
26435
26436 wxPyEndAllowThreads(__tstate);
26437 if (PyErr_Occurred()) SWIG_fail;
26438 }
26439 Py_INCREF(Py_None); resultobj = Py_None;
26440 return resultobj;
26441 fail:
26442 return NULL;
26443 }
26444
26445
26446 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26447 PyObject *resultobj;
26448 wxWindow *arg1 = (wxWindow *) 0 ;
26449 wxSize *arg2 = 0 ;
26450 wxSize temp2 ;
26451 PyObject * obj0 = 0 ;
26452 PyObject * obj1 = 0 ;
26453 char *kwnames[] = {
26454 (char *) "self",(char *) "maxSize", NULL
26455 };
26456
26457 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
26458 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26459 if (SWIG_arg_fail(1)) SWIG_fail;
26460 {
26461 arg2 = &temp2;
26462 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26463 }
26464 {
26465 PyThreadState* __tstate = wxPyBeginAllowThreads();
26466 (arg1)->SetMaxSize((wxSize const &)*arg2);
26467
26468 wxPyEndAllowThreads(__tstate);
26469 if (PyErr_Occurred()) SWIG_fail;
26470 }
26471 Py_INCREF(Py_None); resultobj = Py_None;
26472 return resultobj;
26473 fail:
26474 return NULL;
26475 }
26476
26477
26478 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26479 PyObject *resultobj;
26480 wxWindow *arg1 = (wxWindow *) 0 ;
26481 int result;
26482 PyObject * obj0 = 0 ;
26483 char *kwnames[] = {
26484 (char *) "self", NULL
26485 };
26486
26487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
26488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26489 if (SWIG_arg_fail(1)) SWIG_fail;
26490 {
26491 PyThreadState* __tstate = wxPyBeginAllowThreads();
26492 result = (int)((wxWindow const *)arg1)->GetMinWidth();
26493
26494 wxPyEndAllowThreads(__tstate);
26495 if (PyErr_Occurred()) SWIG_fail;
26496 }
26497 {
26498 resultobj = SWIG_From_int((int)(result));
26499 }
26500 return resultobj;
26501 fail:
26502 return NULL;
26503 }
26504
26505
26506 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26507 PyObject *resultobj;
26508 wxWindow *arg1 = (wxWindow *) 0 ;
26509 int result;
26510 PyObject * obj0 = 0 ;
26511 char *kwnames[] = {
26512 (char *) "self", NULL
26513 };
26514
26515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
26516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26517 if (SWIG_arg_fail(1)) SWIG_fail;
26518 {
26519 PyThreadState* __tstate = wxPyBeginAllowThreads();
26520 result = (int)((wxWindow const *)arg1)->GetMinHeight();
26521
26522 wxPyEndAllowThreads(__tstate);
26523 if (PyErr_Occurred()) SWIG_fail;
26524 }
26525 {
26526 resultobj = SWIG_From_int((int)(result));
26527 }
26528 return resultobj;
26529 fail:
26530 return NULL;
26531 }
26532
26533
26534 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
26535 PyObject *resultobj;
26536 wxWindow *arg1 = (wxWindow *) 0 ;
26537 int result;
26538 PyObject * obj0 = 0 ;
26539 char *kwnames[] = {
26540 (char *) "self", NULL
26541 };
26542
26543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
26544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26545 if (SWIG_arg_fail(1)) SWIG_fail;
26546 {
26547 PyThreadState* __tstate = wxPyBeginAllowThreads();
26548 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
26549
26550 wxPyEndAllowThreads(__tstate);
26551 if (PyErr_Occurred()) SWIG_fail;
26552 }
26553 {
26554 resultobj = SWIG_From_int((int)(result));
26555 }
26556 return resultobj;
26557 fail:
26558 return NULL;
26559 }
26560
26561
26562 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
26563 PyObject *resultobj;
26564 wxWindow *arg1 = (wxWindow *) 0 ;
26565 int result;
26566 PyObject * obj0 = 0 ;
26567 char *kwnames[] = {
26568 (char *) "self", NULL
26569 };
26570
26571 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
26572 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26573 if (SWIG_arg_fail(1)) SWIG_fail;
26574 {
26575 PyThreadState* __tstate = wxPyBeginAllowThreads();
26576 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
26577
26578 wxPyEndAllowThreads(__tstate);
26579 if (PyErr_Occurred()) SWIG_fail;
26580 }
26581 {
26582 resultobj = SWIG_From_int((int)(result));
26583 }
26584 return resultobj;
26585 fail:
26586 return NULL;
26587 }
26588
26589
26590 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26591 PyObject *resultobj;
26592 wxWindow *arg1 = (wxWindow *) 0 ;
26593 wxSize *arg2 = 0 ;
26594 wxSize temp2 ;
26595 PyObject * obj0 = 0 ;
26596 PyObject * obj1 = 0 ;
26597 char *kwnames[] = {
26598 (char *) "self",(char *) "size", NULL
26599 };
26600
26601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
26602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26603 if (SWIG_arg_fail(1)) SWIG_fail;
26604 {
26605 arg2 = &temp2;
26606 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26607 }
26608 {
26609 PyThreadState* __tstate = wxPyBeginAllowThreads();
26610 (arg1)->SetVirtualSize((wxSize const &)*arg2);
26611
26612 wxPyEndAllowThreads(__tstate);
26613 if (PyErr_Occurred()) SWIG_fail;
26614 }
26615 Py_INCREF(Py_None); resultobj = Py_None;
26616 return resultobj;
26617 fail:
26618 return NULL;
26619 }
26620
26621
26622 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26623 PyObject *resultobj;
26624 wxWindow *arg1 = (wxWindow *) 0 ;
26625 int arg2 ;
26626 int arg3 ;
26627 PyObject * obj0 = 0 ;
26628 PyObject * obj1 = 0 ;
26629 PyObject * obj2 = 0 ;
26630 char *kwnames[] = {
26631 (char *) "self",(char *) "w",(char *) "h", NULL
26632 };
26633
26634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26636 if (SWIG_arg_fail(1)) SWIG_fail;
26637 {
26638 arg2 = (int)(SWIG_As_int(obj1));
26639 if (SWIG_arg_fail(2)) SWIG_fail;
26640 }
26641 {
26642 arg3 = (int)(SWIG_As_int(obj2));
26643 if (SWIG_arg_fail(3)) SWIG_fail;
26644 }
26645 {
26646 PyThreadState* __tstate = wxPyBeginAllowThreads();
26647 (arg1)->SetVirtualSize(arg2,arg3);
26648
26649 wxPyEndAllowThreads(__tstate);
26650 if (PyErr_Occurred()) SWIG_fail;
26651 }
26652 Py_INCREF(Py_None); resultobj = Py_None;
26653 return resultobj;
26654 fail:
26655 return NULL;
26656 }
26657
26658
26659 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26660 PyObject *resultobj;
26661 wxWindow *arg1 = (wxWindow *) 0 ;
26662 wxSize result;
26663 PyObject * obj0 = 0 ;
26664 char *kwnames[] = {
26665 (char *) "self", NULL
26666 };
26667
26668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
26669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26670 if (SWIG_arg_fail(1)) SWIG_fail;
26671 {
26672 PyThreadState* __tstate = wxPyBeginAllowThreads();
26673 result = ((wxWindow const *)arg1)->GetVirtualSize();
26674
26675 wxPyEndAllowThreads(__tstate);
26676 if (PyErr_Occurred()) SWIG_fail;
26677 }
26678 {
26679 wxSize * resultptr;
26680 resultptr = new wxSize((wxSize &)(result));
26681 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26682 }
26683 return resultobj;
26684 fail:
26685 return NULL;
26686 }
26687
26688
26689 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26690 PyObject *resultobj;
26691 wxWindow *arg1 = (wxWindow *) 0 ;
26692 int *arg2 = (int *) 0 ;
26693 int *arg3 = (int *) 0 ;
26694 int temp2 ;
26695 int res2 = 0 ;
26696 int temp3 ;
26697 int res3 = 0 ;
26698 PyObject * obj0 = 0 ;
26699 char *kwnames[] = {
26700 (char *) "self", NULL
26701 };
26702
26703 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26704 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
26706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26707 if (SWIG_arg_fail(1)) SWIG_fail;
26708 {
26709 PyThreadState* __tstate = wxPyBeginAllowThreads();
26710 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
26711
26712 wxPyEndAllowThreads(__tstate);
26713 if (PyErr_Occurred()) SWIG_fail;
26714 }
26715 Py_INCREF(Py_None); resultobj = Py_None;
26716 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26717 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26718 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26719 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26720 return resultobj;
26721 fail:
26722 return NULL;
26723 }
26724
26725
26726 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
26727 PyObject *resultobj;
26728 wxWindow *arg1 = (wxWindow *) 0 ;
26729 wxSize result;
26730 PyObject * obj0 = 0 ;
26731 char *kwnames[] = {
26732 (char *) "self", NULL
26733 };
26734
26735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
26736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26737 if (SWIG_arg_fail(1)) SWIG_fail;
26738 {
26739 PyThreadState* __tstate = wxPyBeginAllowThreads();
26740 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
26741
26742 wxPyEndAllowThreads(__tstate);
26743 if (PyErr_Occurred()) SWIG_fail;
26744 }
26745 {
26746 wxSize * resultptr;
26747 resultptr = new wxSize((wxSize &)(result));
26748 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26749 }
26750 return resultobj;
26751 fail:
26752 return NULL;
26753 }
26754
26755
26756 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
26757 PyObject *resultobj;
26758 wxWindow *arg1 = (wxWindow *) 0 ;
26759 bool arg2 = (bool) true ;
26760 bool result;
26761 PyObject * obj0 = 0 ;
26762 PyObject * obj1 = 0 ;
26763 char *kwnames[] = {
26764 (char *) "self",(char *) "show", NULL
26765 };
26766
26767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
26768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26769 if (SWIG_arg_fail(1)) SWIG_fail;
26770 if (obj1) {
26771 {
26772 arg2 = (bool)(SWIG_As_bool(obj1));
26773 if (SWIG_arg_fail(2)) SWIG_fail;
26774 }
26775 }
26776 {
26777 PyThreadState* __tstate = wxPyBeginAllowThreads();
26778 result = (bool)(arg1)->Show(arg2);
26779
26780 wxPyEndAllowThreads(__tstate);
26781 if (PyErr_Occurred()) SWIG_fail;
26782 }
26783 {
26784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26785 }
26786 return resultobj;
26787 fail:
26788 return NULL;
26789 }
26790
26791
26792 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
26793 PyObject *resultobj;
26794 wxWindow *arg1 = (wxWindow *) 0 ;
26795 bool result;
26796 PyObject * obj0 = 0 ;
26797 char *kwnames[] = {
26798 (char *) "self", NULL
26799 };
26800
26801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
26802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26803 if (SWIG_arg_fail(1)) SWIG_fail;
26804 {
26805 PyThreadState* __tstate = wxPyBeginAllowThreads();
26806 result = (bool)(arg1)->Hide();
26807
26808 wxPyEndAllowThreads(__tstate);
26809 if (PyErr_Occurred()) SWIG_fail;
26810 }
26811 {
26812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26813 }
26814 return resultobj;
26815 fail:
26816 return NULL;
26817 }
26818
26819
26820 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
26821 PyObject *resultobj;
26822 wxWindow *arg1 = (wxWindow *) 0 ;
26823 bool arg2 = (bool) true ;
26824 bool result;
26825 PyObject * obj0 = 0 ;
26826 PyObject * obj1 = 0 ;
26827 char *kwnames[] = {
26828 (char *) "self",(char *) "enable", NULL
26829 };
26830
26831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
26832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26833 if (SWIG_arg_fail(1)) SWIG_fail;
26834 if (obj1) {
26835 {
26836 arg2 = (bool)(SWIG_As_bool(obj1));
26837 if (SWIG_arg_fail(2)) SWIG_fail;
26838 }
26839 }
26840 {
26841 PyThreadState* __tstate = wxPyBeginAllowThreads();
26842 result = (bool)(arg1)->Enable(arg2);
26843
26844 wxPyEndAllowThreads(__tstate);
26845 if (PyErr_Occurred()) SWIG_fail;
26846 }
26847 {
26848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26849 }
26850 return resultobj;
26851 fail:
26852 return NULL;
26853 }
26854
26855
26856 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
26857 PyObject *resultobj;
26858 wxWindow *arg1 = (wxWindow *) 0 ;
26859 bool result;
26860 PyObject * obj0 = 0 ;
26861 char *kwnames[] = {
26862 (char *) "self", NULL
26863 };
26864
26865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
26866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26867 if (SWIG_arg_fail(1)) SWIG_fail;
26868 {
26869 PyThreadState* __tstate = wxPyBeginAllowThreads();
26870 result = (bool)(arg1)->Disable();
26871
26872 wxPyEndAllowThreads(__tstate);
26873 if (PyErr_Occurred()) SWIG_fail;
26874 }
26875 {
26876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26877 }
26878 return resultobj;
26879 fail:
26880 return NULL;
26881 }
26882
26883
26884 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
26885 PyObject *resultobj;
26886 wxWindow *arg1 = (wxWindow *) 0 ;
26887 bool result;
26888 PyObject * obj0 = 0 ;
26889 char *kwnames[] = {
26890 (char *) "self", NULL
26891 };
26892
26893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
26894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26895 if (SWIG_arg_fail(1)) SWIG_fail;
26896 {
26897 PyThreadState* __tstate = wxPyBeginAllowThreads();
26898 result = (bool)((wxWindow const *)arg1)->IsShown();
26899
26900 wxPyEndAllowThreads(__tstate);
26901 if (PyErr_Occurred()) SWIG_fail;
26902 }
26903 {
26904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26905 }
26906 return resultobj;
26907 fail:
26908 return NULL;
26909 }
26910
26911
26912 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
26913 PyObject *resultobj;
26914 wxWindow *arg1 = (wxWindow *) 0 ;
26915 bool result;
26916 PyObject * obj0 = 0 ;
26917 char *kwnames[] = {
26918 (char *) "self", NULL
26919 };
26920
26921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
26922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26923 if (SWIG_arg_fail(1)) SWIG_fail;
26924 {
26925 PyThreadState* __tstate = wxPyBeginAllowThreads();
26926 result = (bool)((wxWindow const *)arg1)->IsEnabled();
26927
26928 wxPyEndAllowThreads(__tstate);
26929 if (PyErr_Occurred()) SWIG_fail;
26930 }
26931 {
26932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26933 }
26934 return resultobj;
26935 fail:
26936 return NULL;
26937 }
26938
26939
26940 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26941 PyObject *resultobj;
26942 wxWindow *arg1 = (wxWindow *) 0 ;
26943 long arg2 ;
26944 PyObject * obj0 = 0 ;
26945 PyObject * obj1 = 0 ;
26946 char *kwnames[] = {
26947 (char *) "self",(char *) "style", NULL
26948 };
26949
26950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
26951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26952 if (SWIG_arg_fail(1)) SWIG_fail;
26953 {
26954 arg2 = (long)(SWIG_As_long(obj1));
26955 if (SWIG_arg_fail(2)) SWIG_fail;
26956 }
26957 {
26958 PyThreadState* __tstate = wxPyBeginAllowThreads();
26959 (arg1)->SetWindowStyleFlag(arg2);
26960
26961 wxPyEndAllowThreads(__tstate);
26962 if (PyErr_Occurred()) SWIG_fail;
26963 }
26964 Py_INCREF(Py_None); resultobj = Py_None;
26965 return resultobj;
26966 fail:
26967 return NULL;
26968 }
26969
26970
26971 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
26972 PyObject *resultobj;
26973 wxWindow *arg1 = (wxWindow *) 0 ;
26974 long result;
26975 PyObject * obj0 = 0 ;
26976 char *kwnames[] = {
26977 (char *) "self", NULL
26978 };
26979
26980 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
26981 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26982 if (SWIG_arg_fail(1)) SWIG_fail;
26983 {
26984 PyThreadState* __tstate = wxPyBeginAllowThreads();
26985 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
26986
26987 wxPyEndAllowThreads(__tstate);
26988 if (PyErr_Occurred()) SWIG_fail;
26989 }
26990 {
26991 resultobj = SWIG_From_long((long)(result));
26992 }
26993 return resultobj;
26994 fail:
26995 return NULL;
26996 }
26997
26998
26999 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27000 PyObject *resultobj;
27001 wxWindow *arg1 = (wxWindow *) 0 ;
27002 int arg2 ;
27003 bool result;
27004 PyObject * obj0 = 0 ;
27005 PyObject * obj1 = 0 ;
27006 char *kwnames[] = {
27007 (char *) "self",(char *) "flag", NULL
27008 };
27009
27010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27012 if (SWIG_arg_fail(1)) SWIG_fail;
27013 {
27014 arg2 = (int)(SWIG_As_int(obj1));
27015 if (SWIG_arg_fail(2)) SWIG_fail;
27016 }
27017 {
27018 PyThreadState* __tstate = wxPyBeginAllowThreads();
27019 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27020
27021 wxPyEndAllowThreads(__tstate);
27022 if (PyErr_Occurred()) SWIG_fail;
27023 }
27024 {
27025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27026 }
27027 return resultobj;
27028 fail:
27029 return NULL;
27030 }
27031
27032
27033 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27034 PyObject *resultobj;
27035 wxWindow *arg1 = (wxWindow *) 0 ;
27036 bool result;
27037 PyObject * obj0 = 0 ;
27038 char *kwnames[] = {
27039 (char *) "self", NULL
27040 };
27041
27042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27044 if (SWIG_arg_fail(1)) SWIG_fail;
27045 {
27046 PyThreadState* __tstate = wxPyBeginAllowThreads();
27047 result = (bool)((wxWindow const *)arg1)->IsRetained();
27048
27049 wxPyEndAllowThreads(__tstate);
27050 if (PyErr_Occurred()) SWIG_fail;
27051 }
27052 {
27053 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27054 }
27055 return resultobj;
27056 fail:
27057 return NULL;
27058 }
27059
27060
27061 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27062 PyObject *resultobj;
27063 wxWindow *arg1 = (wxWindow *) 0 ;
27064 long arg2 ;
27065 PyObject * obj0 = 0 ;
27066 PyObject * obj1 = 0 ;
27067 char *kwnames[] = {
27068 (char *) "self",(char *) "exStyle", NULL
27069 };
27070
27071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27073 if (SWIG_arg_fail(1)) SWIG_fail;
27074 {
27075 arg2 = (long)(SWIG_As_long(obj1));
27076 if (SWIG_arg_fail(2)) SWIG_fail;
27077 }
27078 {
27079 PyThreadState* __tstate = wxPyBeginAllowThreads();
27080 (arg1)->SetExtraStyle(arg2);
27081
27082 wxPyEndAllowThreads(__tstate);
27083 if (PyErr_Occurred()) SWIG_fail;
27084 }
27085 Py_INCREF(Py_None); resultobj = Py_None;
27086 return resultobj;
27087 fail:
27088 return NULL;
27089 }
27090
27091
27092 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27093 PyObject *resultobj;
27094 wxWindow *arg1 = (wxWindow *) 0 ;
27095 long result;
27096 PyObject * obj0 = 0 ;
27097 char *kwnames[] = {
27098 (char *) "self", NULL
27099 };
27100
27101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27103 if (SWIG_arg_fail(1)) SWIG_fail;
27104 {
27105 PyThreadState* __tstate = wxPyBeginAllowThreads();
27106 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27107
27108 wxPyEndAllowThreads(__tstate);
27109 if (PyErr_Occurred()) SWIG_fail;
27110 }
27111 {
27112 resultobj = SWIG_From_long((long)(result));
27113 }
27114 return resultobj;
27115 fail:
27116 return NULL;
27117 }
27118
27119
27120 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27121 PyObject *resultobj;
27122 wxWindow *arg1 = (wxWindow *) 0 ;
27123 bool arg2 = (bool) true ;
27124 PyObject * obj0 = 0 ;
27125 PyObject * obj1 = 0 ;
27126 char *kwnames[] = {
27127 (char *) "self",(char *) "modal", NULL
27128 };
27129
27130 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27131 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27132 if (SWIG_arg_fail(1)) SWIG_fail;
27133 if (obj1) {
27134 {
27135 arg2 = (bool)(SWIG_As_bool(obj1));
27136 if (SWIG_arg_fail(2)) SWIG_fail;
27137 }
27138 }
27139 {
27140 PyThreadState* __tstate = wxPyBeginAllowThreads();
27141 (arg1)->MakeModal(arg2);
27142
27143 wxPyEndAllowThreads(__tstate);
27144 if (PyErr_Occurred()) SWIG_fail;
27145 }
27146 Py_INCREF(Py_None); resultobj = Py_None;
27147 return resultobj;
27148 fail:
27149 return NULL;
27150 }
27151
27152
27153 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27154 PyObject *resultobj;
27155 wxWindow *arg1 = (wxWindow *) 0 ;
27156 bool arg2 ;
27157 PyObject * obj0 = 0 ;
27158 PyObject * obj1 = 0 ;
27159 char *kwnames[] = {
27160 (char *) "self",(char *) "enableTheme", NULL
27161 };
27162
27163 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27164 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27165 if (SWIG_arg_fail(1)) SWIG_fail;
27166 {
27167 arg2 = (bool)(SWIG_As_bool(obj1));
27168 if (SWIG_arg_fail(2)) SWIG_fail;
27169 }
27170 {
27171 PyThreadState* __tstate = wxPyBeginAllowThreads();
27172 (arg1)->SetThemeEnabled(arg2);
27173
27174 wxPyEndAllowThreads(__tstate);
27175 if (PyErr_Occurred()) SWIG_fail;
27176 }
27177 Py_INCREF(Py_None); resultobj = Py_None;
27178 return resultobj;
27179 fail:
27180 return NULL;
27181 }
27182
27183
27184 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27185 PyObject *resultobj;
27186 wxWindow *arg1 = (wxWindow *) 0 ;
27187 bool result;
27188 PyObject * obj0 = 0 ;
27189 char *kwnames[] = {
27190 (char *) "self", NULL
27191 };
27192
27193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27195 if (SWIG_arg_fail(1)) SWIG_fail;
27196 {
27197 PyThreadState* __tstate = wxPyBeginAllowThreads();
27198 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27199
27200 wxPyEndAllowThreads(__tstate);
27201 if (PyErr_Occurred()) SWIG_fail;
27202 }
27203 {
27204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27205 }
27206 return resultobj;
27207 fail:
27208 return NULL;
27209 }
27210
27211
27212 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27213 PyObject *resultobj;
27214 wxWindow *arg1 = (wxWindow *) 0 ;
27215 PyObject * obj0 = 0 ;
27216 char *kwnames[] = {
27217 (char *) "self", NULL
27218 };
27219
27220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27222 if (SWIG_arg_fail(1)) SWIG_fail;
27223 {
27224 PyThreadState* __tstate = wxPyBeginAllowThreads();
27225 (arg1)->SetFocus();
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_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27238 PyObject *resultobj;
27239 wxWindow *arg1 = (wxWindow *) 0 ;
27240 PyObject * obj0 = 0 ;
27241 char *kwnames[] = {
27242 (char *) "self", NULL
27243 };
27244
27245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27247 if (SWIG_arg_fail(1)) SWIG_fail;
27248 {
27249 PyThreadState* __tstate = wxPyBeginAllowThreads();
27250 (arg1)->SetFocusFromKbd();
27251
27252 wxPyEndAllowThreads(__tstate);
27253 if (PyErr_Occurred()) SWIG_fail;
27254 }
27255 Py_INCREF(Py_None); resultobj = Py_None;
27256 return resultobj;
27257 fail:
27258 return NULL;
27259 }
27260
27261
27262 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27263 PyObject *resultobj;
27264 wxWindow *result;
27265 char *kwnames[] = {
27266 NULL
27267 };
27268
27269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27270 {
27271 if (!wxPyCheckForApp()) SWIG_fail;
27272 PyThreadState* __tstate = wxPyBeginAllowThreads();
27273 result = (wxWindow *)wxWindow::FindFocus();
27274
27275 wxPyEndAllowThreads(__tstate);
27276 if (PyErr_Occurred()) SWIG_fail;
27277 }
27278 {
27279 resultobj = wxPyMake_wxObject(result, 0);
27280 }
27281 return resultobj;
27282 fail:
27283 return NULL;
27284 }
27285
27286
27287 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27288 PyObject *resultobj;
27289 wxWindow *arg1 = (wxWindow *) 0 ;
27290 bool result;
27291 PyObject * obj0 = 0 ;
27292 char *kwnames[] = {
27293 (char *) "self", NULL
27294 };
27295
27296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27298 if (SWIG_arg_fail(1)) SWIG_fail;
27299 {
27300 PyThreadState* __tstate = wxPyBeginAllowThreads();
27301 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27302
27303 wxPyEndAllowThreads(__tstate);
27304 if (PyErr_Occurred()) SWIG_fail;
27305 }
27306 {
27307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27308 }
27309 return resultobj;
27310 fail:
27311 return NULL;
27312 }
27313
27314
27315 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27316 PyObject *resultobj;
27317 wxWindow *arg1 = (wxWindow *) 0 ;
27318 bool result;
27319 PyObject * obj0 = 0 ;
27320 char *kwnames[] = {
27321 (char *) "self", NULL
27322 };
27323
27324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27326 if (SWIG_arg_fail(1)) SWIG_fail;
27327 {
27328 PyThreadState* __tstate = wxPyBeginAllowThreads();
27329 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27330
27331 wxPyEndAllowThreads(__tstate);
27332 if (PyErr_Occurred()) SWIG_fail;
27333 }
27334 {
27335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27336 }
27337 return resultobj;
27338 fail:
27339 return NULL;
27340 }
27341
27342
27343 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27344 PyObject *resultobj;
27345 wxWindow *arg1 = (wxWindow *) 0 ;
27346 wxWindow *result;
27347 PyObject * obj0 = 0 ;
27348 char *kwnames[] = {
27349 (char *) "self", NULL
27350 };
27351
27352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27354 if (SWIG_arg_fail(1)) SWIG_fail;
27355 {
27356 PyThreadState* __tstate = wxPyBeginAllowThreads();
27357 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27358
27359 wxPyEndAllowThreads(__tstate);
27360 if (PyErr_Occurred()) SWIG_fail;
27361 }
27362 {
27363 resultobj = wxPyMake_wxObject(result, 0);
27364 }
27365 return resultobj;
27366 fail:
27367 return NULL;
27368 }
27369
27370
27371 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27372 PyObject *resultobj;
27373 wxWindow *arg1 = (wxWindow *) 0 ;
27374 wxWindow *arg2 = (wxWindow *) 0 ;
27375 wxWindow *result;
27376 PyObject * obj0 = 0 ;
27377 PyObject * obj1 = 0 ;
27378 char *kwnames[] = {
27379 (char *) "self",(char *) "child", NULL
27380 };
27381
27382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27384 if (SWIG_arg_fail(1)) SWIG_fail;
27385 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27386 if (SWIG_arg_fail(2)) SWIG_fail;
27387 {
27388 PyThreadState* __tstate = wxPyBeginAllowThreads();
27389 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27390
27391 wxPyEndAllowThreads(__tstate);
27392 if (PyErr_Occurred()) SWIG_fail;
27393 }
27394 {
27395 resultobj = wxPyMake_wxObject(result, 0);
27396 }
27397 return resultobj;
27398 fail:
27399 return NULL;
27400 }
27401
27402
27403 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27404 PyObject *resultobj;
27405 wxWindow *arg1 = (wxWindow *) 0 ;
27406 wxWindow *arg2 = (wxWindow *) 0 ;
27407 PyObject * obj0 = 0 ;
27408 PyObject * obj1 = 0 ;
27409 char *kwnames[] = {
27410 (char *) "self",(char *) "win", NULL
27411 };
27412
27413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27415 if (SWIG_arg_fail(1)) SWIG_fail;
27416 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27417 if (SWIG_arg_fail(2)) SWIG_fail;
27418 {
27419 PyThreadState* __tstate = wxPyBeginAllowThreads();
27420 (arg1)->SetTmpDefaultItem(arg2);
27421
27422 wxPyEndAllowThreads(__tstate);
27423 if (PyErr_Occurred()) SWIG_fail;
27424 }
27425 Py_INCREF(Py_None); resultobj = Py_None;
27426 return resultobj;
27427 fail:
27428 return NULL;
27429 }
27430
27431
27432 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
27433 PyObject *resultobj;
27434 wxWindow *arg1 = (wxWindow *) 0 ;
27435 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
27436 bool result;
27437 PyObject * obj0 = 0 ;
27438 PyObject * obj1 = 0 ;
27439 char *kwnames[] = {
27440 (char *) "self",(char *) "flags", NULL
27441 };
27442
27443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) 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 if (obj1) {
27447 {
27448 arg2 = (int)(SWIG_As_int(obj1));
27449 if (SWIG_arg_fail(2)) SWIG_fail;
27450 }
27451 }
27452 {
27453 PyThreadState* __tstate = wxPyBeginAllowThreads();
27454 result = (bool)(arg1)->Navigate(arg2);
27455
27456 wxPyEndAllowThreads(__tstate);
27457 if (PyErr_Occurred()) SWIG_fail;
27458 }
27459 {
27460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27461 }
27462 return resultobj;
27463 fail:
27464 return NULL;
27465 }
27466
27467
27468 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27469 PyObject *resultobj;
27470 wxWindow *arg1 = (wxWindow *) 0 ;
27471 wxWindow *arg2 = (wxWindow *) 0 ;
27472 PyObject * obj0 = 0 ;
27473 PyObject * obj1 = 0 ;
27474 char *kwnames[] = {
27475 (char *) "self",(char *) "win", NULL
27476 };
27477
27478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27480 if (SWIG_arg_fail(1)) SWIG_fail;
27481 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27482 if (SWIG_arg_fail(2)) SWIG_fail;
27483 {
27484 PyThreadState* __tstate = wxPyBeginAllowThreads();
27485 (arg1)->MoveAfterInTabOrder(arg2);
27486
27487 wxPyEndAllowThreads(__tstate);
27488 if (PyErr_Occurred()) SWIG_fail;
27489 }
27490 Py_INCREF(Py_None); resultobj = Py_None;
27491 return resultobj;
27492 fail:
27493 return NULL;
27494 }
27495
27496
27497 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
27498 PyObject *resultobj;
27499 wxWindow *arg1 = (wxWindow *) 0 ;
27500 wxWindow *arg2 = (wxWindow *) 0 ;
27501 PyObject * obj0 = 0 ;
27502 PyObject * obj1 = 0 ;
27503 char *kwnames[] = {
27504 (char *) "self",(char *) "win", NULL
27505 };
27506
27507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
27508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27509 if (SWIG_arg_fail(1)) SWIG_fail;
27510 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27511 if (SWIG_arg_fail(2)) SWIG_fail;
27512 {
27513 PyThreadState* __tstate = wxPyBeginAllowThreads();
27514 (arg1)->MoveBeforeInTabOrder(arg2);
27515
27516 wxPyEndAllowThreads(__tstate);
27517 if (PyErr_Occurred()) SWIG_fail;
27518 }
27519 Py_INCREF(Py_None); resultobj = Py_None;
27520 return resultobj;
27521 fail:
27522 return NULL;
27523 }
27524
27525
27526 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
27527 PyObject *resultobj;
27528 wxWindow *arg1 = (wxWindow *) 0 ;
27529 PyObject *result;
27530 PyObject * obj0 = 0 ;
27531 char *kwnames[] = {
27532 (char *) "self", NULL
27533 };
27534
27535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
27536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27537 if (SWIG_arg_fail(1)) SWIG_fail;
27538 {
27539 PyThreadState* __tstate = wxPyBeginAllowThreads();
27540 result = (PyObject *)wxWindow_GetChildren(arg1);
27541
27542 wxPyEndAllowThreads(__tstate);
27543 if (PyErr_Occurred()) SWIG_fail;
27544 }
27545 resultobj = result;
27546 return resultobj;
27547 fail:
27548 return NULL;
27549 }
27550
27551
27552 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
27553 PyObject *resultobj;
27554 wxWindow *arg1 = (wxWindow *) 0 ;
27555 wxWindow *result;
27556 PyObject * obj0 = 0 ;
27557 char *kwnames[] = {
27558 (char *) "self", NULL
27559 };
27560
27561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
27562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27563 if (SWIG_arg_fail(1)) SWIG_fail;
27564 {
27565 PyThreadState* __tstate = wxPyBeginAllowThreads();
27566 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
27567
27568 wxPyEndAllowThreads(__tstate);
27569 if (PyErr_Occurred()) SWIG_fail;
27570 }
27571 {
27572 resultobj = wxPyMake_wxObject(result, 0);
27573 }
27574 return resultobj;
27575 fail:
27576 return NULL;
27577 }
27578
27579
27580 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
27581 PyObject *resultobj;
27582 wxWindow *arg1 = (wxWindow *) 0 ;
27583 wxWindow *result;
27584 PyObject * obj0 = 0 ;
27585 char *kwnames[] = {
27586 (char *) "self", NULL
27587 };
27588
27589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
27590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27591 if (SWIG_arg_fail(1)) SWIG_fail;
27592 {
27593 PyThreadState* __tstate = wxPyBeginAllowThreads();
27594 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
27595
27596 wxPyEndAllowThreads(__tstate);
27597 if (PyErr_Occurred()) SWIG_fail;
27598 }
27599 {
27600 resultobj = wxPyMake_wxObject(result, 0);
27601 }
27602 return resultobj;
27603 fail:
27604 return NULL;
27605 }
27606
27607
27608 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
27609 PyObject *resultobj;
27610 wxWindow *arg1 = (wxWindow *) 0 ;
27611 bool result;
27612 PyObject * obj0 = 0 ;
27613 char *kwnames[] = {
27614 (char *) "self", NULL
27615 };
27616
27617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
27618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27619 if (SWIG_arg_fail(1)) SWIG_fail;
27620 {
27621 PyThreadState* __tstate = wxPyBeginAllowThreads();
27622 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
27623
27624 wxPyEndAllowThreads(__tstate);
27625 if (PyErr_Occurred()) SWIG_fail;
27626 }
27627 {
27628 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27629 }
27630 return resultobj;
27631 fail:
27632 return NULL;
27633 }
27634
27635
27636 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
27637 PyObject *resultobj;
27638 wxWindow *arg1 = (wxWindow *) 0 ;
27639 wxWindow *arg2 = (wxWindow *) 0 ;
27640 bool result;
27641 PyObject * obj0 = 0 ;
27642 PyObject * obj1 = 0 ;
27643 char *kwnames[] = {
27644 (char *) "self",(char *) "newParent", NULL
27645 };
27646
27647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
27648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27649 if (SWIG_arg_fail(1)) SWIG_fail;
27650 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27651 if (SWIG_arg_fail(2)) SWIG_fail;
27652 {
27653 PyThreadState* __tstate = wxPyBeginAllowThreads();
27654 result = (bool)(arg1)->Reparent(arg2);
27655
27656 wxPyEndAllowThreads(__tstate);
27657 if (PyErr_Occurred()) SWIG_fail;
27658 }
27659 {
27660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27661 }
27662 return resultobj;
27663 fail:
27664 return NULL;
27665 }
27666
27667
27668 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
27669 PyObject *resultobj;
27670 wxWindow *arg1 = (wxWindow *) 0 ;
27671 wxWindow *arg2 = (wxWindow *) 0 ;
27672 PyObject * obj0 = 0 ;
27673 PyObject * obj1 = 0 ;
27674 char *kwnames[] = {
27675 (char *) "self",(char *) "child", NULL
27676 };
27677
27678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
27679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27680 if (SWIG_arg_fail(1)) SWIG_fail;
27681 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27682 if (SWIG_arg_fail(2)) SWIG_fail;
27683 {
27684 PyThreadState* __tstate = wxPyBeginAllowThreads();
27685 (arg1)->AddChild(arg2);
27686
27687 wxPyEndAllowThreads(__tstate);
27688 if (PyErr_Occurred()) SWIG_fail;
27689 }
27690 Py_INCREF(Py_None); resultobj = Py_None;
27691 return resultobj;
27692 fail:
27693 return NULL;
27694 }
27695
27696
27697 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
27698 PyObject *resultobj;
27699 wxWindow *arg1 = (wxWindow *) 0 ;
27700 wxWindow *arg2 = (wxWindow *) 0 ;
27701 PyObject * obj0 = 0 ;
27702 PyObject * obj1 = 0 ;
27703 char *kwnames[] = {
27704 (char *) "self",(char *) "child", NULL
27705 };
27706
27707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
27708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27709 if (SWIG_arg_fail(1)) SWIG_fail;
27710 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27711 if (SWIG_arg_fail(2)) SWIG_fail;
27712 {
27713 PyThreadState* __tstate = wxPyBeginAllowThreads();
27714 (arg1)->RemoveChild(arg2);
27715
27716 wxPyEndAllowThreads(__tstate);
27717 if (PyErr_Occurred()) SWIG_fail;
27718 }
27719 Py_INCREF(Py_None); resultobj = Py_None;
27720 return resultobj;
27721 fail:
27722 return NULL;
27723 }
27724
27725
27726 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
27727 PyObject *resultobj;
27728 wxWindow *arg1 = (wxWindow *) 0 ;
27729 long arg2 ;
27730 wxWindow *result;
27731 PyObject * obj0 = 0 ;
27732 PyObject * obj1 = 0 ;
27733 char *kwnames[] = {
27734 (char *) "self",(char *) "winid", NULL
27735 };
27736
27737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
27738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27739 if (SWIG_arg_fail(1)) SWIG_fail;
27740 {
27741 arg2 = (long)(SWIG_As_long(obj1));
27742 if (SWIG_arg_fail(2)) SWIG_fail;
27743 }
27744 {
27745 PyThreadState* __tstate = wxPyBeginAllowThreads();
27746 result = (wxWindow *)(arg1)->FindWindow(arg2);
27747
27748 wxPyEndAllowThreads(__tstate);
27749 if (PyErr_Occurred()) SWIG_fail;
27750 }
27751 {
27752 resultobj = wxPyMake_wxObject(result, 0);
27753 }
27754 return resultobj;
27755 fail:
27756 return NULL;
27757 }
27758
27759
27760 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
27761 PyObject *resultobj;
27762 wxWindow *arg1 = (wxWindow *) 0 ;
27763 wxString *arg2 = 0 ;
27764 wxWindow *result;
27765 bool temp2 = false ;
27766 PyObject * obj0 = 0 ;
27767 PyObject * obj1 = 0 ;
27768 char *kwnames[] = {
27769 (char *) "self",(char *) "name", NULL
27770 };
27771
27772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
27773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27774 if (SWIG_arg_fail(1)) SWIG_fail;
27775 {
27776 arg2 = wxString_in_helper(obj1);
27777 if (arg2 == NULL) SWIG_fail;
27778 temp2 = true;
27779 }
27780 {
27781 PyThreadState* __tstate = wxPyBeginAllowThreads();
27782 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
27783
27784 wxPyEndAllowThreads(__tstate);
27785 if (PyErr_Occurred()) SWIG_fail;
27786 }
27787 {
27788 resultobj = wxPyMake_wxObject(result, 0);
27789 }
27790 {
27791 if (temp2)
27792 delete arg2;
27793 }
27794 return resultobj;
27795 fail:
27796 {
27797 if (temp2)
27798 delete arg2;
27799 }
27800 return NULL;
27801 }
27802
27803
27804 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27805 PyObject *resultobj;
27806 wxWindow *arg1 = (wxWindow *) 0 ;
27807 wxEvtHandler *result;
27808 PyObject * obj0 = 0 ;
27809 char *kwnames[] = {
27810 (char *) "self", NULL
27811 };
27812
27813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
27814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27815 if (SWIG_arg_fail(1)) SWIG_fail;
27816 {
27817 PyThreadState* __tstate = wxPyBeginAllowThreads();
27818 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
27819
27820 wxPyEndAllowThreads(__tstate);
27821 if (PyErr_Occurred()) SWIG_fail;
27822 }
27823 {
27824 resultobj = wxPyMake_wxObject(result, 0);
27825 }
27826 return resultobj;
27827 fail:
27828 return NULL;
27829 }
27830
27831
27832 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27833 PyObject *resultobj;
27834 wxWindow *arg1 = (wxWindow *) 0 ;
27835 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27836 PyObject * obj0 = 0 ;
27837 PyObject * obj1 = 0 ;
27838 char *kwnames[] = {
27839 (char *) "self",(char *) "handler", NULL
27840 };
27841
27842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
27843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27844 if (SWIG_arg_fail(1)) SWIG_fail;
27845 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27846 if (SWIG_arg_fail(2)) SWIG_fail;
27847 {
27848 PyThreadState* __tstate = wxPyBeginAllowThreads();
27849 (arg1)->SetEventHandler(arg2);
27850
27851 wxPyEndAllowThreads(__tstate);
27852 if (PyErr_Occurred()) SWIG_fail;
27853 }
27854 Py_INCREF(Py_None); resultobj = Py_None;
27855 return resultobj;
27856 fail:
27857 return NULL;
27858 }
27859
27860
27861 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27862 PyObject *resultobj;
27863 wxWindow *arg1 = (wxWindow *) 0 ;
27864 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27865 PyObject * obj0 = 0 ;
27866 PyObject * obj1 = 0 ;
27867 char *kwnames[] = {
27868 (char *) "self",(char *) "handler", NULL
27869 };
27870
27871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
27872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27873 if (SWIG_arg_fail(1)) SWIG_fail;
27874 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27875 if (SWIG_arg_fail(2)) SWIG_fail;
27876 {
27877 PyThreadState* __tstate = wxPyBeginAllowThreads();
27878 (arg1)->PushEventHandler(arg2);
27879
27880 wxPyEndAllowThreads(__tstate);
27881 if (PyErr_Occurred()) SWIG_fail;
27882 }
27883 Py_INCREF(Py_None); resultobj = Py_None;
27884 return resultobj;
27885 fail:
27886 return NULL;
27887 }
27888
27889
27890 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27891 PyObject *resultobj;
27892 wxWindow *arg1 = (wxWindow *) 0 ;
27893 bool arg2 = (bool) false ;
27894 wxEvtHandler *result;
27895 PyObject * obj0 = 0 ;
27896 PyObject * obj1 = 0 ;
27897 char *kwnames[] = {
27898 (char *) "self",(char *) "deleteHandler", NULL
27899 };
27900
27901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
27902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27903 if (SWIG_arg_fail(1)) SWIG_fail;
27904 if (obj1) {
27905 {
27906 arg2 = (bool)(SWIG_As_bool(obj1));
27907 if (SWIG_arg_fail(2)) SWIG_fail;
27908 }
27909 }
27910 {
27911 PyThreadState* __tstate = wxPyBeginAllowThreads();
27912 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
27913
27914 wxPyEndAllowThreads(__tstate);
27915 if (PyErr_Occurred()) SWIG_fail;
27916 }
27917 {
27918 resultobj = wxPyMake_wxObject(result, 0);
27919 }
27920 return resultobj;
27921 fail:
27922 return NULL;
27923 }
27924
27925
27926 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
27927 PyObject *resultobj;
27928 wxWindow *arg1 = (wxWindow *) 0 ;
27929 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
27930 bool result;
27931 PyObject * obj0 = 0 ;
27932 PyObject * obj1 = 0 ;
27933 char *kwnames[] = {
27934 (char *) "self",(char *) "handler", NULL
27935 };
27936
27937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
27938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27939 if (SWIG_arg_fail(1)) SWIG_fail;
27940 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
27941 if (SWIG_arg_fail(2)) SWIG_fail;
27942 {
27943 PyThreadState* __tstate = wxPyBeginAllowThreads();
27944 result = (bool)(arg1)->RemoveEventHandler(arg2);
27945
27946 wxPyEndAllowThreads(__tstate);
27947 if (PyErr_Occurred()) SWIG_fail;
27948 }
27949 {
27950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27951 }
27952 return resultobj;
27953 fail:
27954 return NULL;
27955 }
27956
27957
27958 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
27959 PyObject *resultobj;
27960 wxWindow *arg1 = (wxWindow *) 0 ;
27961 wxValidator *arg2 = 0 ;
27962 PyObject * obj0 = 0 ;
27963 PyObject * obj1 = 0 ;
27964 char *kwnames[] = {
27965 (char *) "self",(char *) "validator", NULL
27966 };
27967
27968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
27969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27970 if (SWIG_arg_fail(1)) SWIG_fail;
27971 {
27972 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
27973 if (SWIG_arg_fail(2)) SWIG_fail;
27974 if (arg2 == NULL) {
27975 SWIG_null_ref("wxValidator");
27976 }
27977 if (SWIG_arg_fail(2)) SWIG_fail;
27978 }
27979 {
27980 PyThreadState* __tstate = wxPyBeginAllowThreads();
27981 (arg1)->SetValidator((wxValidator const &)*arg2);
27982
27983 wxPyEndAllowThreads(__tstate);
27984 if (PyErr_Occurred()) SWIG_fail;
27985 }
27986 Py_INCREF(Py_None); resultobj = Py_None;
27987 return resultobj;
27988 fail:
27989 return NULL;
27990 }
27991
27992
27993 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
27994 PyObject *resultobj;
27995 wxWindow *arg1 = (wxWindow *) 0 ;
27996 wxValidator *result;
27997 PyObject * obj0 = 0 ;
27998 char *kwnames[] = {
27999 (char *) "self", NULL
28000 };
28001
28002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28004 if (SWIG_arg_fail(1)) SWIG_fail;
28005 {
28006 PyThreadState* __tstate = wxPyBeginAllowThreads();
28007 result = (wxValidator *)(arg1)->GetValidator();
28008
28009 wxPyEndAllowThreads(__tstate);
28010 if (PyErr_Occurred()) SWIG_fail;
28011 }
28012 {
28013 resultobj = wxPyMake_wxObject(result, 0);
28014 }
28015 return resultobj;
28016 fail:
28017 return NULL;
28018 }
28019
28020
28021 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28022 PyObject *resultobj;
28023 wxWindow *arg1 = (wxWindow *) 0 ;
28024 bool result;
28025 PyObject * obj0 = 0 ;
28026 char *kwnames[] = {
28027 (char *) "self", NULL
28028 };
28029
28030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28032 if (SWIG_arg_fail(1)) SWIG_fail;
28033 {
28034 PyThreadState* __tstate = wxPyBeginAllowThreads();
28035 result = (bool)(arg1)->Validate();
28036
28037 wxPyEndAllowThreads(__tstate);
28038 if (PyErr_Occurred()) SWIG_fail;
28039 }
28040 {
28041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28042 }
28043 return resultobj;
28044 fail:
28045 return NULL;
28046 }
28047
28048
28049 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28050 PyObject *resultobj;
28051 wxWindow *arg1 = (wxWindow *) 0 ;
28052 bool result;
28053 PyObject * obj0 = 0 ;
28054 char *kwnames[] = {
28055 (char *) "self", NULL
28056 };
28057
28058 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28059 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28060 if (SWIG_arg_fail(1)) SWIG_fail;
28061 {
28062 PyThreadState* __tstate = wxPyBeginAllowThreads();
28063 result = (bool)(arg1)->TransferDataToWindow();
28064
28065 wxPyEndAllowThreads(__tstate);
28066 if (PyErr_Occurred()) SWIG_fail;
28067 }
28068 {
28069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28070 }
28071 return resultobj;
28072 fail:
28073 return NULL;
28074 }
28075
28076
28077 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28078 PyObject *resultobj;
28079 wxWindow *arg1 = (wxWindow *) 0 ;
28080 bool result;
28081 PyObject * obj0 = 0 ;
28082 char *kwnames[] = {
28083 (char *) "self", NULL
28084 };
28085
28086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28087 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28088 if (SWIG_arg_fail(1)) SWIG_fail;
28089 {
28090 PyThreadState* __tstate = wxPyBeginAllowThreads();
28091 result = (bool)(arg1)->TransferDataFromWindow();
28092
28093 wxPyEndAllowThreads(__tstate);
28094 if (PyErr_Occurred()) SWIG_fail;
28095 }
28096 {
28097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28098 }
28099 return resultobj;
28100 fail:
28101 return NULL;
28102 }
28103
28104
28105 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28106 PyObject *resultobj;
28107 wxWindow *arg1 = (wxWindow *) 0 ;
28108 PyObject * obj0 = 0 ;
28109 char *kwnames[] = {
28110 (char *) "self", NULL
28111 };
28112
28113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",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 (arg1)->InitDialog();
28119
28120 wxPyEndAllowThreads(__tstate);
28121 if (PyErr_Occurred()) SWIG_fail;
28122 }
28123 Py_INCREF(Py_None); resultobj = Py_None;
28124 return resultobj;
28125 fail:
28126 return NULL;
28127 }
28128
28129
28130 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28131 PyObject *resultobj;
28132 wxWindow *arg1 = (wxWindow *) 0 ;
28133 wxAcceleratorTable *arg2 = 0 ;
28134 PyObject * obj0 = 0 ;
28135 PyObject * obj1 = 0 ;
28136 char *kwnames[] = {
28137 (char *) "self",(char *) "accel", NULL
28138 };
28139
28140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28142 if (SWIG_arg_fail(1)) SWIG_fail;
28143 {
28144 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28145 if (SWIG_arg_fail(2)) SWIG_fail;
28146 if (arg2 == NULL) {
28147 SWIG_null_ref("wxAcceleratorTable");
28148 }
28149 if (SWIG_arg_fail(2)) SWIG_fail;
28150 }
28151 {
28152 PyThreadState* __tstate = wxPyBeginAllowThreads();
28153 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28154
28155 wxPyEndAllowThreads(__tstate);
28156 if (PyErr_Occurred()) SWIG_fail;
28157 }
28158 Py_INCREF(Py_None); resultobj = Py_None;
28159 return resultobj;
28160 fail:
28161 return NULL;
28162 }
28163
28164
28165 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28166 PyObject *resultobj;
28167 wxWindow *arg1 = (wxWindow *) 0 ;
28168 wxAcceleratorTable *result;
28169 PyObject * obj0 = 0 ;
28170 char *kwnames[] = {
28171 (char *) "self", NULL
28172 };
28173
28174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28176 if (SWIG_arg_fail(1)) SWIG_fail;
28177 {
28178 PyThreadState* __tstate = wxPyBeginAllowThreads();
28179 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28180
28181 wxPyEndAllowThreads(__tstate);
28182 if (PyErr_Occurred()) SWIG_fail;
28183 }
28184 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28185 return resultobj;
28186 fail:
28187 return NULL;
28188 }
28189
28190
28191 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28192 PyObject *resultobj;
28193 wxWindow *arg1 = (wxWindow *) 0 ;
28194 int arg2 ;
28195 int arg3 ;
28196 int arg4 ;
28197 bool result;
28198 PyObject * obj0 = 0 ;
28199 PyObject * obj1 = 0 ;
28200 PyObject * obj2 = 0 ;
28201 PyObject * obj3 = 0 ;
28202 char *kwnames[] = {
28203 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28204 };
28205
28206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28208 if (SWIG_arg_fail(1)) SWIG_fail;
28209 {
28210 arg2 = (int)(SWIG_As_int(obj1));
28211 if (SWIG_arg_fail(2)) SWIG_fail;
28212 }
28213 {
28214 arg3 = (int)(SWIG_As_int(obj2));
28215 if (SWIG_arg_fail(3)) SWIG_fail;
28216 }
28217 {
28218 arg4 = (int)(SWIG_As_int(obj3));
28219 if (SWIG_arg_fail(4)) SWIG_fail;
28220 }
28221 {
28222 PyThreadState* __tstate = wxPyBeginAllowThreads();
28223 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28224
28225 wxPyEndAllowThreads(__tstate);
28226 if (PyErr_Occurred()) SWIG_fail;
28227 }
28228 {
28229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28230 }
28231 return resultobj;
28232 fail:
28233 return NULL;
28234 }
28235
28236
28237 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28238 PyObject *resultobj;
28239 wxWindow *arg1 = (wxWindow *) 0 ;
28240 int arg2 ;
28241 bool result;
28242 PyObject * obj0 = 0 ;
28243 PyObject * obj1 = 0 ;
28244 char *kwnames[] = {
28245 (char *) "self",(char *) "hotkeyId", NULL
28246 };
28247
28248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28250 if (SWIG_arg_fail(1)) SWIG_fail;
28251 {
28252 arg2 = (int)(SWIG_As_int(obj1));
28253 if (SWIG_arg_fail(2)) SWIG_fail;
28254 }
28255 {
28256 PyThreadState* __tstate = wxPyBeginAllowThreads();
28257 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28258
28259 wxPyEndAllowThreads(__tstate);
28260 if (PyErr_Occurred()) SWIG_fail;
28261 }
28262 {
28263 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28264 }
28265 return resultobj;
28266 fail:
28267 return NULL;
28268 }
28269
28270
28271 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28272 PyObject *resultobj;
28273 wxWindow *arg1 = (wxWindow *) 0 ;
28274 wxPoint *arg2 = 0 ;
28275 wxPoint result;
28276 wxPoint temp2 ;
28277 PyObject * obj0 = 0 ;
28278 PyObject * obj1 = 0 ;
28279 char *kwnames[] = {
28280 (char *) "self",(char *) "pt", NULL
28281 };
28282
28283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28285 if (SWIG_arg_fail(1)) SWIG_fail;
28286 {
28287 arg2 = &temp2;
28288 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28289 }
28290 {
28291 PyThreadState* __tstate = wxPyBeginAllowThreads();
28292 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28293
28294 wxPyEndAllowThreads(__tstate);
28295 if (PyErr_Occurred()) SWIG_fail;
28296 }
28297 {
28298 wxPoint * resultptr;
28299 resultptr = new wxPoint((wxPoint &)(result));
28300 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28301 }
28302 return resultobj;
28303 fail:
28304 return NULL;
28305 }
28306
28307
28308 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28309 PyObject *resultobj;
28310 wxWindow *arg1 = (wxWindow *) 0 ;
28311 wxSize *arg2 = 0 ;
28312 wxSize result;
28313 wxSize temp2 ;
28314 PyObject * obj0 = 0 ;
28315 PyObject * obj1 = 0 ;
28316 char *kwnames[] = {
28317 (char *) "self",(char *) "sz", NULL
28318 };
28319
28320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28322 if (SWIG_arg_fail(1)) SWIG_fail;
28323 {
28324 arg2 = &temp2;
28325 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28326 }
28327 {
28328 PyThreadState* __tstate = wxPyBeginAllowThreads();
28329 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28330
28331 wxPyEndAllowThreads(__tstate);
28332 if (PyErr_Occurred()) SWIG_fail;
28333 }
28334 {
28335 wxSize * resultptr;
28336 resultptr = new wxSize((wxSize &)(result));
28337 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28338 }
28339 return resultobj;
28340 fail:
28341 return NULL;
28342 }
28343
28344
28345 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28346 PyObject *resultobj;
28347 wxWindow *arg1 = (wxWindow *) 0 ;
28348 wxPoint *arg2 = 0 ;
28349 wxPoint result;
28350 wxPoint temp2 ;
28351 PyObject * obj0 = 0 ;
28352 PyObject * obj1 = 0 ;
28353 char *kwnames[] = {
28354 (char *) "self",(char *) "pt", NULL
28355 };
28356
28357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28359 if (SWIG_arg_fail(1)) SWIG_fail;
28360 {
28361 arg2 = &temp2;
28362 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28363 }
28364 {
28365 PyThreadState* __tstate = wxPyBeginAllowThreads();
28366 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28367
28368 wxPyEndAllowThreads(__tstate);
28369 if (PyErr_Occurred()) SWIG_fail;
28370 }
28371 {
28372 wxPoint * resultptr;
28373 resultptr = new wxPoint((wxPoint &)(result));
28374 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28375 }
28376 return resultobj;
28377 fail:
28378 return NULL;
28379 }
28380
28381
28382 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28383 PyObject *resultobj;
28384 wxWindow *arg1 = (wxWindow *) 0 ;
28385 wxSize *arg2 = 0 ;
28386 wxSize result;
28387 wxSize temp2 ;
28388 PyObject * obj0 = 0 ;
28389 PyObject * obj1 = 0 ;
28390 char *kwnames[] = {
28391 (char *) "self",(char *) "sz", NULL
28392 };
28393
28394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28396 if (SWIG_arg_fail(1)) SWIG_fail;
28397 {
28398 arg2 = &temp2;
28399 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28400 }
28401 {
28402 PyThreadState* __tstate = wxPyBeginAllowThreads();
28403 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28404
28405 wxPyEndAllowThreads(__tstate);
28406 if (PyErr_Occurred()) SWIG_fail;
28407 }
28408 {
28409 wxSize * resultptr;
28410 resultptr = new wxSize((wxSize &)(result));
28411 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28412 }
28413 return resultobj;
28414 fail:
28415 return NULL;
28416 }
28417
28418
28419 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28420 PyObject *resultobj;
28421 wxWindow *arg1 = (wxWindow *) 0 ;
28422 wxPoint *arg2 = 0 ;
28423 wxPoint result;
28424 wxPoint temp2 ;
28425 PyObject * obj0 = 0 ;
28426 PyObject * obj1 = 0 ;
28427 char *kwnames[] = {
28428 (char *) "self",(char *) "pt", NULL
28429 };
28430
28431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
28432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28433 if (SWIG_arg_fail(1)) SWIG_fail;
28434 {
28435 arg2 = &temp2;
28436 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28437 }
28438 {
28439 PyThreadState* __tstate = wxPyBeginAllowThreads();
28440 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
28441
28442 wxPyEndAllowThreads(__tstate);
28443 if (PyErr_Occurred()) SWIG_fail;
28444 }
28445 {
28446 wxPoint * resultptr;
28447 resultptr = new wxPoint((wxPoint &)(result));
28448 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28449 }
28450 return resultobj;
28451 fail:
28452 return NULL;
28453 }
28454
28455
28456 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28457 PyObject *resultobj;
28458 wxWindow *arg1 = (wxWindow *) 0 ;
28459 wxSize *arg2 = 0 ;
28460 wxSize result;
28461 wxSize temp2 ;
28462 PyObject * obj0 = 0 ;
28463 PyObject * obj1 = 0 ;
28464 char *kwnames[] = {
28465 (char *) "self",(char *) "sz", NULL
28466 };
28467
28468 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
28469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28470 if (SWIG_arg_fail(1)) SWIG_fail;
28471 {
28472 arg2 = &temp2;
28473 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28474 }
28475 {
28476 PyThreadState* __tstate = wxPyBeginAllowThreads();
28477 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
28478
28479 wxPyEndAllowThreads(__tstate);
28480 if (PyErr_Occurred()) SWIG_fail;
28481 }
28482 {
28483 wxSize * resultptr;
28484 resultptr = new wxSize((wxSize &)(result));
28485 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28486 }
28487 return resultobj;
28488 fail:
28489 return NULL;
28490 }
28491
28492
28493 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
28494 PyObject *resultobj;
28495 wxWindow *arg1 = (wxWindow *) 0 ;
28496 int arg2 ;
28497 int arg3 ;
28498 PyObject * obj0 = 0 ;
28499 PyObject * obj1 = 0 ;
28500 PyObject * obj2 = 0 ;
28501 char *kwnames[] = {
28502 (char *) "self",(char *) "x",(char *) "y", NULL
28503 };
28504
28505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
28506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28507 if (SWIG_arg_fail(1)) SWIG_fail;
28508 {
28509 arg2 = (int)(SWIG_As_int(obj1));
28510 if (SWIG_arg_fail(2)) SWIG_fail;
28511 }
28512 {
28513 arg3 = (int)(SWIG_As_int(obj2));
28514 if (SWIG_arg_fail(3)) SWIG_fail;
28515 }
28516 {
28517 PyThreadState* __tstate = wxPyBeginAllowThreads();
28518 (arg1)->WarpPointer(arg2,arg3);
28519
28520 wxPyEndAllowThreads(__tstate);
28521 if (PyErr_Occurred()) SWIG_fail;
28522 }
28523 Py_INCREF(Py_None); resultobj = Py_None;
28524 return resultobj;
28525 fail:
28526 return NULL;
28527 }
28528
28529
28530 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28531 PyObject *resultobj;
28532 wxWindow *arg1 = (wxWindow *) 0 ;
28533 PyObject * obj0 = 0 ;
28534 char *kwnames[] = {
28535 (char *) "self", NULL
28536 };
28537
28538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
28539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28540 if (SWIG_arg_fail(1)) SWIG_fail;
28541 {
28542 PyThreadState* __tstate = wxPyBeginAllowThreads();
28543 (arg1)->CaptureMouse();
28544
28545 wxPyEndAllowThreads(__tstate);
28546 if (PyErr_Occurred()) SWIG_fail;
28547 }
28548 Py_INCREF(Py_None); resultobj = Py_None;
28549 return resultobj;
28550 fail:
28551 return NULL;
28552 }
28553
28554
28555 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
28556 PyObject *resultobj;
28557 wxWindow *arg1 = (wxWindow *) 0 ;
28558 PyObject * obj0 = 0 ;
28559 char *kwnames[] = {
28560 (char *) "self", NULL
28561 };
28562
28563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
28564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28565 if (SWIG_arg_fail(1)) SWIG_fail;
28566 {
28567 PyThreadState* __tstate = wxPyBeginAllowThreads();
28568 (arg1)->ReleaseMouse();
28569
28570 wxPyEndAllowThreads(__tstate);
28571 if (PyErr_Occurred()) SWIG_fail;
28572 }
28573 Py_INCREF(Py_None); resultobj = Py_None;
28574 return resultobj;
28575 fail:
28576 return NULL;
28577 }
28578
28579
28580 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28581 PyObject *resultobj;
28582 wxWindow *result;
28583 char *kwnames[] = {
28584 NULL
28585 };
28586
28587 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
28588 {
28589 if (!wxPyCheckForApp()) SWIG_fail;
28590 PyThreadState* __tstate = wxPyBeginAllowThreads();
28591 result = (wxWindow *)wxWindow::GetCapture();
28592
28593 wxPyEndAllowThreads(__tstate);
28594 if (PyErr_Occurred()) SWIG_fail;
28595 }
28596 {
28597 resultobj = wxPyMake_wxObject(result, 0);
28598 }
28599 return resultobj;
28600 fail:
28601 return NULL;
28602 }
28603
28604
28605 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
28606 PyObject *resultobj;
28607 wxWindow *arg1 = (wxWindow *) 0 ;
28608 bool result;
28609 PyObject * obj0 = 0 ;
28610 char *kwnames[] = {
28611 (char *) "self", NULL
28612 };
28613
28614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
28615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28616 if (SWIG_arg_fail(1)) SWIG_fail;
28617 {
28618 PyThreadState* __tstate = wxPyBeginAllowThreads();
28619 result = (bool)((wxWindow const *)arg1)->HasCapture();
28620
28621 wxPyEndAllowThreads(__tstate);
28622 if (PyErr_Occurred()) SWIG_fail;
28623 }
28624 {
28625 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28626 }
28627 return resultobj;
28628 fail:
28629 return NULL;
28630 }
28631
28632
28633 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
28634 PyObject *resultobj;
28635 wxWindow *arg1 = (wxWindow *) 0 ;
28636 bool arg2 = (bool) true ;
28637 wxRect *arg3 = (wxRect *) NULL ;
28638 PyObject * obj0 = 0 ;
28639 PyObject * obj1 = 0 ;
28640 PyObject * obj2 = 0 ;
28641 char *kwnames[] = {
28642 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
28643 };
28644
28645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
28646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28647 if (SWIG_arg_fail(1)) SWIG_fail;
28648 if (obj1) {
28649 {
28650 arg2 = (bool)(SWIG_As_bool(obj1));
28651 if (SWIG_arg_fail(2)) SWIG_fail;
28652 }
28653 }
28654 if (obj2) {
28655 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
28656 if (SWIG_arg_fail(3)) SWIG_fail;
28657 }
28658 {
28659 PyThreadState* __tstate = wxPyBeginAllowThreads();
28660 (arg1)->Refresh(arg2,(wxRect const *)arg3);
28661
28662 wxPyEndAllowThreads(__tstate);
28663 if (PyErr_Occurred()) SWIG_fail;
28664 }
28665 Py_INCREF(Py_None); resultobj = Py_None;
28666 return resultobj;
28667 fail:
28668 return NULL;
28669 }
28670
28671
28672 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
28673 PyObject *resultobj;
28674 wxWindow *arg1 = (wxWindow *) 0 ;
28675 wxRect *arg2 = 0 ;
28676 bool arg3 = (bool) true ;
28677 wxRect temp2 ;
28678 PyObject * obj0 = 0 ;
28679 PyObject * obj1 = 0 ;
28680 PyObject * obj2 = 0 ;
28681 char *kwnames[] = {
28682 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
28683 };
28684
28685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
28686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28687 if (SWIG_arg_fail(1)) SWIG_fail;
28688 {
28689 arg2 = &temp2;
28690 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
28691 }
28692 if (obj2) {
28693 {
28694 arg3 = (bool)(SWIG_As_bool(obj2));
28695 if (SWIG_arg_fail(3)) SWIG_fail;
28696 }
28697 }
28698 {
28699 PyThreadState* __tstate = wxPyBeginAllowThreads();
28700 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
28701
28702 wxPyEndAllowThreads(__tstate);
28703 if (PyErr_Occurred()) SWIG_fail;
28704 }
28705 Py_INCREF(Py_None); resultobj = Py_None;
28706 return resultobj;
28707 fail:
28708 return NULL;
28709 }
28710
28711
28712 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
28713 PyObject *resultobj;
28714 wxWindow *arg1 = (wxWindow *) 0 ;
28715 PyObject * obj0 = 0 ;
28716 char *kwnames[] = {
28717 (char *) "self", NULL
28718 };
28719
28720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
28721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28722 if (SWIG_arg_fail(1)) SWIG_fail;
28723 {
28724 PyThreadState* __tstate = wxPyBeginAllowThreads();
28725 (arg1)->Update();
28726
28727 wxPyEndAllowThreads(__tstate);
28728 if (PyErr_Occurred()) SWIG_fail;
28729 }
28730 Py_INCREF(Py_None); resultobj = Py_None;
28731 return resultobj;
28732 fail:
28733 return NULL;
28734 }
28735
28736
28737 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
28738 PyObject *resultobj;
28739 wxWindow *arg1 = (wxWindow *) 0 ;
28740 PyObject * obj0 = 0 ;
28741 char *kwnames[] = {
28742 (char *) "self", NULL
28743 };
28744
28745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
28746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28747 if (SWIG_arg_fail(1)) SWIG_fail;
28748 {
28749 PyThreadState* __tstate = wxPyBeginAllowThreads();
28750 (arg1)->ClearBackground();
28751
28752 wxPyEndAllowThreads(__tstate);
28753 if (PyErr_Occurred()) SWIG_fail;
28754 }
28755 Py_INCREF(Py_None); resultobj = Py_None;
28756 return resultobj;
28757 fail:
28758 return NULL;
28759 }
28760
28761
28762 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
28763 PyObject *resultobj;
28764 wxWindow *arg1 = (wxWindow *) 0 ;
28765 PyObject * obj0 = 0 ;
28766 char *kwnames[] = {
28767 (char *) "self", NULL
28768 };
28769
28770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
28771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28772 if (SWIG_arg_fail(1)) SWIG_fail;
28773 {
28774 PyThreadState* __tstate = wxPyBeginAllowThreads();
28775 (arg1)->Freeze();
28776
28777 wxPyEndAllowThreads(__tstate);
28778 if (PyErr_Occurred()) SWIG_fail;
28779 }
28780 Py_INCREF(Py_None); resultobj = Py_None;
28781 return resultobj;
28782 fail:
28783 return NULL;
28784 }
28785
28786
28787 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
28788 PyObject *resultobj;
28789 wxWindow *arg1 = (wxWindow *) 0 ;
28790 PyObject * obj0 = 0 ;
28791 char *kwnames[] = {
28792 (char *) "self", NULL
28793 };
28794
28795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
28796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28797 if (SWIG_arg_fail(1)) SWIG_fail;
28798 {
28799 PyThreadState* __tstate = wxPyBeginAllowThreads();
28800 (arg1)->Thaw();
28801
28802 wxPyEndAllowThreads(__tstate);
28803 if (PyErr_Occurred()) SWIG_fail;
28804 }
28805 Py_INCREF(Py_None); resultobj = Py_None;
28806 return resultobj;
28807 fail:
28808 return NULL;
28809 }
28810
28811
28812 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
28813 PyObject *resultobj;
28814 wxWindow *arg1 = (wxWindow *) 0 ;
28815 wxDC *arg2 = 0 ;
28816 PyObject * obj0 = 0 ;
28817 PyObject * obj1 = 0 ;
28818 char *kwnames[] = {
28819 (char *) "self",(char *) "dc", NULL
28820 };
28821
28822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
28823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28824 if (SWIG_arg_fail(1)) SWIG_fail;
28825 {
28826 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
28827 if (SWIG_arg_fail(2)) SWIG_fail;
28828 if (arg2 == NULL) {
28829 SWIG_null_ref("wxDC");
28830 }
28831 if (SWIG_arg_fail(2)) SWIG_fail;
28832 }
28833 {
28834 PyThreadState* __tstate = wxPyBeginAllowThreads();
28835 (arg1)->PrepareDC(*arg2);
28836
28837 wxPyEndAllowThreads(__tstate);
28838 if (PyErr_Occurred()) SWIG_fail;
28839 }
28840 Py_INCREF(Py_None); resultobj = Py_None;
28841 return resultobj;
28842 fail:
28843 return NULL;
28844 }
28845
28846
28847 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
28848 PyObject *resultobj;
28849 wxWindow *arg1 = (wxWindow *) 0 ;
28850 wxRegion *result;
28851 PyObject * obj0 = 0 ;
28852 char *kwnames[] = {
28853 (char *) "self", NULL
28854 };
28855
28856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
28857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28858 if (SWIG_arg_fail(1)) SWIG_fail;
28859 {
28860 PyThreadState* __tstate = wxPyBeginAllowThreads();
28861 {
28862 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
28863 result = (wxRegion *) &_result_ref;
28864 }
28865
28866 wxPyEndAllowThreads(__tstate);
28867 if (PyErr_Occurred()) SWIG_fail;
28868 }
28869 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
28870 return resultobj;
28871 fail:
28872 return NULL;
28873 }
28874
28875
28876 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
28877 PyObject *resultobj;
28878 wxWindow *arg1 = (wxWindow *) 0 ;
28879 wxRect result;
28880 PyObject * obj0 = 0 ;
28881 char *kwnames[] = {
28882 (char *) "self", NULL
28883 };
28884
28885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
28886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28887 if (SWIG_arg_fail(1)) SWIG_fail;
28888 {
28889 PyThreadState* __tstate = wxPyBeginAllowThreads();
28890 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
28891
28892 wxPyEndAllowThreads(__tstate);
28893 if (PyErr_Occurred()) SWIG_fail;
28894 }
28895 {
28896 wxRect * resultptr;
28897 resultptr = new wxRect((wxRect &)(result));
28898 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
28899 }
28900 return resultobj;
28901 fail:
28902 return NULL;
28903 }
28904
28905
28906 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
28907 PyObject *resultobj;
28908 wxWindow *arg1 = (wxWindow *) 0 ;
28909 int arg2 ;
28910 int arg3 ;
28911 int arg4 = (int) 1 ;
28912 int arg5 = (int) 1 ;
28913 bool result;
28914 PyObject * obj0 = 0 ;
28915 PyObject * obj1 = 0 ;
28916 PyObject * obj2 = 0 ;
28917 PyObject * obj3 = 0 ;
28918 PyObject * obj4 = 0 ;
28919 char *kwnames[] = {
28920 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
28921 };
28922
28923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
28924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28925 if (SWIG_arg_fail(1)) SWIG_fail;
28926 {
28927 arg2 = (int)(SWIG_As_int(obj1));
28928 if (SWIG_arg_fail(2)) SWIG_fail;
28929 }
28930 {
28931 arg3 = (int)(SWIG_As_int(obj2));
28932 if (SWIG_arg_fail(3)) SWIG_fail;
28933 }
28934 if (obj3) {
28935 {
28936 arg4 = (int)(SWIG_As_int(obj3));
28937 if (SWIG_arg_fail(4)) SWIG_fail;
28938 }
28939 }
28940 if (obj4) {
28941 {
28942 arg5 = (int)(SWIG_As_int(obj4));
28943 if (SWIG_arg_fail(5)) SWIG_fail;
28944 }
28945 }
28946 {
28947 PyThreadState* __tstate = wxPyBeginAllowThreads();
28948 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
28949
28950 wxPyEndAllowThreads(__tstate);
28951 if (PyErr_Occurred()) SWIG_fail;
28952 }
28953 {
28954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28955 }
28956 return resultobj;
28957 fail:
28958 return NULL;
28959 }
28960
28961
28962 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
28963 PyObject *resultobj;
28964 wxWindow *arg1 = (wxWindow *) 0 ;
28965 wxPoint *arg2 = 0 ;
28966 bool result;
28967 wxPoint temp2 ;
28968 PyObject * obj0 = 0 ;
28969 PyObject * obj1 = 0 ;
28970 char *kwnames[] = {
28971 (char *) "self",(char *) "pt", NULL
28972 };
28973
28974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
28975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28976 if (SWIG_arg_fail(1)) SWIG_fail;
28977 {
28978 arg2 = &temp2;
28979 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28980 }
28981 {
28982 PyThreadState* __tstate = wxPyBeginAllowThreads();
28983 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
28984
28985 wxPyEndAllowThreads(__tstate);
28986 if (PyErr_Occurred()) SWIG_fail;
28987 }
28988 {
28989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28990 }
28991 return resultobj;
28992 fail:
28993 return NULL;
28994 }
28995
28996
28997 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
28998 PyObject *resultobj;
28999 wxWindow *arg1 = (wxWindow *) 0 ;
29000 wxRect *arg2 = 0 ;
29001 bool result;
29002 wxRect temp2 ;
29003 PyObject * obj0 = 0 ;
29004 PyObject * obj1 = 0 ;
29005 char *kwnames[] = {
29006 (char *) "self",(char *) "rect", NULL
29007 };
29008
29009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",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 ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29015 }
29016 {
29017 PyThreadState* __tstate = wxPyBeginAllowThreads();
29018 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29019
29020 wxPyEndAllowThreads(__tstate);
29021 if (PyErr_Occurred()) SWIG_fail;
29022 }
29023 {
29024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29025 }
29026 return resultobj;
29027 fail:
29028 return NULL;
29029 }
29030
29031
29032 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29033 PyObject *resultobj;
29034 wxWindow *arg1 = (wxWindow *) 0 ;
29035 wxVisualAttributes result;
29036 PyObject * obj0 = 0 ;
29037 char *kwnames[] = {
29038 (char *) "self", NULL
29039 };
29040
29041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29043 if (SWIG_arg_fail(1)) SWIG_fail;
29044 {
29045 PyThreadState* __tstate = wxPyBeginAllowThreads();
29046 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29047
29048 wxPyEndAllowThreads(__tstate);
29049 if (PyErr_Occurred()) SWIG_fail;
29050 }
29051 {
29052 wxVisualAttributes * resultptr;
29053 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29054 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29055 }
29056 return resultobj;
29057 fail:
29058 return NULL;
29059 }
29060
29061
29062 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29063 PyObject *resultobj;
29064 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29065 wxVisualAttributes result;
29066 PyObject * obj0 = 0 ;
29067 char *kwnames[] = {
29068 (char *) "variant", NULL
29069 };
29070
29071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29072 if (obj0) {
29073 {
29074 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29075 if (SWIG_arg_fail(1)) SWIG_fail;
29076 }
29077 }
29078 {
29079 if (!wxPyCheckForApp()) SWIG_fail;
29080 PyThreadState* __tstate = wxPyBeginAllowThreads();
29081 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29082
29083 wxPyEndAllowThreads(__tstate);
29084 if (PyErr_Occurred()) SWIG_fail;
29085 }
29086 {
29087 wxVisualAttributes * resultptr;
29088 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29089 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29090 }
29091 return resultobj;
29092 fail:
29093 return NULL;
29094 }
29095
29096
29097 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29098 PyObject *resultobj;
29099 wxWindow *arg1 = (wxWindow *) 0 ;
29100 wxColour *arg2 = 0 ;
29101 bool result;
29102 wxColour temp2 ;
29103 PyObject * obj0 = 0 ;
29104 PyObject * obj1 = 0 ;
29105 char *kwnames[] = {
29106 (char *) "self",(char *) "colour", NULL
29107 };
29108
29109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29111 if (SWIG_arg_fail(1)) SWIG_fail;
29112 {
29113 arg2 = &temp2;
29114 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29115 }
29116 {
29117 PyThreadState* __tstate = wxPyBeginAllowThreads();
29118 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29119
29120 wxPyEndAllowThreads(__tstate);
29121 if (PyErr_Occurred()) SWIG_fail;
29122 }
29123 {
29124 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29125 }
29126 return resultobj;
29127 fail:
29128 return NULL;
29129 }
29130
29131
29132 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29133 PyObject *resultobj;
29134 wxWindow *arg1 = (wxWindow *) 0 ;
29135 wxColour *arg2 = 0 ;
29136 wxColour temp2 ;
29137 PyObject * obj0 = 0 ;
29138 PyObject * obj1 = 0 ;
29139 char *kwnames[] = {
29140 (char *) "self",(char *) "colour", NULL
29141 };
29142
29143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29145 if (SWIG_arg_fail(1)) SWIG_fail;
29146 {
29147 arg2 = &temp2;
29148 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29149 }
29150 {
29151 PyThreadState* __tstate = wxPyBeginAllowThreads();
29152 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29153
29154 wxPyEndAllowThreads(__tstate);
29155 if (PyErr_Occurred()) SWIG_fail;
29156 }
29157 Py_INCREF(Py_None); resultobj = Py_None;
29158 return resultobj;
29159 fail:
29160 return NULL;
29161 }
29162
29163
29164 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29165 PyObject *resultobj;
29166 wxWindow *arg1 = (wxWindow *) 0 ;
29167 wxColour *arg2 = 0 ;
29168 bool result;
29169 wxColour temp2 ;
29170 PyObject * obj0 = 0 ;
29171 PyObject * obj1 = 0 ;
29172 char *kwnames[] = {
29173 (char *) "self",(char *) "colour", NULL
29174 };
29175
29176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29178 if (SWIG_arg_fail(1)) SWIG_fail;
29179 {
29180 arg2 = &temp2;
29181 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29182 }
29183 {
29184 PyThreadState* __tstate = wxPyBeginAllowThreads();
29185 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29186
29187 wxPyEndAllowThreads(__tstate);
29188 if (PyErr_Occurred()) SWIG_fail;
29189 }
29190 {
29191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29192 }
29193 return resultobj;
29194 fail:
29195 return NULL;
29196 }
29197
29198
29199 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29200 PyObject *resultobj;
29201 wxWindow *arg1 = (wxWindow *) 0 ;
29202 wxColour *arg2 = 0 ;
29203 wxColour temp2 ;
29204 PyObject * obj0 = 0 ;
29205 PyObject * obj1 = 0 ;
29206 char *kwnames[] = {
29207 (char *) "self",(char *) "colour", NULL
29208 };
29209
29210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29212 if (SWIG_arg_fail(1)) SWIG_fail;
29213 {
29214 arg2 = &temp2;
29215 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29216 }
29217 {
29218 PyThreadState* __tstate = wxPyBeginAllowThreads();
29219 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29220
29221 wxPyEndAllowThreads(__tstate);
29222 if (PyErr_Occurred()) SWIG_fail;
29223 }
29224 Py_INCREF(Py_None); resultobj = Py_None;
29225 return resultobj;
29226 fail:
29227 return NULL;
29228 }
29229
29230
29231 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29232 PyObject *resultobj;
29233 wxWindow *arg1 = (wxWindow *) 0 ;
29234 wxColour result;
29235 PyObject * obj0 = 0 ;
29236 char *kwnames[] = {
29237 (char *) "self", NULL
29238 };
29239
29240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29242 if (SWIG_arg_fail(1)) SWIG_fail;
29243 {
29244 PyThreadState* __tstate = wxPyBeginAllowThreads();
29245 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29246
29247 wxPyEndAllowThreads(__tstate);
29248 if (PyErr_Occurred()) SWIG_fail;
29249 }
29250 {
29251 wxColour * resultptr;
29252 resultptr = new wxColour((wxColour &)(result));
29253 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29254 }
29255 return resultobj;
29256 fail:
29257 return NULL;
29258 }
29259
29260
29261 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29262 PyObject *resultobj;
29263 wxWindow *arg1 = (wxWindow *) 0 ;
29264 wxColour result;
29265 PyObject * obj0 = 0 ;
29266 char *kwnames[] = {
29267 (char *) "self", NULL
29268 };
29269
29270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29272 if (SWIG_arg_fail(1)) SWIG_fail;
29273 {
29274 PyThreadState* __tstate = wxPyBeginAllowThreads();
29275 result = ((wxWindow const *)arg1)->GetForegroundColour();
29276
29277 wxPyEndAllowThreads(__tstate);
29278 if (PyErr_Occurred()) SWIG_fail;
29279 }
29280 {
29281 wxColour * resultptr;
29282 resultptr = new wxColour((wxColour &)(result));
29283 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29284 }
29285 return resultobj;
29286 fail:
29287 return NULL;
29288 }
29289
29290
29291 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29292 PyObject *resultobj;
29293 wxWindow *arg1 = (wxWindow *) 0 ;
29294 wxBackgroundStyle arg2 ;
29295 bool result;
29296 PyObject * obj0 = 0 ;
29297 PyObject * obj1 = 0 ;
29298 char *kwnames[] = {
29299 (char *) "self",(char *) "style", NULL
29300 };
29301
29302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29304 if (SWIG_arg_fail(1)) SWIG_fail;
29305 {
29306 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29307 if (SWIG_arg_fail(2)) SWIG_fail;
29308 }
29309 {
29310 PyThreadState* __tstate = wxPyBeginAllowThreads();
29311 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29312
29313 wxPyEndAllowThreads(__tstate);
29314 if (PyErr_Occurred()) SWIG_fail;
29315 }
29316 {
29317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29318 }
29319 return resultobj;
29320 fail:
29321 return NULL;
29322 }
29323
29324
29325 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29326 PyObject *resultobj;
29327 wxWindow *arg1 = (wxWindow *) 0 ;
29328 wxBackgroundStyle result;
29329 PyObject * obj0 = 0 ;
29330 char *kwnames[] = {
29331 (char *) "self", NULL
29332 };
29333
29334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29336 if (SWIG_arg_fail(1)) SWIG_fail;
29337 {
29338 PyThreadState* __tstate = wxPyBeginAllowThreads();
29339 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29340
29341 wxPyEndAllowThreads(__tstate);
29342 if (PyErr_Occurred()) SWIG_fail;
29343 }
29344 resultobj = SWIG_From_int((result));
29345 return resultobj;
29346 fail:
29347 return NULL;
29348 }
29349
29350
29351 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29352 PyObject *resultobj;
29353 wxWindow *arg1 = (wxWindow *) 0 ;
29354 bool result;
29355 PyObject * obj0 = 0 ;
29356 char *kwnames[] = {
29357 (char *) "self", NULL
29358 };
29359
29360 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
29361 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29362 if (SWIG_arg_fail(1)) SWIG_fail;
29363 {
29364 PyThreadState* __tstate = wxPyBeginAllowThreads();
29365 result = (bool)(arg1)->HasTransparentBackground();
29366
29367 wxPyEndAllowThreads(__tstate);
29368 if (PyErr_Occurred()) SWIG_fail;
29369 }
29370 {
29371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29372 }
29373 return resultobj;
29374 fail:
29375 return NULL;
29376 }
29377
29378
29379 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29380 PyObject *resultobj;
29381 wxWindow *arg1 = (wxWindow *) 0 ;
29382 wxCursor *arg2 = 0 ;
29383 bool result;
29384 PyObject * obj0 = 0 ;
29385 PyObject * obj1 = 0 ;
29386 char *kwnames[] = {
29387 (char *) "self",(char *) "cursor", NULL
29388 };
29389
29390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
29391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29392 if (SWIG_arg_fail(1)) SWIG_fail;
29393 {
29394 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
29395 if (SWIG_arg_fail(2)) SWIG_fail;
29396 if (arg2 == NULL) {
29397 SWIG_null_ref("wxCursor");
29398 }
29399 if (SWIG_arg_fail(2)) SWIG_fail;
29400 }
29401 {
29402 PyThreadState* __tstate = wxPyBeginAllowThreads();
29403 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
29404
29405 wxPyEndAllowThreads(__tstate);
29406 if (PyErr_Occurred()) SWIG_fail;
29407 }
29408 {
29409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29410 }
29411 return resultobj;
29412 fail:
29413 return NULL;
29414 }
29415
29416
29417 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
29418 PyObject *resultobj;
29419 wxWindow *arg1 = (wxWindow *) 0 ;
29420 wxCursor result;
29421 PyObject * obj0 = 0 ;
29422 char *kwnames[] = {
29423 (char *) "self", NULL
29424 };
29425
29426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
29427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29428 if (SWIG_arg_fail(1)) SWIG_fail;
29429 {
29430 PyThreadState* __tstate = wxPyBeginAllowThreads();
29431 result = (arg1)->GetCursor();
29432
29433 wxPyEndAllowThreads(__tstate);
29434 if (PyErr_Occurred()) SWIG_fail;
29435 }
29436 {
29437 wxCursor * resultptr;
29438 resultptr = new wxCursor((wxCursor &)(result));
29439 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
29440 }
29441 return resultobj;
29442 fail:
29443 return NULL;
29444 }
29445
29446
29447 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29448 PyObject *resultobj;
29449 wxWindow *arg1 = (wxWindow *) 0 ;
29450 wxFont *arg2 = 0 ;
29451 bool result;
29452 PyObject * obj0 = 0 ;
29453 PyObject * obj1 = 0 ;
29454 char *kwnames[] = {
29455 (char *) "self",(char *) "font", NULL
29456 };
29457
29458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
29459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29460 if (SWIG_arg_fail(1)) SWIG_fail;
29461 {
29462 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29463 if (SWIG_arg_fail(2)) SWIG_fail;
29464 if (arg2 == NULL) {
29465 SWIG_null_ref("wxFont");
29466 }
29467 if (SWIG_arg_fail(2)) SWIG_fail;
29468 }
29469 {
29470 PyThreadState* __tstate = wxPyBeginAllowThreads();
29471 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
29472
29473 wxPyEndAllowThreads(__tstate);
29474 if (PyErr_Occurred()) SWIG_fail;
29475 }
29476 {
29477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29478 }
29479 return resultobj;
29480 fail:
29481 return NULL;
29482 }
29483
29484
29485 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
29486 PyObject *resultobj;
29487 wxWindow *arg1 = (wxWindow *) 0 ;
29488 wxFont *arg2 = 0 ;
29489 PyObject * obj0 = 0 ;
29490 PyObject * obj1 = 0 ;
29491 char *kwnames[] = {
29492 (char *) "self",(char *) "font", NULL
29493 };
29494
29495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
29496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29497 if (SWIG_arg_fail(1)) SWIG_fail;
29498 {
29499 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29500 if (SWIG_arg_fail(2)) SWIG_fail;
29501 if (arg2 == NULL) {
29502 SWIG_null_ref("wxFont");
29503 }
29504 if (SWIG_arg_fail(2)) SWIG_fail;
29505 }
29506 {
29507 PyThreadState* __tstate = wxPyBeginAllowThreads();
29508 (arg1)->SetOwnFont((wxFont const &)*arg2);
29509
29510 wxPyEndAllowThreads(__tstate);
29511 if (PyErr_Occurred()) SWIG_fail;
29512 }
29513 Py_INCREF(Py_None); resultobj = Py_None;
29514 return resultobj;
29515 fail:
29516 return NULL;
29517 }
29518
29519
29520 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
29521 PyObject *resultobj;
29522 wxWindow *arg1 = (wxWindow *) 0 ;
29523 wxFont result;
29524 PyObject * obj0 = 0 ;
29525 char *kwnames[] = {
29526 (char *) "self", NULL
29527 };
29528
29529 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
29530 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29531 if (SWIG_arg_fail(1)) SWIG_fail;
29532 {
29533 PyThreadState* __tstate = wxPyBeginAllowThreads();
29534 result = (arg1)->GetFont();
29535
29536 wxPyEndAllowThreads(__tstate);
29537 if (PyErr_Occurred()) SWIG_fail;
29538 }
29539 {
29540 wxFont * resultptr;
29541 resultptr = new wxFont((wxFont &)(result));
29542 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
29543 }
29544 return resultobj;
29545 fail:
29546 return NULL;
29547 }
29548
29549
29550 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29551 PyObject *resultobj;
29552 wxWindow *arg1 = (wxWindow *) 0 ;
29553 wxCaret *arg2 = (wxCaret *) 0 ;
29554 PyObject * obj0 = 0 ;
29555 PyObject * obj1 = 0 ;
29556 char *kwnames[] = {
29557 (char *) "self",(char *) "caret", NULL
29558 };
29559
29560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
29561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29562 if (SWIG_arg_fail(1)) SWIG_fail;
29563 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
29564 if (SWIG_arg_fail(2)) SWIG_fail;
29565 {
29566 PyThreadState* __tstate = wxPyBeginAllowThreads();
29567 (arg1)->SetCaret(arg2);
29568
29569 wxPyEndAllowThreads(__tstate);
29570 if (PyErr_Occurred()) SWIG_fail;
29571 }
29572 Py_INCREF(Py_None); resultobj = Py_None;
29573 return resultobj;
29574 fail:
29575 return NULL;
29576 }
29577
29578
29579 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
29580 PyObject *resultobj;
29581 wxWindow *arg1 = (wxWindow *) 0 ;
29582 wxCaret *result;
29583 PyObject * obj0 = 0 ;
29584 char *kwnames[] = {
29585 (char *) "self", NULL
29586 };
29587
29588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
29589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29590 if (SWIG_arg_fail(1)) SWIG_fail;
29591 {
29592 PyThreadState* __tstate = wxPyBeginAllowThreads();
29593 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
29594
29595 wxPyEndAllowThreads(__tstate);
29596 if (PyErr_Occurred()) SWIG_fail;
29597 }
29598 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
29599 return resultobj;
29600 fail:
29601 return NULL;
29602 }
29603
29604
29605 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
29606 PyObject *resultobj;
29607 wxWindow *arg1 = (wxWindow *) 0 ;
29608 int result;
29609 PyObject * obj0 = 0 ;
29610 char *kwnames[] = {
29611 (char *) "self", NULL
29612 };
29613
29614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
29615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29616 if (SWIG_arg_fail(1)) SWIG_fail;
29617 {
29618 PyThreadState* __tstate = wxPyBeginAllowThreads();
29619 result = (int)((wxWindow const *)arg1)->GetCharHeight();
29620
29621 wxPyEndAllowThreads(__tstate);
29622 if (PyErr_Occurred()) SWIG_fail;
29623 }
29624 {
29625 resultobj = SWIG_From_int((int)(result));
29626 }
29627 return resultobj;
29628 fail:
29629 return NULL;
29630 }
29631
29632
29633 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
29634 PyObject *resultobj;
29635 wxWindow *arg1 = (wxWindow *) 0 ;
29636 int result;
29637 PyObject * obj0 = 0 ;
29638 char *kwnames[] = {
29639 (char *) "self", NULL
29640 };
29641
29642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
29643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29644 if (SWIG_arg_fail(1)) SWIG_fail;
29645 {
29646 PyThreadState* __tstate = wxPyBeginAllowThreads();
29647 result = (int)((wxWindow const *)arg1)->GetCharWidth();
29648
29649 wxPyEndAllowThreads(__tstate);
29650 if (PyErr_Occurred()) SWIG_fail;
29651 }
29652 {
29653 resultobj = SWIG_From_int((int)(result));
29654 }
29655 return resultobj;
29656 fail:
29657 return NULL;
29658 }
29659
29660
29661 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29662 PyObject *resultobj;
29663 wxWindow *arg1 = (wxWindow *) 0 ;
29664 wxString *arg2 = 0 ;
29665 int *arg3 = (int *) 0 ;
29666 int *arg4 = (int *) 0 ;
29667 bool temp2 = false ;
29668 int temp3 ;
29669 int res3 = 0 ;
29670 int temp4 ;
29671 int res4 = 0 ;
29672 PyObject * obj0 = 0 ;
29673 PyObject * obj1 = 0 ;
29674 char *kwnames[] = {
29675 (char *) "self",(char *) "string", NULL
29676 };
29677
29678 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29679 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
29681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29682 if (SWIG_arg_fail(1)) SWIG_fail;
29683 {
29684 arg2 = wxString_in_helper(obj1);
29685 if (arg2 == NULL) SWIG_fail;
29686 temp2 = true;
29687 }
29688 {
29689 PyThreadState* __tstate = wxPyBeginAllowThreads();
29690 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
29691
29692 wxPyEndAllowThreads(__tstate);
29693 if (PyErr_Occurred()) SWIG_fail;
29694 }
29695 Py_INCREF(Py_None); resultobj = Py_None;
29696 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29697 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29698 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29699 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29700 {
29701 if (temp2)
29702 delete arg2;
29703 }
29704 return resultobj;
29705 fail:
29706 {
29707 if (temp2)
29708 delete arg2;
29709 }
29710 return NULL;
29711 }
29712
29713
29714 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
29715 PyObject *resultobj;
29716 wxWindow *arg1 = (wxWindow *) 0 ;
29717 wxString *arg2 = 0 ;
29718 int *arg3 = (int *) 0 ;
29719 int *arg4 = (int *) 0 ;
29720 int *arg5 = (int *) 0 ;
29721 int *arg6 = (int *) 0 ;
29722 wxFont *arg7 = (wxFont *) NULL ;
29723 bool temp2 = false ;
29724 int temp3 ;
29725 int res3 = 0 ;
29726 int temp4 ;
29727 int res4 = 0 ;
29728 int temp5 ;
29729 int res5 = 0 ;
29730 int temp6 ;
29731 int res6 = 0 ;
29732 PyObject * obj0 = 0 ;
29733 PyObject * obj1 = 0 ;
29734 PyObject * obj2 = 0 ;
29735 char *kwnames[] = {
29736 (char *) "self",(char *) "string",(char *) "font", NULL
29737 };
29738
29739 arg3 = &temp3; res3 = SWIG_NEWOBJ;
29740 arg4 = &temp4; res4 = SWIG_NEWOBJ;
29741 arg5 = &temp5; res5 = SWIG_NEWOBJ;
29742 arg6 = &temp6; res6 = SWIG_NEWOBJ;
29743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
29744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29745 if (SWIG_arg_fail(1)) SWIG_fail;
29746 {
29747 arg2 = wxString_in_helper(obj1);
29748 if (arg2 == NULL) SWIG_fail;
29749 temp2 = true;
29750 }
29751 if (obj2) {
29752 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
29753 if (SWIG_arg_fail(7)) SWIG_fail;
29754 }
29755 {
29756 PyThreadState* __tstate = wxPyBeginAllowThreads();
29757 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
29758
29759 wxPyEndAllowThreads(__tstate);
29760 if (PyErr_Occurred()) SWIG_fail;
29761 }
29762 Py_INCREF(Py_None); resultobj = Py_None;
29763 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29764 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29765 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
29766 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
29767 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
29768 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
29769 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
29770 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
29771 {
29772 if (temp2)
29773 delete arg2;
29774 }
29775 return resultobj;
29776 fail:
29777 {
29778 if (temp2)
29779 delete arg2;
29780 }
29781 return NULL;
29782 }
29783
29784
29785 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
29786 PyObject *resultobj;
29787 wxWindow *arg1 = (wxWindow *) 0 ;
29788 int *arg2 = (int *) 0 ;
29789 int *arg3 = (int *) 0 ;
29790 int temp2 ;
29791 int res2 = 0 ;
29792 int temp3 ;
29793 int res3 = 0 ;
29794 PyObject * obj0 = 0 ;
29795 PyObject * obj1 = 0 ;
29796 PyObject * obj2 = 0 ;
29797 char *kwnames[] = {
29798 (char *) "self",(char *) "x",(char *) "y", NULL
29799 };
29800
29801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29803 if (SWIG_arg_fail(1)) SWIG_fail;
29804 {
29805 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29806 temp2 = SWIG_As_int(obj1);
29807 if (SWIG_arg_fail(2)) SWIG_fail;
29808 arg2 = &temp2;
29809 res2 = SWIG_NEWOBJ;
29810 }
29811 }
29812 {
29813 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29814 temp3 = SWIG_As_int(obj2);
29815 if (SWIG_arg_fail(3)) SWIG_fail;
29816 arg3 = &temp3;
29817 res3 = SWIG_NEWOBJ;
29818 }
29819 }
29820 {
29821 PyThreadState* __tstate = wxPyBeginAllowThreads();
29822 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
29823
29824 wxPyEndAllowThreads(__tstate);
29825 if (PyErr_Occurred()) SWIG_fail;
29826 }
29827 Py_INCREF(Py_None); resultobj = Py_None;
29828 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29829 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29830 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29831 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29832 return resultobj;
29833 fail:
29834 return NULL;
29835 }
29836
29837
29838 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
29839 PyObject *resultobj;
29840 wxWindow *arg1 = (wxWindow *) 0 ;
29841 int *arg2 = (int *) 0 ;
29842 int *arg3 = (int *) 0 ;
29843 int temp2 ;
29844 int res2 = 0 ;
29845 int temp3 ;
29846 int res3 = 0 ;
29847 PyObject * obj0 = 0 ;
29848 PyObject * obj1 = 0 ;
29849 PyObject * obj2 = 0 ;
29850 char *kwnames[] = {
29851 (char *) "self",(char *) "x",(char *) "y", NULL
29852 };
29853
29854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29856 if (SWIG_arg_fail(1)) SWIG_fail;
29857 {
29858 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
29859 temp2 = SWIG_As_int(obj1);
29860 if (SWIG_arg_fail(2)) SWIG_fail;
29861 arg2 = &temp2;
29862 res2 = SWIG_NEWOBJ;
29863 }
29864 }
29865 {
29866 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
29867 temp3 = SWIG_As_int(obj2);
29868 if (SWIG_arg_fail(3)) SWIG_fail;
29869 arg3 = &temp3;
29870 res3 = SWIG_NEWOBJ;
29871 }
29872 }
29873 {
29874 PyThreadState* __tstate = wxPyBeginAllowThreads();
29875 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
29876
29877 wxPyEndAllowThreads(__tstate);
29878 if (PyErr_Occurred()) SWIG_fail;
29879 }
29880 Py_INCREF(Py_None); resultobj = Py_None;
29881 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
29882 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
29883 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
29884 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
29885 return resultobj;
29886 fail:
29887 return NULL;
29888 }
29889
29890
29891 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
29892 PyObject *resultobj;
29893 wxWindow *arg1 = (wxWindow *) 0 ;
29894 wxPoint *arg2 = 0 ;
29895 wxPoint result;
29896 wxPoint temp2 ;
29897 PyObject * obj0 = 0 ;
29898 PyObject * obj1 = 0 ;
29899 char *kwnames[] = {
29900 (char *) "self",(char *) "pt", NULL
29901 };
29902
29903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
29904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29905 if (SWIG_arg_fail(1)) SWIG_fail;
29906 {
29907 arg2 = &temp2;
29908 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29909 }
29910 {
29911 PyThreadState* __tstate = wxPyBeginAllowThreads();
29912 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
29913
29914 wxPyEndAllowThreads(__tstate);
29915 if (PyErr_Occurred()) SWIG_fail;
29916 }
29917 {
29918 wxPoint * resultptr;
29919 resultptr = new wxPoint((wxPoint &)(result));
29920 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29921 }
29922 return resultobj;
29923 fail:
29924 return NULL;
29925 }
29926
29927
29928 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
29929 PyObject *resultobj;
29930 wxWindow *arg1 = (wxWindow *) 0 ;
29931 wxPoint *arg2 = 0 ;
29932 wxPoint result;
29933 wxPoint temp2 ;
29934 PyObject * obj0 = 0 ;
29935 PyObject * obj1 = 0 ;
29936 char *kwnames[] = {
29937 (char *) "self",(char *) "pt", NULL
29938 };
29939
29940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
29941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29942 if (SWIG_arg_fail(1)) SWIG_fail;
29943 {
29944 arg2 = &temp2;
29945 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29946 }
29947 {
29948 PyThreadState* __tstate = wxPyBeginAllowThreads();
29949 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
29950
29951 wxPyEndAllowThreads(__tstate);
29952 if (PyErr_Occurred()) SWIG_fail;
29953 }
29954 {
29955 wxPoint * resultptr;
29956 resultptr = new wxPoint((wxPoint &)(result));
29957 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29958 }
29959 return resultobj;
29960 fail:
29961 return NULL;
29962 }
29963
29964
29965 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
29966 PyObject *resultobj;
29967 wxWindow *arg1 = (wxWindow *) 0 ;
29968 int arg2 ;
29969 int arg3 ;
29970 wxHitTest result;
29971 PyObject * obj0 = 0 ;
29972 PyObject * obj1 = 0 ;
29973 PyObject * obj2 = 0 ;
29974 char *kwnames[] = {
29975 (char *) "self",(char *) "x",(char *) "y", NULL
29976 };
29977
29978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
29979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29980 if (SWIG_arg_fail(1)) SWIG_fail;
29981 {
29982 arg2 = (int)(SWIG_As_int(obj1));
29983 if (SWIG_arg_fail(2)) SWIG_fail;
29984 }
29985 {
29986 arg3 = (int)(SWIG_As_int(obj2));
29987 if (SWIG_arg_fail(3)) SWIG_fail;
29988 }
29989 {
29990 PyThreadState* __tstate = wxPyBeginAllowThreads();
29991 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
29992
29993 wxPyEndAllowThreads(__tstate);
29994 if (PyErr_Occurred()) SWIG_fail;
29995 }
29996 resultobj = SWIG_From_int((result));
29997 return resultobj;
29998 fail:
29999 return NULL;
30000 }
30001
30002
30003 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30004 PyObject *resultobj;
30005 wxWindow *arg1 = (wxWindow *) 0 ;
30006 wxPoint *arg2 = 0 ;
30007 wxHitTest result;
30008 wxPoint temp2 ;
30009 PyObject * obj0 = 0 ;
30010 PyObject * obj1 = 0 ;
30011 char *kwnames[] = {
30012 (char *) "self",(char *) "pt", NULL
30013 };
30014
30015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30017 if (SWIG_arg_fail(1)) SWIG_fail;
30018 {
30019 arg2 = &temp2;
30020 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30021 }
30022 {
30023 PyThreadState* __tstate = wxPyBeginAllowThreads();
30024 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30025
30026 wxPyEndAllowThreads(__tstate);
30027 if (PyErr_Occurred()) SWIG_fail;
30028 }
30029 resultobj = SWIG_From_int((result));
30030 return resultobj;
30031 fail:
30032 return NULL;
30033 }
30034
30035
30036 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30037 PyObject *resultobj;
30038 wxWindow *arg1 = (wxWindow *) 0 ;
30039 long arg2 ;
30040 wxBorder result;
30041 PyObject * obj0 = 0 ;
30042 PyObject * obj1 = 0 ;
30043
30044 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30046 if (SWIG_arg_fail(1)) SWIG_fail;
30047 {
30048 arg2 = (long)(SWIG_As_long(obj1));
30049 if (SWIG_arg_fail(2)) SWIG_fail;
30050 }
30051 {
30052 PyThreadState* __tstate = wxPyBeginAllowThreads();
30053 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30054
30055 wxPyEndAllowThreads(__tstate);
30056 if (PyErr_Occurred()) SWIG_fail;
30057 }
30058 resultobj = SWIG_From_int((result));
30059 return resultobj;
30060 fail:
30061 return NULL;
30062 }
30063
30064
30065 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30066 PyObject *resultobj;
30067 wxWindow *arg1 = (wxWindow *) 0 ;
30068 wxBorder result;
30069 PyObject * obj0 = 0 ;
30070
30071 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30073 if (SWIG_arg_fail(1)) SWIG_fail;
30074 {
30075 PyThreadState* __tstate = wxPyBeginAllowThreads();
30076 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30077
30078 wxPyEndAllowThreads(__tstate);
30079 if (PyErr_Occurred()) SWIG_fail;
30080 }
30081 resultobj = SWIG_From_int((result));
30082 return resultobj;
30083 fail:
30084 return NULL;
30085 }
30086
30087
30088 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30089 int argc;
30090 PyObject *argv[3];
30091 int ii;
30092
30093 argc = PyObject_Length(args);
30094 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30095 argv[ii] = PyTuple_GetItem(args,ii);
30096 }
30097 if (argc == 1) {
30098 int _v;
30099 {
30100 void *ptr;
30101 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30102 _v = 0;
30103 PyErr_Clear();
30104 } else {
30105 _v = 1;
30106 }
30107 }
30108 if (_v) {
30109 return _wrap_Window_GetBorder__SWIG_1(self,args);
30110 }
30111 }
30112 if (argc == 2) {
30113 int _v;
30114 {
30115 void *ptr;
30116 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30117 _v = 0;
30118 PyErr_Clear();
30119 } else {
30120 _v = 1;
30121 }
30122 }
30123 if (_v) {
30124 _v = SWIG_Check_long(argv[1]);
30125 if (_v) {
30126 return _wrap_Window_GetBorder__SWIG_0(self,args);
30127 }
30128 }
30129 }
30130
30131 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30132 return NULL;
30133 }
30134
30135
30136 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30137 PyObject *resultobj;
30138 wxWindow *arg1 = (wxWindow *) 0 ;
30139 long arg2 = (long) wxUPDATE_UI_NONE ;
30140 PyObject * obj0 = 0 ;
30141 PyObject * obj1 = 0 ;
30142 char *kwnames[] = {
30143 (char *) "self",(char *) "flags", NULL
30144 };
30145
30146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30148 if (SWIG_arg_fail(1)) SWIG_fail;
30149 if (obj1) {
30150 {
30151 arg2 = (long)(SWIG_As_long(obj1));
30152 if (SWIG_arg_fail(2)) SWIG_fail;
30153 }
30154 }
30155 {
30156 PyThreadState* __tstate = wxPyBeginAllowThreads();
30157 (arg1)->UpdateWindowUI(arg2);
30158
30159 wxPyEndAllowThreads(__tstate);
30160 if (PyErr_Occurred()) SWIG_fail;
30161 }
30162 Py_INCREF(Py_None); resultobj = Py_None;
30163 return resultobj;
30164 fail:
30165 return NULL;
30166 }
30167
30168
30169 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30170 PyObject *resultobj;
30171 wxWindow *arg1 = (wxWindow *) 0 ;
30172 wxMenu *arg2 = (wxMenu *) 0 ;
30173 int arg3 = (int) -1 ;
30174 int arg4 = (int) -1 ;
30175 bool result;
30176 PyObject * obj0 = 0 ;
30177 PyObject * obj1 = 0 ;
30178 PyObject * obj2 = 0 ;
30179 PyObject * obj3 = 0 ;
30180 char *kwnames[] = {
30181 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30182 };
30183
30184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30186 if (SWIG_arg_fail(1)) SWIG_fail;
30187 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30188 if (SWIG_arg_fail(2)) SWIG_fail;
30189 if (obj2) {
30190 {
30191 arg3 = (int)(SWIG_As_int(obj2));
30192 if (SWIG_arg_fail(3)) SWIG_fail;
30193 }
30194 }
30195 if (obj3) {
30196 {
30197 arg4 = (int)(SWIG_As_int(obj3));
30198 if (SWIG_arg_fail(4)) SWIG_fail;
30199 }
30200 }
30201 {
30202 PyThreadState* __tstate = wxPyBeginAllowThreads();
30203 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30204
30205 wxPyEndAllowThreads(__tstate);
30206 if (PyErr_Occurred()) SWIG_fail;
30207 }
30208 {
30209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30210 }
30211 return resultobj;
30212 fail:
30213 return NULL;
30214 }
30215
30216
30217 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30218 PyObject *resultobj;
30219 wxWindow *arg1 = (wxWindow *) 0 ;
30220 wxMenu *arg2 = (wxMenu *) 0 ;
30221 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30222 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30223 bool result;
30224 wxPoint temp3 ;
30225 PyObject * obj0 = 0 ;
30226 PyObject * obj1 = 0 ;
30227 PyObject * obj2 = 0 ;
30228 char *kwnames[] = {
30229 (char *) "self",(char *) "menu",(char *) "pos", NULL
30230 };
30231
30232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30234 if (SWIG_arg_fail(1)) SWIG_fail;
30235 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30236 if (SWIG_arg_fail(2)) SWIG_fail;
30237 if (obj2) {
30238 {
30239 arg3 = &temp3;
30240 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30241 }
30242 }
30243 {
30244 PyThreadState* __tstate = wxPyBeginAllowThreads();
30245 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30246
30247 wxPyEndAllowThreads(__tstate);
30248 if (PyErr_Occurred()) SWIG_fail;
30249 }
30250 {
30251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30252 }
30253 return resultobj;
30254 fail:
30255 return NULL;
30256 }
30257
30258
30259 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30260 PyObject *resultobj;
30261 wxWindow *arg1 = (wxWindow *) 0 ;
30262 long result;
30263 PyObject * obj0 = 0 ;
30264 char *kwnames[] = {
30265 (char *) "self", NULL
30266 };
30267
30268 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30270 if (SWIG_arg_fail(1)) SWIG_fail;
30271 {
30272 PyThreadState* __tstate = wxPyBeginAllowThreads();
30273 result = (long)wxWindow_GetHandle(arg1);
30274
30275 wxPyEndAllowThreads(__tstate);
30276 if (PyErr_Occurred()) SWIG_fail;
30277 }
30278 {
30279 resultobj = SWIG_From_long((long)(result));
30280 }
30281 return resultobj;
30282 fail:
30283 return NULL;
30284 }
30285
30286
30287 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30288 PyObject *resultobj;
30289 wxWindow *arg1 = (wxWindow *) 0 ;
30290 long arg2 ;
30291 PyObject * obj0 = 0 ;
30292 PyObject * obj1 = 0 ;
30293 char *kwnames[] = {
30294 (char *) "self",(char *) "handle", NULL
30295 };
30296
30297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30299 if (SWIG_arg_fail(1)) SWIG_fail;
30300 {
30301 arg2 = (long)(SWIG_As_long(obj1));
30302 if (SWIG_arg_fail(2)) SWIG_fail;
30303 }
30304 {
30305 PyThreadState* __tstate = wxPyBeginAllowThreads();
30306 wxWindow_AssociateHandle(arg1,arg2);
30307
30308 wxPyEndAllowThreads(__tstate);
30309 if (PyErr_Occurred()) SWIG_fail;
30310 }
30311 Py_INCREF(Py_None); resultobj = Py_None;
30312 return resultobj;
30313 fail:
30314 return NULL;
30315 }
30316
30317
30318 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30319 PyObject *resultobj;
30320 wxWindow *arg1 = (wxWindow *) 0 ;
30321 PyObject * obj0 = 0 ;
30322 char *kwnames[] = {
30323 (char *) "self", NULL
30324 };
30325
30326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30328 if (SWIG_arg_fail(1)) SWIG_fail;
30329 {
30330 PyThreadState* __tstate = wxPyBeginAllowThreads();
30331 (arg1)->DissociateHandle();
30332
30333 wxPyEndAllowThreads(__tstate);
30334 if (PyErr_Occurred()) SWIG_fail;
30335 }
30336 Py_INCREF(Py_None); resultobj = Py_None;
30337 return resultobj;
30338 fail:
30339 return NULL;
30340 }
30341
30342
30343 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30344 PyObject *resultobj;
30345 wxWindow *arg1 = (wxWindow *) 0 ;
30346 int arg2 ;
30347 bool result;
30348 PyObject * obj0 = 0 ;
30349 PyObject * obj1 = 0 ;
30350 char *kwnames[] = {
30351 (char *) "self",(char *) "orient", NULL
30352 };
30353
30354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
30355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30356 if (SWIG_arg_fail(1)) SWIG_fail;
30357 {
30358 arg2 = (int)(SWIG_As_int(obj1));
30359 if (SWIG_arg_fail(2)) SWIG_fail;
30360 }
30361 {
30362 PyThreadState* __tstate = wxPyBeginAllowThreads();
30363 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
30364
30365 wxPyEndAllowThreads(__tstate);
30366 if (PyErr_Occurred()) SWIG_fail;
30367 }
30368 {
30369 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30370 }
30371 return resultobj;
30372 fail:
30373 return NULL;
30374 }
30375
30376
30377 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30378 PyObject *resultobj;
30379 wxWindow *arg1 = (wxWindow *) 0 ;
30380 int arg2 ;
30381 int arg3 ;
30382 int arg4 ;
30383 int arg5 ;
30384 bool arg6 = (bool) true ;
30385 PyObject * obj0 = 0 ;
30386 PyObject * obj1 = 0 ;
30387 PyObject * obj2 = 0 ;
30388 PyObject * obj3 = 0 ;
30389 PyObject * obj4 = 0 ;
30390 PyObject * obj5 = 0 ;
30391 char *kwnames[] = {
30392 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
30393 };
30394
30395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
30396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30397 if (SWIG_arg_fail(1)) SWIG_fail;
30398 {
30399 arg2 = (int)(SWIG_As_int(obj1));
30400 if (SWIG_arg_fail(2)) SWIG_fail;
30401 }
30402 {
30403 arg3 = (int)(SWIG_As_int(obj2));
30404 if (SWIG_arg_fail(3)) SWIG_fail;
30405 }
30406 {
30407 arg4 = (int)(SWIG_As_int(obj3));
30408 if (SWIG_arg_fail(4)) SWIG_fail;
30409 }
30410 {
30411 arg5 = (int)(SWIG_As_int(obj4));
30412 if (SWIG_arg_fail(5)) SWIG_fail;
30413 }
30414 if (obj5) {
30415 {
30416 arg6 = (bool)(SWIG_As_bool(obj5));
30417 if (SWIG_arg_fail(6)) SWIG_fail;
30418 }
30419 }
30420 {
30421 PyThreadState* __tstate = wxPyBeginAllowThreads();
30422 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
30423
30424 wxPyEndAllowThreads(__tstate);
30425 if (PyErr_Occurred()) SWIG_fail;
30426 }
30427 Py_INCREF(Py_None); resultobj = Py_None;
30428 return resultobj;
30429 fail:
30430 return NULL;
30431 }
30432
30433
30434 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30435 PyObject *resultobj;
30436 wxWindow *arg1 = (wxWindow *) 0 ;
30437 int arg2 ;
30438 int arg3 ;
30439 bool arg4 = (bool) true ;
30440 PyObject * obj0 = 0 ;
30441 PyObject * obj1 = 0 ;
30442 PyObject * obj2 = 0 ;
30443 PyObject * obj3 = 0 ;
30444 char *kwnames[] = {
30445 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
30446 };
30447
30448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30450 if (SWIG_arg_fail(1)) SWIG_fail;
30451 {
30452 arg2 = (int)(SWIG_As_int(obj1));
30453 if (SWIG_arg_fail(2)) SWIG_fail;
30454 }
30455 {
30456 arg3 = (int)(SWIG_As_int(obj2));
30457 if (SWIG_arg_fail(3)) SWIG_fail;
30458 }
30459 if (obj3) {
30460 {
30461 arg4 = (bool)(SWIG_As_bool(obj3));
30462 if (SWIG_arg_fail(4)) SWIG_fail;
30463 }
30464 }
30465 {
30466 PyThreadState* __tstate = wxPyBeginAllowThreads();
30467 (arg1)->SetScrollPos(arg2,arg3,arg4);
30468
30469 wxPyEndAllowThreads(__tstate);
30470 if (PyErr_Occurred()) SWIG_fail;
30471 }
30472 Py_INCREF(Py_None); resultobj = Py_None;
30473 return resultobj;
30474 fail:
30475 return NULL;
30476 }
30477
30478
30479 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
30480 PyObject *resultobj;
30481 wxWindow *arg1 = (wxWindow *) 0 ;
30482 int arg2 ;
30483 int result;
30484 PyObject * obj0 = 0 ;
30485 PyObject * obj1 = 0 ;
30486 char *kwnames[] = {
30487 (char *) "self",(char *) "orientation", NULL
30488 };
30489
30490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
30491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30492 if (SWIG_arg_fail(1)) SWIG_fail;
30493 {
30494 arg2 = (int)(SWIG_As_int(obj1));
30495 if (SWIG_arg_fail(2)) SWIG_fail;
30496 }
30497 {
30498 PyThreadState* __tstate = wxPyBeginAllowThreads();
30499 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
30500
30501 wxPyEndAllowThreads(__tstate);
30502 if (PyErr_Occurred()) SWIG_fail;
30503 }
30504 {
30505 resultobj = SWIG_From_int((int)(result));
30506 }
30507 return resultobj;
30508 fail:
30509 return NULL;
30510 }
30511
30512
30513 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
30514 PyObject *resultobj;
30515 wxWindow *arg1 = (wxWindow *) 0 ;
30516 int arg2 ;
30517 int result;
30518 PyObject * obj0 = 0 ;
30519 PyObject * obj1 = 0 ;
30520 char *kwnames[] = {
30521 (char *) "self",(char *) "orientation", NULL
30522 };
30523
30524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
30525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30526 if (SWIG_arg_fail(1)) SWIG_fail;
30527 {
30528 arg2 = (int)(SWIG_As_int(obj1));
30529 if (SWIG_arg_fail(2)) SWIG_fail;
30530 }
30531 {
30532 PyThreadState* __tstate = wxPyBeginAllowThreads();
30533 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
30534
30535 wxPyEndAllowThreads(__tstate);
30536 if (PyErr_Occurred()) SWIG_fail;
30537 }
30538 {
30539 resultobj = SWIG_From_int((int)(result));
30540 }
30541 return resultobj;
30542 fail:
30543 return NULL;
30544 }
30545
30546
30547 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
30548 PyObject *resultobj;
30549 wxWindow *arg1 = (wxWindow *) 0 ;
30550 int arg2 ;
30551 int result;
30552 PyObject * obj0 = 0 ;
30553 PyObject * obj1 = 0 ;
30554 char *kwnames[] = {
30555 (char *) "self",(char *) "orientation", NULL
30556 };
30557
30558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
30559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30560 if (SWIG_arg_fail(1)) SWIG_fail;
30561 {
30562 arg2 = (int)(SWIG_As_int(obj1));
30563 if (SWIG_arg_fail(2)) SWIG_fail;
30564 }
30565 {
30566 PyThreadState* __tstate = wxPyBeginAllowThreads();
30567 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
30568
30569 wxPyEndAllowThreads(__tstate);
30570 if (PyErr_Occurred()) SWIG_fail;
30571 }
30572 {
30573 resultobj = SWIG_From_int((int)(result));
30574 }
30575 return resultobj;
30576 fail:
30577 return NULL;
30578 }
30579
30580
30581 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
30582 PyObject *resultobj;
30583 wxWindow *arg1 = (wxWindow *) 0 ;
30584 int arg2 ;
30585 int arg3 ;
30586 wxRect *arg4 = (wxRect *) NULL ;
30587 PyObject * obj0 = 0 ;
30588 PyObject * obj1 = 0 ;
30589 PyObject * obj2 = 0 ;
30590 PyObject * obj3 = 0 ;
30591 char *kwnames[] = {
30592 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
30593 };
30594
30595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30597 if (SWIG_arg_fail(1)) SWIG_fail;
30598 {
30599 arg2 = (int)(SWIG_As_int(obj1));
30600 if (SWIG_arg_fail(2)) SWIG_fail;
30601 }
30602 {
30603 arg3 = (int)(SWIG_As_int(obj2));
30604 if (SWIG_arg_fail(3)) SWIG_fail;
30605 }
30606 if (obj3) {
30607 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
30608 if (SWIG_arg_fail(4)) SWIG_fail;
30609 }
30610 {
30611 PyThreadState* __tstate = wxPyBeginAllowThreads();
30612 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
30613
30614 wxPyEndAllowThreads(__tstate);
30615 if (PyErr_Occurred()) SWIG_fail;
30616 }
30617 Py_INCREF(Py_None); resultobj = Py_None;
30618 return resultobj;
30619 fail:
30620 return NULL;
30621 }
30622
30623
30624 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
30625 PyObject *resultobj;
30626 wxWindow *arg1 = (wxWindow *) 0 ;
30627 int arg2 ;
30628 bool result;
30629 PyObject * obj0 = 0 ;
30630 PyObject * obj1 = 0 ;
30631 char *kwnames[] = {
30632 (char *) "self",(char *) "lines", NULL
30633 };
30634
30635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
30636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30637 if (SWIG_arg_fail(1)) SWIG_fail;
30638 {
30639 arg2 = (int)(SWIG_As_int(obj1));
30640 if (SWIG_arg_fail(2)) SWIG_fail;
30641 }
30642 {
30643 PyThreadState* __tstate = wxPyBeginAllowThreads();
30644 result = (bool)(arg1)->ScrollLines(arg2);
30645
30646 wxPyEndAllowThreads(__tstate);
30647 if (PyErr_Occurred()) SWIG_fail;
30648 }
30649 {
30650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30651 }
30652 return resultobj;
30653 fail:
30654 return NULL;
30655 }
30656
30657
30658 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
30659 PyObject *resultobj;
30660 wxWindow *arg1 = (wxWindow *) 0 ;
30661 int arg2 ;
30662 bool result;
30663 PyObject * obj0 = 0 ;
30664 PyObject * obj1 = 0 ;
30665 char *kwnames[] = {
30666 (char *) "self",(char *) "pages", NULL
30667 };
30668
30669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
30670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30671 if (SWIG_arg_fail(1)) SWIG_fail;
30672 {
30673 arg2 = (int)(SWIG_As_int(obj1));
30674 if (SWIG_arg_fail(2)) SWIG_fail;
30675 }
30676 {
30677 PyThreadState* __tstate = wxPyBeginAllowThreads();
30678 result = (bool)(arg1)->ScrollPages(arg2);
30679
30680 wxPyEndAllowThreads(__tstate);
30681 if (PyErr_Occurred()) SWIG_fail;
30682 }
30683 {
30684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30685 }
30686 return resultobj;
30687 fail:
30688 return NULL;
30689 }
30690
30691
30692 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
30693 PyObject *resultobj;
30694 wxWindow *arg1 = (wxWindow *) 0 ;
30695 bool result;
30696 PyObject * obj0 = 0 ;
30697 char *kwnames[] = {
30698 (char *) "self", NULL
30699 };
30700
30701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
30702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30703 if (SWIG_arg_fail(1)) SWIG_fail;
30704 {
30705 PyThreadState* __tstate = wxPyBeginAllowThreads();
30706 result = (bool)(arg1)->LineUp();
30707
30708 wxPyEndAllowThreads(__tstate);
30709 if (PyErr_Occurred()) SWIG_fail;
30710 }
30711 {
30712 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30713 }
30714 return resultobj;
30715 fail:
30716 return NULL;
30717 }
30718
30719
30720 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
30721 PyObject *resultobj;
30722 wxWindow *arg1 = (wxWindow *) 0 ;
30723 bool result;
30724 PyObject * obj0 = 0 ;
30725 char *kwnames[] = {
30726 (char *) "self", NULL
30727 };
30728
30729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
30730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30731 if (SWIG_arg_fail(1)) SWIG_fail;
30732 {
30733 PyThreadState* __tstate = wxPyBeginAllowThreads();
30734 result = (bool)(arg1)->LineDown();
30735
30736 wxPyEndAllowThreads(__tstate);
30737 if (PyErr_Occurred()) SWIG_fail;
30738 }
30739 {
30740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30741 }
30742 return resultobj;
30743 fail:
30744 return NULL;
30745 }
30746
30747
30748 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
30749 PyObject *resultobj;
30750 wxWindow *arg1 = (wxWindow *) 0 ;
30751 bool result;
30752 PyObject * obj0 = 0 ;
30753 char *kwnames[] = {
30754 (char *) "self", NULL
30755 };
30756
30757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
30758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30759 if (SWIG_arg_fail(1)) SWIG_fail;
30760 {
30761 PyThreadState* __tstate = wxPyBeginAllowThreads();
30762 result = (bool)(arg1)->PageUp();
30763
30764 wxPyEndAllowThreads(__tstate);
30765 if (PyErr_Occurred()) SWIG_fail;
30766 }
30767 {
30768 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30769 }
30770 return resultobj;
30771 fail:
30772 return NULL;
30773 }
30774
30775
30776 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
30777 PyObject *resultobj;
30778 wxWindow *arg1 = (wxWindow *) 0 ;
30779 bool result;
30780 PyObject * obj0 = 0 ;
30781 char *kwnames[] = {
30782 (char *) "self", NULL
30783 };
30784
30785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
30786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30787 if (SWIG_arg_fail(1)) SWIG_fail;
30788 {
30789 PyThreadState* __tstate = wxPyBeginAllowThreads();
30790 result = (bool)(arg1)->PageDown();
30791
30792 wxPyEndAllowThreads(__tstate);
30793 if (PyErr_Occurred()) SWIG_fail;
30794 }
30795 {
30796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30797 }
30798 return resultobj;
30799 fail:
30800 return NULL;
30801 }
30802
30803
30804 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30805 PyObject *resultobj;
30806 wxWindow *arg1 = (wxWindow *) 0 ;
30807 wxString *arg2 = 0 ;
30808 bool temp2 = false ;
30809 PyObject * obj0 = 0 ;
30810 PyObject * obj1 = 0 ;
30811 char *kwnames[] = {
30812 (char *) "self",(char *) "text", NULL
30813 };
30814
30815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
30816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30817 if (SWIG_arg_fail(1)) SWIG_fail;
30818 {
30819 arg2 = wxString_in_helper(obj1);
30820 if (arg2 == NULL) SWIG_fail;
30821 temp2 = true;
30822 }
30823 {
30824 PyThreadState* __tstate = wxPyBeginAllowThreads();
30825 (arg1)->SetHelpText((wxString const &)*arg2);
30826
30827 wxPyEndAllowThreads(__tstate);
30828 if (PyErr_Occurred()) SWIG_fail;
30829 }
30830 Py_INCREF(Py_None); resultobj = Py_None;
30831 {
30832 if (temp2)
30833 delete arg2;
30834 }
30835 return resultobj;
30836 fail:
30837 {
30838 if (temp2)
30839 delete arg2;
30840 }
30841 return NULL;
30842 }
30843
30844
30845 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
30846 PyObject *resultobj;
30847 wxWindow *arg1 = (wxWindow *) 0 ;
30848 wxString *arg2 = 0 ;
30849 bool temp2 = false ;
30850 PyObject * obj0 = 0 ;
30851 PyObject * obj1 = 0 ;
30852 char *kwnames[] = {
30853 (char *) "self",(char *) "text", NULL
30854 };
30855
30856 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
30857 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30858 if (SWIG_arg_fail(1)) SWIG_fail;
30859 {
30860 arg2 = wxString_in_helper(obj1);
30861 if (arg2 == NULL) SWIG_fail;
30862 temp2 = true;
30863 }
30864 {
30865 PyThreadState* __tstate = wxPyBeginAllowThreads();
30866 (arg1)->SetHelpTextForId((wxString const &)*arg2);
30867
30868 wxPyEndAllowThreads(__tstate);
30869 if (PyErr_Occurred()) SWIG_fail;
30870 }
30871 Py_INCREF(Py_None); resultobj = Py_None;
30872 {
30873 if (temp2)
30874 delete arg2;
30875 }
30876 return resultobj;
30877 fail:
30878 {
30879 if (temp2)
30880 delete arg2;
30881 }
30882 return NULL;
30883 }
30884
30885
30886 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
30887 PyObject *resultobj;
30888 wxWindow *arg1 = (wxWindow *) 0 ;
30889 wxString result;
30890 PyObject * obj0 = 0 ;
30891 char *kwnames[] = {
30892 (char *) "self", NULL
30893 };
30894
30895 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
30896 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30897 if (SWIG_arg_fail(1)) SWIG_fail;
30898 {
30899 PyThreadState* __tstate = wxPyBeginAllowThreads();
30900 result = ((wxWindow const *)arg1)->GetHelpText();
30901
30902 wxPyEndAllowThreads(__tstate);
30903 if (PyErr_Occurred()) SWIG_fail;
30904 }
30905 {
30906 #if wxUSE_UNICODE
30907 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30908 #else
30909 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30910 #endif
30911 }
30912 return resultobj;
30913 fail:
30914 return NULL;
30915 }
30916
30917
30918 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
30919 PyObject *resultobj;
30920 wxWindow *arg1 = (wxWindow *) 0 ;
30921 wxString *arg2 = 0 ;
30922 bool temp2 = false ;
30923 PyObject * obj0 = 0 ;
30924 PyObject * obj1 = 0 ;
30925 char *kwnames[] = {
30926 (char *) "self",(char *) "tip", NULL
30927 };
30928
30929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
30930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30931 if (SWIG_arg_fail(1)) SWIG_fail;
30932 {
30933 arg2 = wxString_in_helper(obj1);
30934 if (arg2 == NULL) SWIG_fail;
30935 temp2 = true;
30936 }
30937 {
30938 PyThreadState* __tstate = wxPyBeginAllowThreads();
30939 (arg1)->SetToolTip((wxString const &)*arg2);
30940
30941 wxPyEndAllowThreads(__tstate);
30942 if (PyErr_Occurred()) SWIG_fail;
30943 }
30944 Py_INCREF(Py_None); resultobj = Py_None;
30945 {
30946 if (temp2)
30947 delete arg2;
30948 }
30949 return resultobj;
30950 fail:
30951 {
30952 if (temp2)
30953 delete arg2;
30954 }
30955 return NULL;
30956 }
30957
30958
30959 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
30960 PyObject *resultobj;
30961 wxWindow *arg1 = (wxWindow *) 0 ;
30962 wxToolTip *arg2 = (wxToolTip *) 0 ;
30963 PyObject * obj0 = 0 ;
30964 PyObject * obj1 = 0 ;
30965 char *kwnames[] = {
30966 (char *) "self",(char *) "tip", NULL
30967 };
30968
30969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
30970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30971 if (SWIG_arg_fail(1)) SWIG_fail;
30972 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
30973 if (SWIG_arg_fail(2)) SWIG_fail;
30974 {
30975 PyThreadState* __tstate = wxPyBeginAllowThreads();
30976 (arg1)->SetToolTip(arg2);
30977
30978 wxPyEndAllowThreads(__tstate);
30979 if (PyErr_Occurred()) SWIG_fail;
30980 }
30981 Py_INCREF(Py_None); resultobj = Py_None;
30982 return resultobj;
30983 fail:
30984 return NULL;
30985 }
30986
30987
30988 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
30989 PyObject *resultobj;
30990 wxWindow *arg1 = (wxWindow *) 0 ;
30991 wxToolTip *result;
30992 PyObject * obj0 = 0 ;
30993 char *kwnames[] = {
30994 (char *) "self", NULL
30995 };
30996
30997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
30998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30999 if (SWIG_arg_fail(1)) SWIG_fail;
31000 {
31001 PyThreadState* __tstate = wxPyBeginAllowThreads();
31002 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31003
31004 wxPyEndAllowThreads(__tstate);
31005 if (PyErr_Occurred()) SWIG_fail;
31006 }
31007 {
31008 resultobj = wxPyMake_wxObject(result, 0);
31009 }
31010 return resultobj;
31011 fail:
31012 return NULL;
31013 }
31014
31015
31016 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31017 PyObject *resultobj;
31018 wxWindow *arg1 = (wxWindow *) 0 ;
31019 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31020 PyObject * obj0 = 0 ;
31021 PyObject * obj1 = 0 ;
31022 char *kwnames[] = {
31023 (char *) "self",(char *) "dropTarget", NULL
31024 };
31025
31026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31028 if (SWIG_arg_fail(1)) SWIG_fail;
31029 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31030 if (SWIG_arg_fail(2)) SWIG_fail;
31031 {
31032 PyThreadState* __tstate = wxPyBeginAllowThreads();
31033 (arg1)->SetDropTarget(arg2);
31034
31035 wxPyEndAllowThreads(__tstate);
31036 if (PyErr_Occurred()) SWIG_fail;
31037 }
31038 Py_INCREF(Py_None); resultobj = Py_None;
31039 return resultobj;
31040 fail:
31041 return NULL;
31042 }
31043
31044
31045 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31046 PyObject *resultobj;
31047 wxWindow *arg1 = (wxWindow *) 0 ;
31048 wxPyDropTarget *result;
31049 PyObject * obj0 = 0 ;
31050 char *kwnames[] = {
31051 (char *) "self", NULL
31052 };
31053
31054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31056 if (SWIG_arg_fail(1)) SWIG_fail;
31057 {
31058 PyThreadState* __tstate = wxPyBeginAllowThreads();
31059 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31060
31061 wxPyEndAllowThreads(__tstate);
31062 if (PyErr_Occurred()) SWIG_fail;
31063 }
31064 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31065 return resultobj;
31066 fail:
31067 return NULL;
31068 }
31069
31070
31071 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31072 PyObject *resultobj;
31073 wxWindow *arg1 = (wxWindow *) 0 ;
31074 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31075 PyObject * obj0 = 0 ;
31076 PyObject * obj1 = 0 ;
31077 char *kwnames[] = {
31078 (char *) "self",(char *) "constraints", NULL
31079 };
31080
31081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31083 if (SWIG_arg_fail(1)) SWIG_fail;
31084 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31085 if (SWIG_arg_fail(2)) SWIG_fail;
31086 {
31087 PyThreadState* __tstate = wxPyBeginAllowThreads();
31088 (arg1)->SetConstraints(arg2);
31089
31090 wxPyEndAllowThreads(__tstate);
31091 if (PyErr_Occurred()) SWIG_fail;
31092 }
31093 Py_INCREF(Py_None); resultobj = Py_None;
31094 return resultobj;
31095 fail:
31096 return NULL;
31097 }
31098
31099
31100 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31101 PyObject *resultobj;
31102 wxWindow *arg1 = (wxWindow *) 0 ;
31103 wxLayoutConstraints *result;
31104 PyObject * obj0 = 0 ;
31105 char *kwnames[] = {
31106 (char *) "self", NULL
31107 };
31108
31109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31111 if (SWIG_arg_fail(1)) SWIG_fail;
31112 {
31113 PyThreadState* __tstate = wxPyBeginAllowThreads();
31114 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31115
31116 wxPyEndAllowThreads(__tstate);
31117 if (PyErr_Occurred()) SWIG_fail;
31118 }
31119 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31120 return resultobj;
31121 fail:
31122 return NULL;
31123 }
31124
31125
31126 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31127 PyObject *resultobj;
31128 wxWindow *arg1 = (wxWindow *) 0 ;
31129 bool arg2 ;
31130 PyObject * obj0 = 0 ;
31131 PyObject * obj1 = 0 ;
31132 char *kwnames[] = {
31133 (char *) "self",(char *) "autoLayout", NULL
31134 };
31135
31136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31138 if (SWIG_arg_fail(1)) SWIG_fail;
31139 {
31140 arg2 = (bool)(SWIG_As_bool(obj1));
31141 if (SWIG_arg_fail(2)) SWIG_fail;
31142 }
31143 {
31144 PyThreadState* __tstate = wxPyBeginAllowThreads();
31145 (arg1)->SetAutoLayout(arg2);
31146
31147 wxPyEndAllowThreads(__tstate);
31148 if (PyErr_Occurred()) SWIG_fail;
31149 }
31150 Py_INCREF(Py_None); resultobj = Py_None;
31151 return resultobj;
31152 fail:
31153 return NULL;
31154 }
31155
31156
31157 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31158 PyObject *resultobj;
31159 wxWindow *arg1 = (wxWindow *) 0 ;
31160 bool result;
31161 PyObject * obj0 = 0 ;
31162 char *kwnames[] = {
31163 (char *) "self", NULL
31164 };
31165
31166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31168 if (SWIG_arg_fail(1)) SWIG_fail;
31169 {
31170 PyThreadState* __tstate = wxPyBeginAllowThreads();
31171 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31172
31173 wxPyEndAllowThreads(__tstate);
31174 if (PyErr_Occurred()) SWIG_fail;
31175 }
31176 {
31177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31178 }
31179 return resultobj;
31180 fail:
31181 return NULL;
31182 }
31183
31184
31185 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31186 PyObject *resultobj;
31187 wxWindow *arg1 = (wxWindow *) 0 ;
31188 bool result;
31189 PyObject * obj0 = 0 ;
31190 char *kwnames[] = {
31191 (char *) "self", NULL
31192 };
31193
31194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31196 if (SWIG_arg_fail(1)) SWIG_fail;
31197 {
31198 PyThreadState* __tstate = wxPyBeginAllowThreads();
31199 result = (bool)(arg1)->Layout();
31200
31201 wxPyEndAllowThreads(__tstate);
31202 if (PyErr_Occurred()) SWIG_fail;
31203 }
31204 {
31205 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31206 }
31207 return resultobj;
31208 fail:
31209 return NULL;
31210 }
31211
31212
31213 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31214 PyObject *resultobj;
31215 wxWindow *arg1 = (wxWindow *) 0 ;
31216 wxSizer *arg2 = (wxSizer *) 0 ;
31217 bool arg3 = (bool) true ;
31218 PyObject * obj0 = 0 ;
31219 PyObject * obj1 = 0 ;
31220 PyObject * obj2 = 0 ;
31221 char *kwnames[] = {
31222 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31223 };
31224
31225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31227 if (SWIG_arg_fail(1)) SWIG_fail;
31228 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31229 if (SWIG_arg_fail(2)) SWIG_fail;
31230 if (obj2) {
31231 {
31232 arg3 = (bool)(SWIG_As_bool(obj2));
31233 if (SWIG_arg_fail(3)) SWIG_fail;
31234 }
31235 }
31236 {
31237 PyThreadState* __tstate = wxPyBeginAllowThreads();
31238 (arg1)->SetSizer(arg2,arg3);
31239
31240 wxPyEndAllowThreads(__tstate);
31241 if (PyErr_Occurred()) SWIG_fail;
31242 }
31243 Py_INCREF(Py_None); resultobj = Py_None;
31244 return resultobj;
31245 fail:
31246 return NULL;
31247 }
31248
31249
31250 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31251 PyObject *resultobj;
31252 wxWindow *arg1 = (wxWindow *) 0 ;
31253 wxSizer *arg2 = (wxSizer *) 0 ;
31254 bool arg3 = (bool) true ;
31255 PyObject * obj0 = 0 ;
31256 PyObject * obj1 = 0 ;
31257 PyObject * obj2 = 0 ;
31258 char *kwnames[] = {
31259 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31260 };
31261
31262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31264 if (SWIG_arg_fail(1)) SWIG_fail;
31265 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31266 if (SWIG_arg_fail(2)) SWIG_fail;
31267 if (obj2) {
31268 {
31269 arg3 = (bool)(SWIG_As_bool(obj2));
31270 if (SWIG_arg_fail(3)) SWIG_fail;
31271 }
31272 }
31273 {
31274 PyThreadState* __tstate = wxPyBeginAllowThreads();
31275 (arg1)->SetSizerAndFit(arg2,arg3);
31276
31277 wxPyEndAllowThreads(__tstate);
31278 if (PyErr_Occurred()) SWIG_fail;
31279 }
31280 Py_INCREF(Py_None); resultobj = Py_None;
31281 return resultobj;
31282 fail:
31283 return NULL;
31284 }
31285
31286
31287 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31288 PyObject *resultobj;
31289 wxWindow *arg1 = (wxWindow *) 0 ;
31290 wxSizer *result;
31291 PyObject * obj0 = 0 ;
31292 char *kwnames[] = {
31293 (char *) "self", NULL
31294 };
31295
31296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31298 if (SWIG_arg_fail(1)) SWIG_fail;
31299 {
31300 PyThreadState* __tstate = wxPyBeginAllowThreads();
31301 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31302
31303 wxPyEndAllowThreads(__tstate);
31304 if (PyErr_Occurred()) SWIG_fail;
31305 }
31306 {
31307 resultobj = wxPyMake_wxSizer(result, 0);
31308 }
31309 return resultobj;
31310 fail:
31311 return NULL;
31312 }
31313
31314
31315 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31316 PyObject *resultobj;
31317 wxWindow *arg1 = (wxWindow *) 0 ;
31318 wxSizer *arg2 = (wxSizer *) 0 ;
31319 PyObject * obj0 = 0 ;
31320 PyObject * obj1 = 0 ;
31321 char *kwnames[] = {
31322 (char *) "self",(char *) "sizer", NULL
31323 };
31324
31325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31327 if (SWIG_arg_fail(1)) SWIG_fail;
31328 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31329 if (SWIG_arg_fail(2)) SWIG_fail;
31330 {
31331 PyThreadState* __tstate = wxPyBeginAllowThreads();
31332 (arg1)->SetContainingSizer(arg2);
31333
31334 wxPyEndAllowThreads(__tstate);
31335 if (PyErr_Occurred()) SWIG_fail;
31336 }
31337 Py_INCREF(Py_None); resultobj = Py_None;
31338 return resultobj;
31339 fail:
31340 return NULL;
31341 }
31342
31343
31344 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31345 PyObject *resultobj;
31346 wxWindow *arg1 = (wxWindow *) 0 ;
31347 wxSizer *result;
31348 PyObject * obj0 = 0 ;
31349 char *kwnames[] = {
31350 (char *) "self", NULL
31351 };
31352
31353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
31354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31355 if (SWIG_arg_fail(1)) SWIG_fail;
31356 {
31357 PyThreadState* __tstate = wxPyBeginAllowThreads();
31358 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
31359
31360 wxPyEndAllowThreads(__tstate);
31361 if (PyErr_Occurred()) SWIG_fail;
31362 }
31363 {
31364 resultobj = wxPyMake_wxSizer(result, 0);
31365 }
31366 return resultobj;
31367 fail:
31368 return NULL;
31369 }
31370
31371
31372 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
31373 PyObject *resultobj;
31374 wxWindow *arg1 = (wxWindow *) 0 ;
31375 PyObject * obj0 = 0 ;
31376 char *kwnames[] = {
31377 (char *) "self", NULL
31378 };
31379
31380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
31381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31382 if (SWIG_arg_fail(1)) SWIG_fail;
31383 {
31384 PyThreadState* __tstate = wxPyBeginAllowThreads();
31385 (arg1)->InheritAttributes();
31386
31387 wxPyEndAllowThreads(__tstate);
31388 if (PyErr_Occurred()) SWIG_fail;
31389 }
31390 Py_INCREF(Py_None); resultobj = Py_None;
31391 return resultobj;
31392 fail:
31393 return NULL;
31394 }
31395
31396
31397 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
31398 PyObject *resultobj;
31399 wxWindow *arg1 = (wxWindow *) 0 ;
31400 bool result;
31401 PyObject * obj0 = 0 ;
31402 char *kwnames[] = {
31403 (char *) "self", NULL
31404 };
31405
31406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
31407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31408 if (SWIG_arg_fail(1)) SWIG_fail;
31409 {
31410 PyThreadState* __tstate = wxPyBeginAllowThreads();
31411 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
31412
31413 wxPyEndAllowThreads(__tstate);
31414 if (PyErr_Occurred()) SWIG_fail;
31415 }
31416 {
31417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31418 }
31419 return resultobj;
31420 fail:
31421 return NULL;
31422 }
31423
31424
31425 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
31426 PyObject *obj;
31427 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31428 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
31429 Py_INCREF(obj);
31430 return Py_BuildValue((char *)"");
31431 }
31432 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
31433 PyObject *resultobj;
31434 long arg1 ;
31435 wxWindow *arg2 = (wxWindow *) NULL ;
31436 wxWindow *result;
31437 PyObject * obj0 = 0 ;
31438 PyObject * obj1 = 0 ;
31439 char *kwnames[] = {
31440 (char *) "id",(char *) "parent", NULL
31441 };
31442
31443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
31444 {
31445 arg1 = (long)(SWIG_As_long(obj0));
31446 if (SWIG_arg_fail(1)) SWIG_fail;
31447 }
31448 if (obj1) {
31449 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31450 if (SWIG_arg_fail(2)) SWIG_fail;
31451 }
31452 {
31453 if (!wxPyCheckForApp()) SWIG_fail;
31454 PyThreadState* __tstate = wxPyBeginAllowThreads();
31455 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
31456
31457 wxPyEndAllowThreads(__tstate);
31458 if (PyErr_Occurred()) SWIG_fail;
31459 }
31460 {
31461 resultobj = wxPyMake_wxObject(result, 0);
31462 }
31463 return resultobj;
31464 fail:
31465 return NULL;
31466 }
31467
31468
31469 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
31470 PyObject *resultobj;
31471 wxString *arg1 = 0 ;
31472 wxWindow *arg2 = (wxWindow *) NULL ;
31473 wxWindow *result;
31474 bool temp1 = false ;
31475 PyObject * obj0 = 0 ;
31476 PyObject * obj1 = 0 ;
31477 char *kwnames[] = {
31478 (char *) "name",(char *) "parent", NULL
31479 };
31480
31481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
31482 {
31483 arg1 = wxString_in_helper(obj0);
31484 if (arg1 == NULL) SWIG_fail;
31485 temp1 = true;
31486 }
31487 if (obj1) {
31488 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31489 if (SWIG_arg_fail(2)) SWIG_fail;
31490 }
31491 {
31492 if (!wxPyCheckForApp()) SWIG_fail;
31493 PyThreadState* __tstate = wxPyBeginAllowThreads();
31494 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
31495
31496 wxPyEndAllowThreads(__tstate);
31497 if (PyErr_Occurred()) SWIG_fail;
31498 }
31499 {
31500 resultobj = wxPyMake_wxObject(result, 0);
31501 }
31502 {
31503 if (temp1)
31504 delete arg1;
31505 }
31506 return resultobj;
31507 fail:
31508 {
31509 if (temp1)
31510 delete arg1;
31511 }
31512 return NULL;
31513 }
31514
31515
31516 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
31517 PyObject *resultobj;
31518 wxString *arg1 = 0 ;
31519 wxWindow *arg2 = (wxWindow *) NULL ;
31520 wxWindow *result;
31521 bool temp1 = false ;
31522 PyObject * obj0 = 0 ;
31523 PyObject * obj1 = 0 ;
31524 char *kwnames[] = {
31525 (char *) "label",(char *) "parent", NULL
31526 };
31527
31528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
31529 {
31530 arg1 = wxString_in_helper(obj0);
31531 if (arg1 == NULL) SWIG_fail;
31532 temp1 = true;
31533 }
31534 if (obj1) {
31535 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31536 if (SWIG_arg_fail(2)) SWIG_fail;
31537 }
31538 {
31539 if (!wxPyCheckForApp()) SWIG_fail;
31540 PyThreadState* __tstate = wxPyBeginAllowThreads();
31541 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
31542
31543 wxPyEndAllowThreads(__tstate);
31544 if (PyErr_Occurred()) SWIG_fail;
31545 }
31546 {
31547 resultobj = wxPyMake_wxObject(result, 0);
31548 }
31549 {
31550 if (temp1)
31551 delete arg1;
31552 }
31553 return resultobj;
31554 fail:
31555 {
31556 if (temp1)
31557 delete arg1;
31558 }
31559 return NULL;
31560 }
31561
31562
31563 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
31564 PyObject *resultobj;
31565 wxWindow *arg1 = (wxWindow *) 0 ;
31566 unsigned long arg2 ;
31567 wxWindow *result;
31568 PyObject * obj0 = 0 ;
31569 PyObject * obj1 = 0 ;
31570 char *kwnames[] = {
31571 (char *) "parent",(char *) "_hWnd", NULL
31572 };
31573
31574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
31575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31576 if (SWIG_arg_fail(1)) SWIG_fail;
31577 {
31578 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
31579 if (SWIG_arg_fail(2)) SWIG_fail;
31580 }
31581 {
31582 PyThreadState* __tstate = wxPyBeginAllowThreads();
31583 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
31584
31585 wxPyEndAllowThreads(__tstate);
31586 if (PyErr_Occurred()) SWIG_fail;
31587 }
31588 {
31589 resultobj = wxPyMake_wxObject(result, 0);
31590 }
31591 return resultobj;
31592 fail:
31593 return NULL;
31594 }
31595
31596
31597 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
31598 PyObject *resultobj;
31599 wxValidator *result;
31600 char *kwnames[] = {
31601 NULL
31602 };
31603
31604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
31605 {
31606 PyThreadState* __tstate = wxPyBeginAllowThreads();
31607 result = (wxValidator *)new wxValidator();
31608
31609 wxPyEndAllowThreads(__tstate);
31610 if (PyErr_Occurred()) SWIG_fail;
31611 }
31612 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
31613 return resultobj;
31614 fail:
31615 return NULL;
31616 }
31617
31618
31619 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
31620 PyObject *resultobj;
31621 wxValidator *arg1 = (wxValidator *) 0 ;
31622 wxValidator *result;
31623 PyObject * obj0 = 0 ;
31624 char *kwnames[] = {
31625 (char *) "self", NULL
31626 };
31627
31628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
31629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31630 if (SWIG_arg_fail(1)) SWIG_fail;
31631 {
31632 PyThreadState* __tstate = wxPyBeginAllowThreads();
31633 result = (wxValidator *)(arg1)->Clone();
31634
31635 wxPyEndAllowThreads(__tstate);
31636 if (PyErr_Occurred()) SWIG_fail;
31637 }
31638 {
31639 resultobj = wxPyMake_wxObject(result, 0);
31640 }
31641 return resultobj;
31642 fail:
31643 return NULL;
31644 }
31645
31646
31647 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
31648 PyObject *resultobj;
31649 wxValidator *arg1 = (wxValidator *) 0 ;
31650 wxWindow *arg2 = (wxWindow *) 0 ;
31651 bool result;
31652 PyObject * obj0 = 0 ;
31653 PyObject * obj1 = 0 ;
31654 char *kwnames[] = {
31655 (char *) "self",(char *) "parent", NULL
31656 };
31657
31658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
31659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31660 if (SWIG_arg_fail(1)) SWIG_fail;
31661 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31662 if (SWIG_arg_fail(2)) SWIG_fail;
31663 {
31664 PyThreadState* __tstate = wxPyBeginAllowThreads();
31665 result = (bool)(arg1)->Validate(arg2);
31666
31667 wxPyEndAllowThreads(__tstate);
31668 if (PyErr_Occurred()) SWIG_fail;
31669 }
31670 {
31671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31672 }
31673 return resultobj;
31674 fail:
31675 return NULL;
31676 }
31677
31678
31679 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31680 PyObject *resultobj;
31681 wxValidator *arg1 = (wxValidator *) 0 ;
31682 bool result;
31683 PyObject * obj0 = 0 ;
31684 char *kwnames[] = {
31685 (char *) "self", NULL
31686 };
31687
31688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
31689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31690 if (SWIG_arg_fail(1)) SWIG_fail;
31691 {
31692 PyThreadState* __tstate = wxPyBeginAllowThreads();
31693 result = (bool)(arg1)->TransferToWindow();
31694
31695 wxPyEndAllowThreads(__tstate);
31696 if (PyErr_Occurred()) SWIG_fail;
31697 }
31698 {
31699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31700 }
31701 return resultobj;
31702 fail:
31703 return NULL;
31704 }
31705
31706
31707 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31708 PyObject *resultobj;
31709 wxValidator *arg1 = (wxValidator *) 0 ;
31710 bool result;
31711 PyObject * obj0 = 0 ;
31712 char *kwnames[] = {
31713 (char *) "self", NULL
31714 };
31715
31716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
31717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31718 if (SWIG_arg_fail(1)) SWIG_fail;
31719 {
31720 PyThreadState* __tstate = wxPyBeginAllowThreads();
31721 result = (bool)(arg1)->TransferFromWindow();
31722
31723 wxPyEndAllowThreads(__tstate);
31724 if (PyErr_Occurred()) SWIG_fail;
31725 }
31726 {
31727 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31728 }
31729 return resultobj;
31730 fail:
31731 return NULL;
31732 }
31733
31734
31735 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31736 PyObject *resultobj;
31737 wxValidator *arg1 = (wxValidator *) 0 ;
31738 wxWindow *result;
31739 PyObject * obj0 = 0 ;
31740 char *kwnames[] = {
31741 (char *) "self", NULL
31742 };
31743
31744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
31745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31746 if (SWIG_arg_fail(1)) SWIG_fail;
31747 {
31748 PyThreadState* __tstate = wxPyBeginAllowThreads();
31749 result = (wxWindow *)(arg1)->GetWindow();
31750
31751 wxPyEndAllowThreads(__tstate);
31752 if (PyErr_Occurred()) SWIG_fail;
31753 }
31754 {
31755 resultobj = wxPyMake_wxObject(result, 0);
31756 }
31757 return resultobj;
31758 fail:
31759 return NULL;
31760 }
31761
31762
31763 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31764 PyObject *resultobj;
31765 wxValidator *arg1 = (wxValidator *) 0 ;
31766 wxWindow *arg2 = (wxWindow *) 0 ;
31767 PyObject * obj0 = 0 ;
31768 PyObject * obj1 = 0 ;
31769 char *kwnames[] = {
31770 (char *) "self",(char *) "window", NULL
31771 };
31772
31773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
31774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
31775 if (SWIG_arg_fail(1)) SWIG_fail;
31776 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31777 if (SWIG_arg_fail(2)) SWIG_fail;
31778 {
31779 PyThreadState* __tstate = wxPyBeginAllowThreads();
31780 (arg1)->SetWindow(arg2);
31781
31782 wxPyEndAllowThreads(__tstate);
31783 if (PyErr_Occurred()) SWIG_fail;
31784 }
31785 Py_INCREF(Py_None); resultobj = Py_None;
31786 return resultobj;
31787 fail:
31788 return NULL;
31789 }
31790
31791
31792 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
31793 PyObject *resultobj;
31794 bool result;
31795 char *kwnames[] = {
31796 NULL
31797 };
31798
31799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
31800 {
31801 PyThreadState* __tstate = wxPyBeginAllowThreads();
31802 result = (bool)wxValidator::IsSilent();
31803
31804 wxPyEndAllowThreads(__tstate);
31805 if (PyErr_Occurred()) SWIG_fail;
31806 }
31807 {
31808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31809 }
31810 return resultobj;
31811 fail:
31812 return NULL;
31813 }
31814
31815
31816 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
31817 PyObject *resultobj;
31818 int arg1 = (int) true ;
31819 PyObject * obj0 = 0 ;
31820 char *kwnames[] = {
31821 (char *) "doIt", NULL
31822 };
31823
31824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
31825 if (obj0) {
31826 {
31827 arg1 = (int)(SWIG_As_int(obj0));
31828 if (SWIG_arg_fail(1)) SWIG_fail;
31829 }
31830 }
31831 {
31832 PyThreadState* __tstate = wxPyBeginAllowThreads();
31833 wxValidator::SetBellOnError(arg1);
31834
31835 wxPyEndAllowThreads(__tstate);
31836 if (PyErr_Occurred()) SWIG_fail;
31837 }
31838 Py_INCREF(Py_None); resultobj = Py_None;
31839 return resultobj;
31840 fail:
31841 return NULL;
31842 }
31843
31844
31845 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
31846 PyObject *obj;
31847 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31848 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
31849 Py_INCREF(obj);
31850 return Py_BuildValue((char *)"");
31851 }
31852 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
31853 PyObject *resultobj;
31854 wxPyValidator *result;
31855 char *kwnames[] = {
31856 NULL
31857 };
31858
31859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
31860 {
31861 PyThreadState* __tstate = wxPyBeginAllowThreads();
31862 result = (wxPyValidator *)new wxPyValidator();
31863
31864 wxPyEndAllowThreads(__tstate);
31865 if (PyErr_Occurred()) SWIG_fail;
31866 }
31867 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
31868 return resultobj;
31869 fail:
31870 return NULL;
31871 }
31872
31873
31874 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
31875 PyObject *resultobj;
31876 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
31877 PyObject *arg2 = (PyObject *) 0 ;
31878 PyObject *arg3 = (PyObject *) 0 ;
31879 int arg4 = (int) true ;
31880 PyObject * obj0 = 0 ;
31881 PyObject * obj1 = 0 ;
31882 PyObject * obj2 = 0 ;
31883 PyObject * obj3 = 0 ;
31884 char *kwnames[] = {
31885 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
31886 };
31887
31888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
31890 if (SWIG_arg_fail(1)) SWIG_fail;
31891 arg2 = obj1;
31892 arg3 = obj2;
31893 if (obj3) {
31894 {
31895 arg4 = (int)(SWIG_As_int(obj3));
31896 if (SWIG_arg_fail(4)) SWIG_fail;
31897 }
31898 }
31899 {
31900 PyThreadState* __tstate = wxPyBeginAllowThreads();
31901 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
31902
31903 wxPyEndAllowThreads(__tstate);
31904 if (PyErr_Occurred()) SWIG_fail;
31905 }
31906 Py_INCREF(Py_None); resultobj = Py_None;
31907 return resultobj;
31908 fail:
31909 return NULL;
31910 }
31911
31912
31913 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
31914 PyObject *obj;
31915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
31916 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
31917 Py_INCREF(obj);
31918 return Py_BuildValue((char *)"");
31919 }
31920 static int _wrap_DefaultValidator_set(PyObject *) {
31921 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
31922 return 1;
31923 }
31924
31925
31926 static PyObject *_wrap_DefaultValidator_get(void) {
31927 PyObject *pyobj;
31928
31929 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
31930 return pyobj;
31931 }
31932
31933
31934 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
31935 PyObject *resultobj;
31936 wxString const &arg1_defvalue = wxPyEmptyString ;
31937 wxString *arg1 = (wxString *) &arg1_defvalue ;
31938 long arg2 = (long) 0 ;
31939 wxMenu *result;
31940 bool temp1 = false ;
31941 PyObject * obj0 = 0 ;
31942 PyObject * obj1 = 0 ;
31943 char *kwnames[] = {
31944 (char *) "title",(char *) "style", NULL
31945 };
31946
31947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
31948 if (obj0) {
31949 {
31950 arg1 = wxString_in_helper(obj0);
31951 if (arg1 == NULL) SWIG_fail;
31952 temp1 = true;
31953 }
31954 }
31955 if (obj1) {
31956 {
31957 arg2 = (long)(SWIG_As_long(obj1));
31958 if (SWIG_arg_fail(2)) SWIG_fail;
31959 }
31960 }
31961 {
31962 if (!wxPyCheckForApp()) SWIG_fail;
31963 PyThreadState* __tstate = wxPyBeginAllowThreads();
31964 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
31965
31966 wxPyEndAllowThreads(__tstate);
31967 if (PyErr_Occurred()) SWIG_fail;
31968 }
31969 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
31970 {
31971 if (temp1)
31972 delete arg1;
31973 }
31974 return resultobj;
31975 fail:
31976 {
31977 if (temp1)
31978 delete arg1;
31979 }
31980 return NULL;
31981 }
31982
31983
31984 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
31985 PyObject *resultobj;
31986 wxMenu *arg1 = (wxMenu *) 0 ;
31987 int arg2 ;
31988 wxString *arg3 = 0 ;
31989 wxString const &arg4_defvalue = wxPyEmptyString ;
31990 wxString *arg4 = (wxString *) &arg4_defvalue ;
31991 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
31992 wxMenuItem *result;
31993 bool temp3 = false ;
31994 bool temp4 = false ;
31995 PyObject * obj0 = 0 ;
31996 PyObject * obj1 = 0 ;
31997 PyObject * obj2 = 0 ;
31998 PyObject * obj3 = 0 ;
31999 PyObject * obj4 = 0 ;
32000 char *kwnames[] = {
32001 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32002 };
32003
32004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32006 if (SWIG_arg_fail(1)) SWIG_fail;
32007 {
32008 arg2 = (int)(SWIG_As_int(obj1));
32009 if (SWIG_arg_fail(2)) SWIG_fail;
32010 }
32011 {
32012 arg3 = wxString_in_helper(obj2);
32013 if (arg3 == NULL) SWIG_fail;
32014 temp3 = true;
32015 }
32016 if (obj3) {
32017 {
32018 arg4 = wxString_in_helper(obj3);
32019 if (arg4 == NULL) SWIG_fail;
32020 temp4 = true;
32021 }
32022 }
32023 if (obj4) {
32024 {
32025 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32026 if (SWIG_arg_fail(5)) SWIG_fail;
32027 }
32028 }
32029 {
32030 PyThreadState* __tstate = wxPyBeginAllowThreads();
32031 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32032
32033 wxPyEndAllowThreads(__tstate);
32034 if (PyErr_Occurred()) SWIG_fail;
32035 }
32036 {
32037 resultobj = wxPyMake_wxObject(result, 0);
32038 }
32039 {
32040 if (temp3)
32041 delete arg3;
32042 }
32043 {
32044 if (temp4)
32045 delete arg4;
32046 }
32047 return resultobj;
32048 fail:
32049 {
32050 if (temp3)
32051 delete arg3;
32052 }
32053 {
32054 if (temp4)
32055 delete arg4;
32056 }
32057 return NULL;
32058 }
32059
32060
32061 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32062 PyObject *resultobj;
32063 wxMenu *arg1 = (wxMenu *) 0 ;
32064 wxMenuItem *result;
32065 PyObject * obj0 = 0 ;
32066 char *kwnames[] = {
32067 (char *) "self", NULL
32068 };
32069
32070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32072 if (SWIG_arg_fail(1)) SWIG_fail;
32073 {
32074 PyThreadState* __tstate = wxPyBeginAllowThreads();
32075 result = (wxMenuItem *)(arg1)->AppendSeparator();
32076
32077 wxPyEndAllowThreads(__tstate);
32078 if (PyErr_Occurred()) SWIG_fail;
32079 }
32080 {
32081 resultobj = wxPyMake_wxObject(result, 0);
32082 }
32083 return resultobj;
32084 fail:
32085 return NULL;
32086 }
32087
32088
32089 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32090 PyObject *resultobj;
32091 wxMenu *arg1 = (wxMenu *) 0 ;
32092 int arg2 ;
32093 wxString *arg3 = 0 ;
32094 wxString const &arg4_defvalue = wxPyEmptyString ;
32095 wxString *arg4 = (wxString *) &arg4_defvalue ;
32096 wxMenuItem *result;
32097 bool temp3 = false ;
32098 bool temp4 = false ;
32099 PyObject * obj0 = 0 ;
32100 PyObject * obj1 = 0 ;
32101 PyObject * obj2 = 0 ;
32102 PyObject * obj3 = 0 ;
32103 char *kwnames[] = {
32104 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32105 };
32106
32107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32109 if (SWIG_arg_fail(1)) SWIG_fail;
32110 {
32111 arg2 = (int)(SWIG_As_int(obj1));
32112 if (SWIG_arg_fail(2)) SWIG_fail;
32113 }
32114 {
32115 arg3 = wxString_in_helper(obj2);
32116 if (arg3 == NULL) SWIG_fail;
32117 temp3 = true;
32118 }
32119 if (obj3) {
32120 {
32121 arg4 = wxString_in_helper(obj3);
32122 if (arg4 == NULL) SWIG_fail;
32123 temp4 = true;
32124 }
32125 }
32126 {
32127 PyThreadState* __tstate = wxPyBeginAllowThreads();
32128 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32129
32130 wxPyEndAllowThreads(__tstate);
32131 if (PyErr_Occurred()) SWIG_fail;
32132 }
32133 {
32134 resultobj = wxPyMake_wxObject(result, 0);
32135 }
32136 {
32137 if (temp3)
32138 delete arg3;
32139 }
32140 {
32141 if (temp4)
32142 delete arg4;
32143 }
32144 return resultobj;
32145 fail:
32146 {
32147 if (temp3)
32148 delete arg3;
32149 }
32150 {
32151 if (temp4)
32152 delete arg4;
32153 }
32154 return NULL;
32155 }
32156
32157
32158 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32159 PyObject *resultobj;
32160 wxMenu *arg1 = (wxMenu *) 0 ;
32161 int arg2 ;
32162 wxString *arg3 = 0 ;
32163 wxString const &arg4_defvalue = wxPyEmptyString ;
32164 wxString *arg4 = (wxString *) &arg4_defvalue ;
32165 wxMenuItem *result;
32166 bool temp3 = false ;
32167 bool temp4 = false ;
32168 PyObject * obj0 = 0 ;
32169 PyObject * obj1 = 0 ;
32170 PyObject * obj2 = 0 ;
32171 PyObject * obj3 = 0 ;
32172 char *kwnames[] = {
32173 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32174 };
32175
32176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32178 if (SWIG_arg_fail(1)) SWIG_fail;
32179 {
32180 arg2 = (int)(SWIG_As_int(obj1));
32181 if (SWIG_arg_fail(2)) SWIG_fail;
32182 }
32183 {
32184 arg3 = wxString_in_helper(obj2);
32185 if (arg3 == NULL) SWIG_fail;
32186 temp3 = true;
32187 }
32188 if (obj3) {
32189 {
32190 arg4 = wxString_in_helper(obj3);
32191 if (arg4 == NULL) SWIG_fail;
32192 temp4 = true;
32193 }
32194 }
32195 {
32196 PyThreadState* __tstate = wxPyBeginAllowThreads();
32197 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32198
32199 wxPyEndAllowThreads(__tstate);
32200 if (PyErr_Occurred()) SWIG_fail;
32201 }
32202 {
32203 resultobj = wxPyMake_wxObject(result, 0);
32204 }
32205 {
32206 if (temp3)
32207 delete arg3;
32208 }
32209 {
32210 if (temp4)
32211 delete arg4;
32212 }
32213 return resultobj;
32214 fail:
32215 {
32216 if (temp3)
32217 delete arg3;
32218 }
32219 {
32220 if (temp4)
32221 delete arg4;
32222 }
32223 return NULL;
32224 }
32225
32226
32227 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32228 PyObject *resultobj;
32229 wxMenu *arg1 = (wxMenu *) 0 ;
32230 int arg2 ;
32231 wxString *arg3 = 0 ;
32232 wxMenu *arg4 = (wxMenu *) 0 ;
32233 wxString const &arg5_defvalue = wxPyEmptyString ;
32234 wxString *arg5 = (wxString *) &arg5_defvalue ;
32235 wxMenuItem *result;
32236 bool temp3 = false ;
32237 bool temp5 = false ;
32238 PyObject * obj0 = 0 ;
32239 PyObject * obj1 = 0 ;
32240 PyObject * obj2 = 0 ;
32241 PyObject * obj3 = 0 ;
32242 PyObject * obj4 = 0 ;
32243 char *kwnames[] = {
32244 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32245 };
32246
32247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32249 if (SWIG_arg_fail(1)) SWIG_fail;
32250 {
32251 arg2 = (int)(SWIG_As_int(obj1));
32252 if (SWIG_arg_fail(2)) SWIG_fail;
32253 }
32254 {
32255 arg3 = wxString_in_helper(obj2);
32256 if (arg3 == NULL) SWIG_fail;
32257 temp3 = true;
32258 }
32259 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32260 if (SWIG_arg_fail(4)) SWIG_fail;
32261 if (obj4) {
32262 {
32263 arg5 = wxString_in_helper(obj4);
32264 if (arg5 == NULL) SWIG_fail;
32265 temp5 = true;
32266 }
32267 }
32268 {
32269 PyThreadState* __tstate = wxPyBeginAllowThreads();
32270 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32271
32272 wxPyEndAllowThreads(__tstate);
32273 if (PyErr_Occurred()) SWIG_fail;
32274 }
32275 {
32276 resultobj = wxPyMake_wxObject(result, 0);
32277 }
32278 {
32279 if (temp3)
32280 delete arg3;
32281 }
32282 {
32283 if (temp5)
32284 delete arg5;
32285 }
32286 return resultobj;
32287 fail:
32288 {
32289 if (temp3)
32290 delete arg3;
32291 }
32292 {
32293 if (temp5)
32294 delete arg5;
32295 }
32296 return NULL;
32297 }
32298
32299
32300 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32301 PyObject *resultobj;
32302 wxMenu *arg1 = (wxMenu *) 0 ;
32303 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32304 wxMenuItem *result;
32305 PyObject * obj0 = 0 ;
32306 PyObject * obj1 = 0 ;
32307 char *kwnames[] = {
32308 (char *) "self",(char *) "item", NULL
32309 };
32310
32311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32313 if (SWIG_arg_fail(1)) SWIG_fail;
32314 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32315 if (SWIG_arg_fail(2)) SWIG_fail;
32316 {
32317 PyThreadState* __tstate = wxPyBeginAllowThreads();
32318 result = (wxMenuItem *)(arg1)->Append(arg2);
32319
32320 wxPyEndAllowThreads(__tstate);
32321 if (PyErr_Occurred()) SWIG_fail;
32322 }
32323 {
32324 resultobj = wxPyMake_wxObject(result, 0);
32325 }
32326 return resultobj;
32327 fail:
32328 return NULL;
32329 }
32330
32331
32332 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32333 PyObject *resultobj;
32334 wxMenu *arg1 = (wxMenu *) 0 ;
32335 PyObject * obj0 = 0 ;
32336 char *kwnames[] = {
32337 (char *) "self", NULL
32338 };
32339
32340 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32342 if (SWIG_arg_fail(1)) SWIG_fail;
32343 {
32344 PyThreadState* __tstate = wxPyBeginAllowThreads();
32345 (arg1)->Break();
32346
32347 wxPyEndAllowThreads(__tstate);
32348 if (PyErr_Occurred()) SWIG_fail;
32349 }
32350 Py_INCREF(Py_None); resultobj = Py_None;
32351 return resultobj;
32352 fail:
32353 return NULL;
32354 }
32355
32356
32357 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
32358 PyObject *resultobj;
32359 wxMenu *arg1 = (wxMenu *) 0 ;
32360 size_t arg2 ;
32361 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
32362 wxMenuItem *result;
32363 PyObject * obj0 = 0 ;
32364 PyObject * obj1 = 0 ;
32365 PyObject * obj2 = 0 ;
32366 char *kwnames[] = {
32367 (char *) "self",(char *) "pos",(char *) "item", NULL
32368 };
32369
32370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
32371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32372 if (SWIG_arg_fail(1)) SWIG_fail;
32373 {
32374 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32375 if (SWIG_arg_fail(2)) SWIG_fail;
32376 }
32377 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32378 if (SWIG_arg_fail(3)) SWIG_fail;
32379 {
32380 PyThreadState* __tstate = wxPyBeginAllowThreads();
32381 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
32382
32383 wxPyEndAllowThreads(__tstate);
32384 if (PyErr_Occurred()) SWIG_fail;
32385 }
32386 {
32387 resultobj = wxPyMake_wxObject(result, 0);
32388 }
32389 return resultobj;
32390 fail:
32391 return NULL;
32392 }
32393
32394
32395 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
32396 PyObject *resultobj;
32397 wxMenu *arg1 = (wxMenu *) 0 ;
32398 size_t arg2 ;
32399 int arg3 ;
32400 wxString *arg4 = 0 ;
32401 wxString const &arg5_defvalue = wxPyEmptyString ;
32402 wxString *arg5 = (wxString *) &arg5_defvalue ;
32403 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
32404 wxMenuItem *result;
32405 bool temp4 = false ;
32406 bool temp5 = false ;
32407 PyObject * obj0 = 0 ;
32408 PyObject * obj1 = 0 ;
32409 PyObject * obj2 = 0 ;
32410 PyObject * obj3 = 0 ;
32411 PyObject * obj4 = 0 ;
32412 PyObject * obj5 = 0 ;
32413 char *kwnames[] = {
32414 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32415 };
32416
32417 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32418 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32419 if (SWIG_arg_fail(1)) SWIG_fail;
32420 {
32421 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32422 if (SWIG_arg_fail(2)) SWIG_fail;
32423 }
32424 {
32425 arg3 = (int)(SWIG_As_int(obj2));
32426 if (SWIG_arg_fail(3)) SWIG_fail;
32427 }
32428 {
32429 arg4 = wxString_in_helper(obj3);
32430 if (arg4 == NULL) SWIG_fail;
32431 temp4 = true;
32432 }
32433 if (obj4) {
32434 {
32435 arg5 = wxString_in_helper(obj4);
32436 if (arg5 == NULL) SWIG_fail;
32437 temp5 = true;
32438 }
32439 }
32440 if (obj5) {
32441 {
32442 arg6 = (wxItemKind)(SWIG_As_int(obj5));
32443 if (SWIG_arg_fail(6)) SWIG_fail;
32444 }
32445 }
32446 {
32447 PyThreadState* __tstate = wxPyBeginAllowThreads();
32448 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
32449
32450 wxPyEndAllowThreads(__tstate);
32451 if (PyErr_Occurred()) SWIG_fail;
32452 }
32453 {
32454 resultobj = wxPyMake_wxObject(result, 0);
32455 }
32456 {
32457 if (temp4)
32458 delete arg4;
32459 }
32460 {
32461 if (temp5)
32462 delete arg5;
32463 }
32464 return resultobj;
32465 fail:
32466 {
32467 if (temp4)
32468 delete arg4;
32469 }
32470 {
32471 if (temp5)
32472 delete arg5;
32473 }
32474 return NULL;
32475 }
32476
32477
32478 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32479 PyObject *resultobj;
32480 wxMenu *arg1 = (wxMenu *) 0 ;
32481 size_t arg2 ;
32482 wxMenuItem *result;
32483 PyObject * obj0 = 0 ;
32484 PyObject * obj1 = 0 ;
32485 char *kwnames[] = {
32486 (char *) "self",(char *) "pos", NULL
32487 };
32488
32489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
32490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32491 if (SWIG_arg_fail(1)) SWIG_fail;
32492 {
32493 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32494 if (SWIG_arg_fail(2)) SWIG_fail;
32495 }
32496 {
32497 PyThreadState* __tstate = wxPyBeginAllowThreads();
32498 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
32499
32500 wxPyEndAllowThreads(__tstate);
32501 if (PyErr_Occurred()) SWIG_fail;
32502 }
32503 {
32504 resultobj = wxPyMake_wxObject(result, 0);
32505 }
32506 return resultobj;
32507 fail:
32508 return NULL;
32509 }
32510
32511
32512 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32513 PyObject *resultobj;
32514 wxMenu *arg1 = (wxMenu *) 0 ;
32515 size_t arg2 ;
32516 int arg3 ;
32517 wxString *arg4 = 0 ;
32518 wxString const &arg5_defvalue = wxPyEmptyString ;
32519 wxString *arg5 = (wxString *) &arg5_defvalue ;
32520 wxMenuItem *result;
32521 bool temp4 = false ;
32522 bool temp5 = false ;
32523 PyObject * obj0 = 0 ;
32524 PyObject * obj1 = 0 ;
32525 PyObject * obj2 = 0 ;
32526 PyObject * obj3 = 0 ;
32527 PyObject * obj4 = 0 ;
32528 char *kwnames[] = {
32529 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32530 };
32531
32532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32534 if (SWIG_arg_fail(1)) SWIG_fail;
32535 {
32536 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32537 if (SWIG_arg_fail(2)) SWIG_fail;
32538 }
32539 {
32540 arg3 = (int)(SWIG_As_int(obj2));
32541 if (SWIG_arg_fail(3)) SWIG_fail;
32542 }
32543 {
32544 arg4 = wxString_in_helper(obj3);
32545 if (arg4 == NULL) SWIG_fail;
32546 temp4 = true;
32547 }
32548 if (obj4) {
32549 {
32550 arg5 = wxString_in_helper(obj4);
32551 if (arg5 == NULL) SWIG_fail;
32552 temp5 = true;
32553 }
32554 }
32555 {
32556 PyThreadState* __tstate = wxPyBeginAllowThreads();
32557 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32558
32559 wxPyEndAllowThreads(__tstate);
32560 if (PyErr_Occurred()) SWIG_fail;
32561 }
32562 {
32563 resultobj = wxPyMake_wxObject(result, 0);
32564 }
32565 {
32566 if (temp4)
32567 delete arg4;
32568 }
32569 {
32570 if (temp5)
32571 delete arg5;
32572 }
32573 return resultobj;
32574 fail:
32575 {
32576 if (temp4)
32577 delete arg4;
32578 }
32579 {
32580 if (temp5)
32581 delete arg5;
32582 }
32583 return NULL;
32584 }
32585
32586
32587 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32588 PyObject *resultobj;
32589 wxMenu *arg1 = (wxMenu *) 0 ;
32590 size_t arg2 ;
32591 int arg3 ;
32592 wxString *arg4 = 0 ;
32593 wxString const &arg5_defvalue = wxPyEmptyString ;
32594 wxString *arg5 = (wxString *) &arg5_defvalue ;
32595 wxMenuItem *result;
32596 bool temp4 = false ;
32597 bool temp5 = false ;
32598 PyObject * obj0 = 0 ;
32599 PyObject * obj1 = 0 ;
32600 PyObject * obj2 = 0 ;
32601 PyObject * obj3 = 0 ;
32602 PyObject * obj4 = 0 ;
32603 char *kwnames[] = {
32604 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
32605 };
32606
32607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32609 if (SWIG_arg_fail(1)) SWIG_fail;
32610 {
32611 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32612 if (SWIG_arg_fail(2)) SWIG_fail;
32613 }
32614 {
32615 arg3 = (int)(SWIG_As_int(obj2));
32616 if (SWIG_arg_fail(3)) SWIG_fail;
32617 }
32618 {
32619 arg4 = wxString_in_helper(obj3);
32620 if (arg4 == NULL) SWIG_fail;
32621 temp4 = true;
32622 }
32623 if (obj4) {
32624 {
32625 arg5 = wxString_in_helper(obj4);
32626 if (arg5 == NULL) SWIG_fail;
32627 temp5 = true;
32628 }
32629 }
32630 {
32631 PyThreadState* __tstate = wxPyBeginAllowThreads();
32632 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
32633
32634 wxPyEndAllowThreads(__tstate);
32635 if (PyErr_Occurred()) SWIG_fail;
32636 }
32637 {
32638 resultobj = wxPyMake_wxObject(result, 0);
32639 }
32640 {
32641 if (temp4)
32642 delete arg4;
32643 }
32644 {
32645 if (temp5)
32646 delete arg5;
32647 }
32648 return resultobj;
32649 fail:
32650 {
32651 if (temp4)
32652 delete arg4;
32653 }
32654 {
32655 if (temp5)
32656 delete arg5;
32657 }
32658 return NULL;
32659 }
32660
32661
32662 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32663 PyObject *resultobj;
32664 wxMenu *arg1 = (wxMenu *) 0 ;
32665 size_t arg2 ;
32666 int arg3 ;
32667 wxString *arg4 = 0 ;
32668 wxMenu *arg5 = (wxMenu *) 0 ;
32669 wxString const &arg6_defvalue = wxPyEmptyString ;
32670 wxString *arg6 = (wxString *) &arg6_defvalue ;
32671 wxMenuItem *result;
32672 bool temp4 = false ;
32673 bool temp6 = false ;
32674 PyObject * obj0 = 0 ;
32675 PyObject * obj1 = 0 ;
32676 PyObject * obj2 = 0 ;
32677 PyObject * obj3 = 0 ;
32678 PyObject * obj4 = 0 ;
32679 PyObject * obj5 = 0 ;
32680 char *kwnames[] = {
32681 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32682 };
32683
32684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
32685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32686 if (SWIG_arg_fail(1)) SWIG_fail;
32687 {
32688 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
32689 if (SWIG_arg_fail(2)) SWIG_fail;
32690 }
32691 {
32692 arg3 = (int)(SWIG_As_int(obj2));
32693 if (SWIG_arg_fail(3)) SWIG_fail;
32694 }
32695 {
32696 arg4 = wxString_in_helper(obj3);
32697 if (arg4 == NULL) SWIG_fail;
32698 temp4 = true;
32699 }
32700 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32701 if (SWIG_arg_fail(5)) SWIG_fail;
32702 if (obj5) {
32703 {
32704 arg6 = wxString_in_helper(obj5);
32705 if (arg6 == NULL) SWIG_fail;
32706 temp6 = true;
32707 }
32708 }
32709 {
32710 PyThreadState* __tstate = wxPyBeginAllowThreads();
32711 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
32712
32713 wxPyEndAllowThreads(__tstate);
32714 if (PyErr_Occurred()) SWIG_fail;
32715 }
32716 {
32717 resultobj = wxPyMake_wxObject(result, 0);
32718 }
32719 {
32720 if (temp4)
32721 delete arg4;
32722 }
32723 {
32724 if (temp6)
32725 delete arg6;
32726 }
32727 return resultobj;
32728 fail:
32729 {
32730 if (temp4)
32731 delete arg4;
32732 }
32733 {
32734 if (temp6)
32735 delete arg6;
32736 }
32737 return NULL;
32738 }
32739
32740
32741 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
32742 PyObject *resultobj;
32743 wxMenu *arg1 = (wxMenu *) 0 ;
32744 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32745 wxMenuItem *result;
32746 PyObject * obj0 = 0 ;
32747 PyObject * obj1 = 0 ;
32748 char *kwnames[] = {
32749 (char *) "self",(char *) "item", NULL
32750 };
32751
32752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
32753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32754 if (SWIG_arg_fail(1)) SWIG_fail;
32755 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32756 if (SWIG_arg_fail(2)) SWIG_fail;
32757 {
32758 PyThreadState* __tstate = wxPyBeginAllowThreads();
32759 result = (wxMenuItem *)(arg1)->Prepend(arg2);
32760
32761 wxPyEndAllowThreads(__tstate);
32762 if (PyErr_Occurred()) SWIG_fail;
32763 }
32764 {
32765 resultobj = wxPyMake_wxObject(result, 0);
32766 }
32767 return resultobj;
32768 fail:
32769 return NULL;
32770 }
32771
32772
32773 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
32774 PyObject *resultobj;
32775 wxMenu *arg1 = (wxMenu *) 0 ;
32776 int arg2 ;
32777 wxString *arg3 = 0 ;
32778 wxString const &arg4_defvalue = wxPyEmptyString ;
32779 wxString *arg4 = (wxString *) &arg4_defvalue ;
32780 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32781 wxMenuItem *result;
32782 bool temp3 = false ;
32783 bool temp4 = false ;
32784 PyObject * obj0 = 0 ;
32785 PyObject * obj1 = 0 ;
32786 PyObject * obj2 = 0 ;
32787 PyObject * obj3 = 0 ;
32788 PyObject * obj4 = 0 ;
32789 char *kwnames[] = {
32790 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32791 };
32792
32793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32795 if (SWIG_arg_fail(1)) SWIG_fail;
32796 {
32797 arg2 = (int)(SWIG_As_int(obj1));
32798 if (SWIG_arg_fail(2)) SWIG_fail;
32799 }
32800 {
32801 arg3 = wxString_in_helper(obj2);
32802 if (arg3 == NULL) SWIG_fail;
32803 temp3 = true;
32804 }
32805 if (obj3) {
32806 {
32807 arg4 = wxString_in_helper(obj3);
32808 if (arg4 == NULL) SWIG_fail;
32809 temp4 = true;
32810 }
32811 }
32812 if (obj4) {
32813 {
32814 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32815 if (SWIG_arg_fail(5)) SWIG_fail;
32816 }
32817 }
32818 {
32819 PyThreadState* __tstate = wxPyBeginAllowThreads();
32820 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32821
32822 wxPyEndAllowThreads(__tstate);
32823 if (PyErr_Occurred()) SWIG_fail;
32824 }
32825 {
32826 resultobj = wxPyMake_wxObject(result, 0);
32827 }
32828 {
32829 if (temp3)
32830 delete arg3;
32831 }
32832 {
32833 if (temp4)
32834 delete arg4;
32835 }
32836 return resultobj;
32837 fail:
32838 {
32839 if (temp3)
32840 delete arg3;
32841 }
32842 {
32843 if (temp4)
32844 delete arg4;
32845 }
32846 return NULL;
32847 }
32848
32849
32850 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32851 PyObject *resultobj;
32852 wxMenu *arg1 = (wxMenu *) 0 ;
32853 wxMenuItem *result;
32854 PyObject * obj0 = 0 ;
32855 char *kwnames[] = {
32856 (char *) "self", NULL
32857 };
32858
32859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
32860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32861 if (SWIG_arg_fail(1)) SWIG_fail;
32862 {
32863 PyThreadState* __tstate = wxPyBeginAllowThreads();
32864 result = (wxMenuItem *)(arg1)->PrependSeparator();
32865
32866 wxPyEndAllowThreads(__tstate);
32867 if (PyErr_Occurred()) SWIG_fail;
32868 }
32869 {
32870 resultobj = wxPyMake_wxObject(result, 0);
32871 }
32872 return resultobj;
32873 fail:
32874 return NULL;
32875 }
32876
32877
32878 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32879 PyObject *resultobj;
32880 wxMenu *arg1 = (wxMenu *) 0 ;
32881 int arg2 ;
32882 wxString *arg3 = 0 ;
32883 wxString const &arg4_defvalue = wxPyEmptyString ;
32884 wxString *arg4 = (wxString *) &arg4_defvalue ;
32885 wxMenuItem *result;
32886 bool temp3 = false ;
32887 bool temp4 = false ;
32888 PyObject * obj0 = 0 ;
32889 PyObject * obj1 = 0 ;
32890 PyObject * obj2 = 0 ;
32891 PyObject * obj3 = 0 ;
32892 char *kwnames[] = {
32893 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32894 };
32895
32896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32898 if (SWIG_arg_fail(1)) SWIG_fail;
32899 {
32900 arg2 = (int)(SWIG_As_int(obj1));
32901 if (SWIG_arg_fail(2)) SWIG_fail;
32902 }
32903 {
32904 arg3 = wxString_in_helper(obj2);
32905 if (arg3 == NULL) SWIG_fail;
32906 temp3 = true;
32907 }
32908 if (obj3) {
32909 {
32910 arg4 = wxString_in_helper(obj3);
32911 if (arg4 == NULL) SWIG_fail;
32912 temp4 = true;
32913 }
32914 }
32915 {
32916 PyThreadState* __tstate = wxPyBeginAllowThreads();
32917 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32918
32919 wxPyEndAllowThreads(__tstate);
32920 if (PyErr_Occurred()) SWIG_fail;
32921 }
32922 {
32923 resultobj = wxPyMake_wxObject(result, 0);
32924 }
32925 {
32926 if (temp3)
32927 delete arg3;
32928 }
32929 {
32930 if (temp4)
32931 delete arg4;
32932 }
32933 return resultobj;
32934 fail:
32935 {
32936 if (temp3)
32937 delete arg3;
32938 }
32939 {
32940 if (temp4)
32941 delete arg4;
32942 }
32943 return NULL;
32944 }
32945
32946
32947 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32948 PyObject *resultobj;
32949 wxMenu *arg1 = (wxMenu *) 0 ;
32950 int arg2 ;
32951 wxString *arg3 = 0 ;
32952 wxString const &arg4_defvalue = wxPyEmptyString ;
32953 wxString *arg4 = (wxString *) &arg4_defvalue ;
32954 wxMenuItem *result;
32955 bool temp3 = false ;
32956 bool temp4 = false ;
32957 PyObject * obj0 = 0 ;
32958 PyObject * obj1 = 0 ;
32959 PyObject * obj2 = 0 ;
32960 PyObject * obj3 = 0 ;
32961 char *kwnames[] = {
32962 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32963 };
32964
32965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32967 if (SWIG_arg_fail(1)) SWIG_fail;
32968 {
32969 arg2 = (int)(SWIG_As_int(obj1));
32970 if (SWIG_arg_fail(2)) SWIG_fail;
32971 }
32972 {
32973 arg3 = wxString_in_helper(obj2);
32974 if (arg3 == NULL) SWIG_fail;
32975 temp3 = true;
32976 }
32977 if (obj3) {
32978 {
32979 arg4 = wxString_in_helper(obj3);
32980 if (arg4 == NULL) SWIG_fail;
32981 temp4 = true;
32982 }
32983 }
32984 {
32985 PyThreadState* __tstate = wxPyBeginAllowThreads();
32986 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32987
32988 wxPyEndAllowThreads(__tstate);
32989 if (PyErr_Occurred()) SWIG_fail;
32990 }
32991 {
32992 resultobj = wxPyMake_wxObject(result, 0);
32993 }
32994 {
32995 if (temp3)
32996 delete arg3;
32997 }
32998 {
32999 if (temp4)
33000 delete arg4;
33001 }
33002 return resultobj;
33003 fail:
33004 {
33005 if (temp3)
33006 delete arg3;
33007 }
33008 {
33009 if (temp4)
33010 delete arg4;
33011 }
33012 return NULL;
33013 }
33014
33015
33016 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33017 PyObject *resultobj;
33018 wxMenu *arg1 = (wxMenu *) 0 ;
33019 int arg2 ;
33020 wxString *arg3 = 0 ;
33021 wxMenu *arg4 = (wxMenu *) 0 ;
33022 wxString const &arg5_defvalue = wxPyEmptyString ;
33023 wxString *arg5 = (wxString *) &arg5_defvalue ;
33024 wxMenuItem *result;
33025 bool temp3 = false ;
33026 bool temp5 = false ;
33027 PyObject * obj0 = 0 ;
33028 PyObject * obj1 = 0 ;
33029 PyObject * obj2 = 0 ;
33030 PyObject * obj3 = 0 ;
33031 PyObject * obj4 = 0 ;
33032 char *kwnames[] = {
33033 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33034 };
33035
33036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33038 if (SWIG_arg_fail(1)) SWIG_fail;
33039 {
33040 arg2 = (int)(SWIG_As_int(obj1));
33041 if (SWIG_arg_fail(2)) SWIG_fail;
33042 }
33043 {
33044 arg3 = wxString_in_helper(obj2);
33045 if (arg3 == NULL) SWIG_fail;
33046 temp3 = true;
33047 }
33048 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33049 if (SWIG_arg_fail(4)) SWIG_fail;
33050 if (obj4) {
33051 {
33052 arg5 = wxString_in_helper(obj4);
33053 if (arg5 == NULL) SWIG_fail;
33054 temp5 = true;
33055 }
33056 }
33057 {
33058 PyThreadState* __tstate = wxPyBeginAllowThreads();
33059 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33060
33061 wxPyEndAllowThreads(__tstate);
33062 if (PyErr_Occurred()) SWIG_fail;
33063 }
33064 {
33065 resultobj = wxPyMake_wxObject(result, 0);
33066 }
33067 {
33068 if (temp3)
33069 delete arg3;
33070 }
33071 {
33072 if (temp5)
33073 delete arg5;
33074 }
33075 return resultobj;
33076 fail:
33077 {
33078 if (temp3)
33079 delete arg3;
33080 }
33081 {
33082 if (temp5)
33083 delete arg5;
33084 }
33085 return NULL;
33086 }
33087
33088
33089 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33090 PyObject *resultobj;
33091 wxMenu *arg1 = (wxMenu *) 0 ;
33092 int arg2 ;
33093 wxMenuItem *result;
33094 PyObject * obj0 = 0 ;
33095 PyObject * obj1 = 0 ;
33096 char *kwnames[] = {
33097 (char *) "self",(char *) "id", NULL
33098 };
33099
33100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33102 if (SWIG_arg_fail(1)) SWIG_fail;
33103 {
33104 arg2 = (int)(SWIG_As_int(obj1));
33105 if (SWIG_arg_fail(2)) SWIG_fail;
33106 }
33107 {
33108 PyThreadState* __tstate = wxPyBeginAllowThreads();
33109 result = (wxMenuItem *)(arg1)->Remove(arg2);
33110
33111 wxPyEndAllowThreads(__tstate);
33112 if (PyErr_Occurred()) SWIG_fail;
33113 }
33114 {
33115 resultobj = wxPyMake_wxObject(result, 0);
33116 }
33117 return resultobj;
33118 fail:
33119 return NULL;
33120 }
33121
33122
33123 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33124 PyObject *resultobj;
33125 wxMenu *arg1 = (wxMenu *) 0 ;
33126 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33127 wxMenuItem *result;
33128 PyObject * obj0 = 0 ;
33129 PyObject * obj1 = 0 ;
33130 char *kwnames[] = {
33131 (char *) "self",(char *) "item", NULL
33132 };
33133
33134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33136 if (SWIG_arg_fail(1)) SWIG_fail;
33137 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33138 if (SWIG_arg_fail(2)) SWIG_fail;
33139 {
33140 PyThreadState* __tstate = wxPyBeginAllowThreads();
33141 result = (wxMenuItem *)(arg1)->Remove(arg2);
33142
33143 wxPyEndAllowThreads(__tstate);
33144 if (PyErr_Occurred()) SWIG_fail;
33145 }
33146 {
33147 resultobj = wxPyMake_wxObject(result, 0);
33148 }
33149 return resultobj;
33150 fail:
33151 return NULL;
33152 }
33153
33154
33155 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33156 PyObject *resultobj;
33157 wxMenu *arg1 = (wxMenu *) 0 ;
33158 int arg2 ;
33159 bool result;
33160 PyObject * obj0 = 0 ;
33161 PyObject * obj1 = 0 ;
33162 char *kwnames[] = {
33163 (char *) "self",(char *) "id", NULL
33164 };
33165
33166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33168 if (SWIG_arg_fail(1)) SWIG_fail;
33169 {
33170 arg2 = (int)(SWIG_As_int(obj1));
33171 if (SWIG_arg_fail(2)) SWIG_fail;
33172 }
33173 {
33174 PyThreadState* __tstate = wxPyBeginAllowThreads();
33175 result = (bool)(arg1)->Delete(arg2);
33176
33177 wxPyEndAllowThreads(__tstate);
33178 if (PyErr_Occurred()) SWIG_fail;
33179 }
33180 {
33181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33182 }
33183 return resultobj;
33184 fail:
33185 return NULL;
33186 }
33187
33188
33189 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33190 PyObject *resultobj;
33191 wxMenu *arg1 = (wxMenu *) 0 ;
33192 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33193 bool result;
33194 PyObject * obj0 = 0 ;
33195 PyObject * obj1 = 0 ;
33196 char *kwnames[] = {
33197 (char *) "self",(char *) "item", NULL
33198 };
33199
33200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33202 if (SWIG_arg_fail(1)) SWIG_fail;
33203 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33204 if (SWIG_arg_fail(2)) SWIG_fail;
33205 {
33206 PyThreadState* __tstate = wxPyBeginAllowThreads();
33207 result = (bool)(arg1)->Delete(arg2);
33208
33209 wxPyEndAllowThreads(__tstate);
33210 if (PyErr_Occurred()) SWIG_fail;
33211 }
33212 {
33213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33214 }
33215 return resultobj;
33216 fail:
33217 return NULL;
33218 }
33219
33220
33221 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33222 PyObject *resultobj;
33223 wxMenu *arg1 = (wxMenu *) 0 ;
33224 PyObject * obj0 = 0 ;
33225 char *kwnames[] = {
33226 (char *) "self", NULL
33227 };
33228
33229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33231 if (SWIG_arg_fail(1)) SWIG_fail;
33232 {
33233 PyThreadState* __tstate = wxPyBeginAllowThreads();
33234 wxMenu_Destroy(arg1);
33235
33236 wxPyEndAllowThreads(__tstate);
33237 if (PyErr_Occurred()) SWIG_fail;
33238 }
33239 Py_INCREF(Py_None); resultobj = Py_None;
33240 return resultobj;
33241 fail:
33242 return NULL;
33243 }
33244
33245
33246 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33247 PyObject *resultobj;
33248 wxMenu *arg1 = (wxMenu *) 0 ;
33249 int arg2 ;
33250 bool result;
33251 PyObject * obj0 = 0 ;
33252 PyObject * obj1 = 0 ;
33253 char *kwnames[] = {
33254 (char *) "self",(char *) "id", NULL
33255 };
33256
33257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33259 if (SWIG_arg_fail(1)) SWIG_fail;
33260 {
33261 arg2 = (int)(SWIG_As_int(obj1));
33262 if (SWIG_arg_fail(2)) SWIG_fail;
33263 }
33264 {
33265 PyThreadState* __tstate = wxPyBeginAllowThreads();
33266 result = (bool)(arg1)->Destroy(arg2);
33267
33268 wxPyEndAllowThreads(__tstate);
33269 if (PyErr_Occurred()) SWIG_fail;
33270 }
33271 {
33272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33273 }
33274 return resultobj;
33275 fail:
33276 return NULL;
33277 }
33278
33279
33280 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33281 PyObject *resultobj;
33282 wxMenu *arg1 = (wxMenu *) 0 ;
33283 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33284 bool result;
33285 PyObject * obj0 = 0 ;
33286 PyObject * obj1 = 0 ;
33287 char *kwnames[] = {
33288 (char *) "self",(char *) "item", NULL
33289 };
33290
33291 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33292 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33293 if (SWIG_arg_fail(1)) SWIG_fail;
33294 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33295 if (SWIG_arg_fail(2)) SWIG_fail;
33296 {
33297 PyThreadState* __tstate = wxPyBeginAllowThreads();
33298 result = (bool)(arg1)->Destroy(arg2);
33299
33300 wxPyEndAllowThreads(__tstate);
33301 if (PyErr_Occurred()) SWIG_fail;
33302 }
33303 {
33304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33305 }
33306 return resultobj;
33307 fail:
33308 return NULL;
33309 }
33310
33311
33312 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33313 PyObject *resultobj;
33314 wxMenu *arg1 = (wxMenu *) 0 ;
33315 size_t result;
33316 PyObject * obj0 = 0 ;
33317 char *kwnames[] = {
33318 (char *) "self", NULL
33319 };
33320
33321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33323 if (SWIG_arg_fail(1)) SWIG_fail;
33324 {
33325 PyThreadState* __tstate = wxPyBeginAllowThreads();
33326 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33327
33328 wxPyEndAllowThreads(__tstate);
33329 if (PyErr_Occurred()) SWIG_fail;
33330 }
33331 {
33332 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33333 }
33334 return resultobj;
33335 fail:
33336 return NULL;
33337 }
33338
33339
33340 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33341 PyObject *resultobj;
33342 wxMenu *arg1 = (wxMenu *) 0 ;
33343 PyObject *result;
33344 PyObject * obj0 = 0 ;
33345 char *kwnames[] = {
33346 (char *) "self", NULL
33347 };
33348
33349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
33350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33351 if (SWIG_arg_fail(1)) SWIG_fail;
33352 {
33353 PyThreadState* __tstate = wxPyBeginAllowThreads();
33354 result = (PyObject *)wxMenu_GetMenuItems(arg1);
33355
33356 wxPyEndAllowThreads(__tstate);
33357 if (PyErr_Occurred()) SWIG_fail;
33358 }
33359 resultobj = result;
33360 return resultobj;
33361 fail:
33362 return NULL;
33363 }
33364
33365
33366 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
33367 PyObject *resultobj;
33368 wxMenu *arg1 = (wxMenu *) 0 ;
33369 wxString *arg2 = 0 ;
33370 int result;
33371 bool temp2 = false ;
33372 PyObject * obj0 = 0 ;
33373 PyObject * obj1 = 0 ;
33374 char *kwnames[] = {
33375 (char *) "self",(char *) "item", NULL
33376 };
33377
33378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
33379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33380 if (SWIG_arg_fail(1)) SWIG_fail;
33381 {
33382 arg2 = wxString_in_helper(obj1);
33383 if (arg2 == NULL) SWIG_fail;
33384 temp2 = true;
33385 }
33386 {
33387 PyThreadState* __tstate = wxPyBeginAllowThreads();
33388 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
33389
33390 wxPyEndAllowThreads(__tstate);
33391 if (PyErr_Occurred()) SWIG_fail;
33392 }
33393 {
33394 resultobj = SWIG_From_int((int)(result));
33395 }
33396 {
33397 if (temp2)
33398 delete arg2;
33399 }
33400 return resultobj;
33401 fail:
33402 {
33403 if (temp2)
33404 delete arg2;
33405 }
33406 return NULL;
33407 }
33408
33409
33410 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
33411 PyObject *resultobj;
33412 wxMenu *arg1 = (wxMenu *) 0 ;
33413 int arg2 ;
33414 wxMenuItem *result;
33415 PyObject * obj0 = 0 ;
33416 PyObject * obj1 = 0 ;
33417 char *kwnames[] = {
33418 (char *) "self",(char *) "id", NULL
33419 };
33420
33421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
33422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33423 if (SWIG_arg_fail(1)) SWIG_fail;
33424 {
33425 arg2 = (int)(SWIG_As_int(obj1));
33426 if (SWIG_arg_fail(2)) SWIG_fail;
33427 }
33428 {
33429 PyThreadState* __tstate = wxPyBeginAllowThreads();
33430 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
33431
33432 wxPyEndAllowThreads(__tstate);
33433 if (PyErr_Occurred()) SWIG_fail;
33434 }
33435 {
33436 resultobj = wxPyMake_wxObject(result, 0);
33437 }
33438 return resultobj;
33439 fail:
33440 return NULL;
33441 }
33442
33443
33444 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
33445 PyObject *resultobj;
33446 wxMenu *arg1 = (wxMenu *) 0 ;
33447 size_t arg2 ;
33448 wxMenuItem *result;
33449 PyObject * obj0 = 0 ;
33450 PyObject * obj1 = 0 ;
33451 char *kwnames[] = {
33452 (char *) "self",(char *) "position", NULL
33453 };
33454
33455 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
33456 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33457 if (SWIG_arg_fail(1)) SWIG_fail;
33458 {
33459 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33460 if (SWIG_arg_fail(2)) SWIG_fail;
33461 }
33462 {
33463 PyThreadState* __tstate = wxPyBeginAllowThreads();
33464 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
33465
33466 wxPyEndAllowThreads(__tstate);
33467 if (PyErr_Occurred()) SWIG_fail;
33468 }
33469 {
33470 resultobj = wxPyMake_wxObject(result, 0);
33471 }
33472 return resultobj;
33473 fail:
33474 return NULL;
33475 }
33476
33477
33478 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
33479 PyObject *resultobj;
33480 wxMenu *arg1 = (wxMenu *) 0 ;
33481 int arg2 ;
33482 bool arg3 ;
33483 PyObject * obj0 = 0 ;
33484 PyObject * obj1 = 0 ;
33485 PyObject * obj2 = 0 ;
33486 char *kwnames[] = {
33487 (char *) "self",(char *) "id",(char *) "enable", NULL
33488 };
33489
33490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
33491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33492 if (SWIG_arg_fail(1)) SWIG_fail;
33493 {
33494 arg2 = (int)(SWIG_As_int(obj1));
33495 if (SWIG_arg_fail(2)) SWIG_fail;
33496 }
33497 {
33498 arg3 = (bool)(SWIG_As_bool(obj2));
33499 if (SWIG_arg_fail(3)) SWIG_fail;
33500 }
33501 {
33502 PyThreadState* __tstate = wxPyBeginAllowThreads();
33503 (arg1)->Enable(arg2,arg3);
33504
33505 wxPyEndAllowThreads(__tstate);
33506 if (PyErr_Occurred()) SWIG_fail;
33507 }
33508 Py_INCREF(Py_None); resultobj = Py_None;
33509 return resultobj;
33510 fail:
33511 return NULL;
33512 }
33513
33514
33515 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
33516 PyObject *resultobj;
33517 wxMenu *arg1 = (wxMenu *) 0 ;
33518 int arg2 ;
33519 bool result;
33520 PyObject * obj0 = 0 ;
33521 PyObject * obj1 = 0 ;
33522 char *kwnames[] = {
33523 (char *) "self",(char *) "id", NULL
33524 };
33525
33526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
33527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33528 if (SWIG_arg_fail(1)) SWIG_fail;
33529 {
33530 arg2 = (int)(SWIG_As_int(obj1));
33531 if (SWIG_arg_fail(2)) SWIG_fail;
33532 }
33533 {
33534 PyThreadState* __tstate = wxPyBeginAllowThreads();
33535 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
33536
33537 wxPyEndAllowThreads(__tstate);
33538 if (PyErr_Occurred()) SWIG_fail;
33539 }
33540 {
33541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33542 }
33543 return resultobj;
33544 fail:
33545 return NULL;
33546 }
33547
33548
33549 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
33550 PyObject *resultobj;
33551 wxMenu *arg1 = (wxMenu *) 0 ;
33552 int arg2 ;
33553 bool arg3 ;
33554 PyObject * obj0 = 0 ;
33555 PyObject * obj1 = 0 ;
33556 PyObject * obj2 = 0 ;
33557 char *kwnames[] = {
33558 (char *) "self",(char *) "id",(char *) "check", NULL
33559 };
33560
33561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
33562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33563 if (SWIG_arg_fail(1)) SWIG_fail;
33564 {
33565 arg2 = (int)(SWIG_As_int(obj1));
33566 if (SWIG_arg_fail(2)) SWIG_fail;
33567 }
33568 {
33569 arg3 = (bool)(SWIG_As_bool(obj2));
33570 if (SWIG_arg_fail(3)) SWIG_fail;
33571 }
33572 {
33573 PyThreadState* __tstate = wxPyBeginAllowThreads();
33574 (arg1)->Check(arg2,arg3);
33575
33576 wxPyEndAllowThreads(__tstate);
33577 if (PyErr_Occurred()) SWIG_fail;
33578 }
33579 Py_INCREF(Py_None); resultobj = Py_None;
33580 return resultobj;
33581 fail:
33582 return NULL;
33583 }
33584
33585
33586 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
33587 PyObject *resultobj;
33588 wxMenu *arg1 = (wxMenu *) 0 ;
33589 int arg2 ;
33590 bool result;
33591 PyObject * obj0 = 0 ;
33592 PyObject * obj1 = 0 ;
33593 char *kwnames[] = {
33594 (char *) "self",(char *) "id", NULL
33595 };
33596
33597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
33598 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33599 if (SWIG_arg_fail(1)) SWIG_fail;
33600 {
33601 arg2 = (int)(SWIG_As_int(obj1));
33602 if (SWIG_arg_fail(2)) SWIG_fail;
33603 }
33604 {
33605 PyThreadState* __tstate = wxPyBeginAllowThreads();
33606 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
33607
33608 wxPyEndAllowThreads(__tstate);
33609 if (PyErr_Occurred()) SWIG_fail;
33610 }
33611 {
33612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33613 }
33614 return resultobj;
33615 fail:
33616 return NULL;
33617 }
33618
33619
33620 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33621 PyObject *resultobj;
33622 wxMenu *arg1 = (wxMenu *) 0 ;
33623 int arg2 ;
33624 wxString *arg3 = 0 ;
33625 bool temp3 = false ;
33626 PyObject * obj0 = 0 ;
33627 PyObject * obj1 = 0 ;
33628 PyObject * obj2 = 0 ;
33629 char *kwnames[] = {
33630 (char *) "self",(char *) "id",(char *) "label", NULL
33631 };
33632
33633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
33634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33635 if (SWIG_arg_fail(1)) SWIG_fail;
33636 {
33637 arg2 = (int)(SWIG_As_int(obj1));
33638 if (SWIG_arg_fail(2)) SWIG_fail;
33639 }
33640 {
33641 arg3 = wxString_in_helper(obj2);
33642 if (arg3 == NULL) SWIG_fail;
33643 temp3 = true;
33644 }
33645 {
33646 PyThreadState* __tstate = wxPyBeginAllowThreads();
33647 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
33648
33649 wxPyEndAllowThreads(__tstate);
33650 if (PyErr_Occurred()) SWIG_fail;
33651 }
33652 Py_INCREF(Py_None); resultobj = Py_None;
33653 {
33654 if (temp3)
33655 delete arg3;
33656 }
33657 return resultobj;
33658 fail:
33659 {
33660 if (temp3)
33661 delete arg3;
33662 }
33663 return NULL;
33664 }
33665
33666
33667 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
33668 PyObject *resultobj;
33669 wxMenu *arg1 = (wxMenu *) 0 ;
33670 int arg2 ;
33671 wxString result;
33672 PyObject * obj0 = 0 ;
33673 PyObject * obj1 = 0 ;
33674 char *kwnames[] = {
33675 (char *) "self",(char *) "id", NULL
33676 };
33677
33678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
33679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33680 if (SWIG_arg_fail(1)) SWIG_fail;
33681 {
33682 arg2 = (int)(SWIG_As_int(obj1));
33683 if (SWIG_arg_fail(2)) SWIG_fail;
33684 }
33685 {
33686 PyThreadState* __tstate = wxPyBeginAllowThreads();
33687 result = ((wxMenu const *)arg1)->GetLabel(arg2);
33688
33689 wxPyEndAllowThreads(__tstate);
33690 if (PyErr_Occurred()) SWIG_fail;
33691 }
33692 {
33693 #if wxUSE_UNICODE
33694 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33695 #else
33696 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33697 #endif
33698 }
33699 return resultobj;
33700 fail:
33701 return NULL;
33702 }
33703
33704
33705 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33706 PyObject *resultobj;
33707 wxMenu *arg1 = (wxMenu *) 0 ;
33708 int arg2 ;
33709 wxString *arg3 = 0 ;
33710 bool temp3 = false ;
33711 PyObject * obj0 = 0 ;
33712 PyObject * obj1 = 0 ;
33713 PyObject * obj2 = 0 ;
33714 char *kwnames[] = {
33715 (char *) "self",(char *) "id",(char *) "helpString", NULL
33716 };
33717
33718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
33719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33720 if (SWIG_arg_fail(1)) SWIG_fail;
33721 {
33722 arg2 = (int)(SWIG_As_int(obj1));
33723 if (SWIG_arg_fail(2)) SWIG_fail;
33724 }
33725 {
33726 arg3 = wxString_in_helper(obj2);
33727 if (arg3 == NULL) SWIG_fail;
33728 temp3 = true;
33729 }
33730 {
33731 PyThreadState* __tstate = wxPyBeginAllowThreads();
33732 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
33733
33734 wxPyEndAllowThreads(__tstate);
33735 if (PyErr_Occurred()) SWIG_fail;
33736 }
33737 Py_INCREF(Py_None); resultobj = Py_None;
33738 {
33739 if (temp3)
33740 delete arg3;
33741 }
33742 return resultobj;
33743 fail:
33744 {
33745 if (temp3)
33746 delete arg3;
33747 }
33748 return NULL;
33749 }
33750
33751
33752 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
33753 PyObject *resultobj;
33754 wxMenu *arg1 = (wxMenu *) 0 ;
33755 int arg2 ;
33756 wxString result;
33757 PyObject * obj0 = 0 ;
33758 PyObject * obj1 = 0 ;
33759 char *kwnames[] = {
33760 (char *) "self",(char *) "id", NULL
33761 };
33762
33763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
33764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33765 if (SWIG_arg_fail(1)) SWIG_fail;
33766 {
33767 arg2 = (int)(SWIG_As_int(obj1));
33768 if (SWIG_arg_fail(2)) SWIG_fail;
33769 }
33770 {
33771 PyThreadState* __tstate = wxPyBeginAllowThreads();
33772 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
33773
33774 wxPyEndAllowThreads(__tstate);
33775 if (PyErr_Occurred()) SWIG_fail;
33776 }
33777 {
33778 #if wxUSE_UNICODE
33779 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33780 #else
33781 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33782 #endif
33783 }
33784 return resultobj;
33785 fail:
33786 return NULL;
33787 }
33788
33789
33790 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33791 PyObject *resultobj;
33792 wxMenu *arg1 = (wxMenu *) 0 ;
33793 wxString *arg2 = 0 ;
33794 bool temp2 = false ;
33795 PyObject * obj0 = 0 ;
33796 PyObject * obj1 = 0 ;
33797 char *kwnames[] = {
33798 (char *) "self",(char *) "title", NULL
33799 };
33800
33801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
33802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33803 if (SWIG_arg_fail(1)) SWIG_fail;
33804 {
33805 arg2 = wxString_in_helper(obj1);
33806 if (arg2 == NULL) SWIG_fail;
33807 temp2 = true;
33808 }
33809 {
33810 PyThreadState* __tstate = wxPyBeginAllowThreads();
33811 (arg1)->SetTitle((wxString const &)*arg2);
33812
33813 wxPyEndAllowThreads(__tstate);
33814 if (PyErr_Occurred()) SWIG_fail;
33815 }
33816 Py_INCREF(Py_None); resultobj = Py_None;
33817 {
33818 if (temp2)
33819 delete arg2;
33820 }
33821 return resultobj;
33822 fail:
33823 {
33824 if (temp2)
33825 delete arg2;
33826 }
33827 return NULL;
33828 }
33829
33830
33831 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
33832 PyObject *resultobj;
33833 wxMenu *arg1 = (wxMenu *) 0 ;
33834 wxString result;
33835 PyObject * obj0 = 0 ;
33836 char *kwnames[] = {
33837 (char *) "self", NULL
33838 };
33839
33840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
33841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33842 if (SWIG_arg_fail(1)) SWIG_fail;
33843 {
33844 PyThreadState* __tstate = wxPyBeginAllowThreads();
33845 result = ((wxMenu const *)arg1)->GetTitle();
33846
33847 wxPyEndAllowThreads(__tstate);
33848 if (PyErr_Occurred()) SWIG_fail;
33849 }
33850 {
33851 #if wxUSE_UNICODE
33852 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33853 #else
33854 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33855 #endif
33856 }
33857 return resultobj;
33858 fail:
33859 return NULL;
33860 }
33861
33862
33863 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33864 PyObject *resultobj;
33865 wxMenu *arg1 = (wxMenu *) 0 ;
33866 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33867 PyObject * obj0 = 0 ;
33868 PyObject * obj1 = 0 ;
33869 char *kwnames[] = {
33870 (char *) "self",(char *) "handler", NULL
33871 };
33872
33873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
33874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33875 if (SWIG_arg_fail(1)) SWIG_fail;
33876 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
33877 if (SWIG_arg_fail(2)) SWIG_fail;
33878 {
33879 PyThreadState* __tstate = wxPyBeginAllowThreads();
33880 (arg1)->SetEventHandler(arg2);
33881
33882 wxPyEndAllowThreads(__tstate);
33883 if (PyErr_Occurred()) SWIG_fail;
33884 }
33885 Py_INCREF(Py_None); resultobj = Py_None;
33886 return resultobj;
33887 fail:
33888 return NULL;
33889 }
33890
33891
33892 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
33893 PyObject *resultobj;
33894 wxMenu *arg1 = (wxMenu *) 0 ;
33895 wxEvtHandler *result;
33896 PyObject * obj0 = 0 ;
33897 char *kwnames[] = {
33898 (char *) "self", NULL
33899 };
33900
33901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
33902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33903 if (SWIG_arg_fail(1)) SWIG_fail;
33904 {
33905 PyThreadState* __tstate = wxPyBeginAllowThreads();
33906 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
33907
33908 wxPyEndAllowThreads(__tstate);
33909 if (PyErr_Occurred()) SWIG_fail;
33910 }
33911 {
33912 resultobj = wxPyMake_wxObject(result, 0);
33913 }
33914 return resultobj;
33915 fail:
33916 return NULL;
33917 }
33918
33919
33920 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33921 PyObject *resultobj;
33922 wxMenu *arg1 = (wxMenu *) 0 ;
33923 wxWindow *arg2 = (wxWindow *) 0 ;
33924 PyObject * obj0 = 0 ;
33925 PyObject * obj1 = 0 ;
33926 char *kwnames[] = {
33927 (char *) "self",(char *) "win", NULL
33928 };
33929
33930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
33931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33932 if (SWIG_arg_fail(1)) SWIG_fail;
33933 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
33934 if (SWIG_arg_fail(2)) SWIG_fail;
33935 {
33936 PyThreadState* __tstate = wxPyBeginAllowThreads();
33937 (arg1)->SetInvokingWindow(arg2);
33938
33939 wxPyEndAllowThreads(__tstate);
33940 if (PyErr_Occurred()) SWIG_fail;
33941 }
33942 Py_INCREF(Py_None); resultobj = Py_None;
33943 return resultobj;
33944 fail:
33945 return NULL;
33946 }
33947
33948
33949 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
33950 PyObject *resultobj;
33951 wxMenu *arg1 = (wxMenu *) 0 ;
33952 wxWindow *result;
33953 PyObject * obj0 = 0 ;
33954 char *kwnames[] = {
33955 (char *) "self", NULL
33956 };
33957
33958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
33959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33960 if (SWIG_arg_fail(1)) SWIG_fail;
33961 {
33962 PyThreadState* __tstate = wxPyBeginAllowThreads();
33963 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
33964
33965 wxPyEndAllowThreads(__tstate);
33966 if (PyErr_Occurred()) SWIG_fail;
33967 }
33968 {
33969 resultobj = wxPyMake_wxObject(result, 0);
33970 }
33971 return resultobj;
33972 fail:
33973 return NULL;
33974 }
33975
33976
33977 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
33978 PyObject *resultobj;
33979 wxMenu *arg1 = (wxMenu *) 0 ;
33980 long result;
33981 PyObject * obj0 = 0 ;
33982 char *kwnames[] = {
33983 (char *) "self", NULL
33984 };
33985
33986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
33987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33988 if (SWIG_arg_fail(1)) SWIG_fail;
33989 {
33990 PyThreadState* __tstate = wxPyBeginAllowThreads();
33991 result = (long)((wxMenu const *)arg1)->GetStyle();
33992
33993 wxPyEndAllowThreads(__tstate);
33994 if (PyErr_Occurred()) SWIG_fail;
33995 }
33996 {
33997 resultobj = SWIG_From_long((long)(result));
33998 }
33999 return resultobj;
34000 fail:
34001 return NULL;
34002 }
34003
34004
34005 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34006 PyObject *resultobj;
34007 wxMenu *arg1 = (wxMenu *) 0 ;
34008 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34009 PyObject * obj0 = 0 ;
34010 PyObject * obj1 = 0 ;
34011 char *kwnames[] = {
34012 (char *) "self",(char *) "source", NULL
34013 };
34014
34015 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34017 if (SWIG_arg_fail(1)) SWIG_fail;
34018 if (obj1) {
34019 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34020 if (SWIG_arg_fail(2)) SWIG_fail;
34021 }
34022 {
34023 PyThreadState* __tstate = wxPyBeginAllowThreads();
34024 (arg1)->UpdateUI(arg2);
34025
34026 wxPyEndAllowThreads(__tstate);
34027 if (PyErr_Occurred()) SWIG_fail;
34028 }
34029 Py_INCREF(Py_None); resultobj = Py_None;
34030 return resultobj;
34031 fail:
34032 return NULL;
34033 }
34034
34035
34036 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34037 PyObject *resultobj;
34038 wxMenu *arg1 = (wxMenu *) 0 ;
34039 wxMenuBar *result;
34040 PyObject * obj0 = 0 ;
34041 char *kwnames[] = {
34042 (char *) "self", NULL
34043 };
34044
34045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34047 if (SWIG_arg_fail(1)) SWIG_fail;
34048 {
34049 PyThreadState* __tstate = wxPyBeginAllowThreads();
34050 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34051
34052 wxPyEndAllowThreads(__tstate);
34053 if (PyErr_Occurred()) SWIG_fail;
34054 }
34055 {
34056 resultobj = wxPyMake_wxObject(result, 0);
34057 }
34058 return resultobj;
34059 fail:
34060 return NULL;
34061 }
34062
34063
34064 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34065 PyObject *resultobj;
34066 wxMenu *arg1 = (wxMenu *) 0 ;
34067 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34068 PyObject * obj0 = 0 ;
34069 PyObject * obj1 = 0 ;
34070 char *kwnames[] = {
34071 (char *) "self",(char *) "menubar", NULL
34072 };
34073
34074 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34075 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34076 if (SWIG_arg_fail(1)) SWIG_fail;
34077 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34078 if (SWIG_arg_fail(2)) SWIG_fail;
34079 {
34080 PyThreadState* __tstate = wxPyBeginAllowThreads();
34081 (arg1)->Attach(arg2);
34082
34083 wxPyEndAllowThreads(__tstate);
34084 if (PyErr_Occurred()) SWIG_fail;
34085 }
34086 Py_INCREF(Py_None); resultobj = Py_None;
34087 return resultobj;
34088 fail:
34089 return NULL;
34090 }
34091
34092
34093 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34094 PyObject *resultobj;
34095 wxMenu *arg1 = (wxMenu *) 0 ;
34096 PyObject * obj0 = 0 ;
34097 char *kwnames[] = {
34098 (char *) "self", NULL
34099 };
34100
34101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34103 if (SWIG_arg_fail(1)) SWIG_fail;
34104 {
34105 PyThreadState* __tstate = wxPyBeginAllowThreads();
34106 (arg1)->Detach();
34107
34108 wxPyEndAllowThreads(__tstate);
34109 if (PyErr_Occurred()) SWIG_fail;
34110 }
34111 Py_INCREF(Py_None); resultobj = Py_None;
34112 return resultobj;
34113 fail:
34114 return NULL;
34115 }
34116
34117
34118 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34119 PyObject *resultobj;
34120 wxMenu *arg1 = (wxMenu *) 0 ;
34121 bool result;
34122 PyObject * obj0 = 0 ;
34123 char *kwnames[] = {
34124 (char *) "self", NULL
34125 };
34126
34127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34129 if (SWIG_arg_fail(1)) SWIG_fail;
34130 {
34131 PyThreadState* __tstate = wxPyBeginAllowThreads();
34132 result = (bool)((wxMenu const *)arg1)->IsAttached();
34133
34134 wxPyEndAllowThreads(__tstate);
34135 if (PyErr_Occurred()) SWIG_fail;
34136 }
34137 {
34138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34139 }
34140 return resultobj;
34141 fail:
34142 return NULL;
34143 }
34144
34145
34146 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34147 PyObject *resultobj;
34148 wxMenu *arg1 = (wxMenu *) 0 ;
34149 wxMenu *arg2 = (wxMenu *) 0 ;
34150 PyObject * obj0 = 0 ;
34151 PyObject * obj1 = 0 ;
34152 char *kwnames[] = {
34153 (char *) "self",(char *) "parent", NULL
34154 };
34155
34156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34158 if (SWIG_arg_fail(1)) SWIG_fail;
34159 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34160 if (SWIG_arg_fail(2)) SWIG_fail;
34161 {
34162 PyThreadState* __tstate = wxPyBeginAllowThreads();
34163 (arg1)->SetParent(arg2);
34164
34165 wxPyEndAllowThreads(__tstate);
34166 if (PyErr_Occurred()) SWIG_fail;
34167 }
34168 Py_INCREF(Py_None); resultobj = Py_None;
34169 return resultobj;
34170 fail:
34171 return NULL;
34172 }
34173
34174
34175 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34176 PyObject *resultobj;
34177 wxMenu *arg1 = (wxMenu *) 0 ;
34178 wxMenu *result;
34179 PyObject * obj0 = 0 ;
34180 char *kwnames[] = {
34181 (char *) "self", NULL
34182 };
34183
34184 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34185 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34186 if (SWIG_arg_fail(1)) SWIG_fail;
34187 {
34188 PyThreadState* __tstate = wxPyBeginAllowThreads();
34189 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34190
34191 wxPyEndAllowThreads(__tstate);
34192 if (PyErr_Occurred()) SWIG_fail;
34193 }
34194 {
34195 resultobj = wxPyMake_wxObject(result, 0);
34196 }
34197 return resultobj;
34198 fail:
34199 return NULL;
34200 }
34201
34202
34203 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34204 PyObject *obj;
34205 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34206 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34207 Py_INCREF(obj);
34208 return Py_BuildValue((char *)"");
34209 }
34210 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34211 PyObject *resultobj;
34212 long arg1 = (long) 0 ;
34213 wxMenuBar *result;
34214 PyObject * obj0 = 0 ;
34215 char *kwnames[] = {
34216 (char *) "style", NULL
34217 };
34218
34219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34220 if (obj0) {
34221 {
34222 arg1 = (long)(SWIG_As_long(obj0));
34223 if (SWIG_arg_fail(1)) SWIG_fail;
34224 }
34225 }
34226 {
34227 if (!wxPyCheckForApp()) SWIG_fail;
34228 PyThreadState* __tstate = wxPyBeginAllowThreads();
34229 result = (wxMenuBar *)new wxMenuBar(arg1);
34230
34231 wxPyEndAllowThreads(__tstate);
34232 if (PyErr_Occurred()) SWIG_fail;
34233 }
34234 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34235 return resultobj;
34236 fail:
34237 return NULL;
34238 }
34239
34240
34241 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34242 PyObject *resultobj;
34243 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34244 wxMenu *arg2 = (wxMenu *) 0 ;
34245 wxString *arg3 = 0 ;
34246 bool result;
34247 bool temp3 = false ;
34248 PyObject * obj0 = 0 ;
34249 PyObject * obj1 = 0 ;
34250 PyObject * obj2 = 0 ;
34251 char *kwnames[] = {
34252 (char *) "self",(char *) "menu",(char *) "title", NULL
34253 };
34254
34255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34257 if (SWIG_arg_fail(1)) SWIG_fail;
34258 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34259 if (SWIG_arg_fail(2)) SWIG_fail;
34260 {
34261 arg3 = wxString_in_helper(obj2);
34262 if (arg3 == NULL) SWIG_fail;
34263 temp3 = true;
34264 }
34265 {
34266 PyThreadState* __tstate = wxPyBeginAllowThreads();
34267 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34268
34269 wxPyEndAllowThreads(__tstate);
34270 if (PyErr_Occurred()) SWIG_fail;
34271 }
34272 {
34273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34274 }
34275 {
34276 if (temp3)
34277 delete arg3;
34278 }
34279 return resultobj;
34280 fail:
34281 {
34282 if (temp3)
34283 delete arg3;
34284 }
34285 return NULL;
34286 }
34287
34288
34289 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34290 PyObject *resultobj;
34291 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34292 size_t arg2 ;
34293 wxMenu *arg3 = (wxMenu *) 0 ;
34294 wxString *arg4 = 0 ;
34295 bool result;
34296 bool temp4 = false ;
34297 PyObject * obj0 = 0 ;
34298 PyObject * obj1 = 0 ;
34299 PyObject * obj2 = 0 ;
34300 PyObject * obj3 = 0 ;
34301 char *kwnames[] = {
34302 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34303 };
34304
34305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34307 if (SWIG_arg_fail(1)) SWIG_fail;
34308 {
34309 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34310 if (SWIG_arg_fail(2)) SWIG_fail;
34311 }
34312 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34313 if (SWIG_arg_fail(3)) SWIG_fail;
34314 {
34315 arg4 = wxString_in_helper(obj3);
34316 if (arg4 == NULL) SWIG_fail;
34317 temp4 = true;
34318 }
34319 {
34320 PyThreadState* __tstate = wxPyBeginAllowThreads();
34321 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34322
34323 wxPyEndAllowThreads(__tstate);
34324 if (PyErr_Occurred()) SWIG_fail;
34325 }
34326 {
34327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34328 }
34329 {
34330 if (temp4)
34331 delete arg4;
34332 }
34333 return resultobj;
34334 fail:
34335 {
34336 if (temp4)
34337 delete arg4;
34338 }
34339 return NULL;
34340 }
34341
34342
34343 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34344 PyObject *resultobj;
34345 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34346 size_t result;
34347 PyObject * obj0 = 0 ;
34348 char *kwnames[] = {
34349 (char *) "self", NULL
34350 };
34351
34352 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
34353 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34354 if (SWIG_arg_fail(1)) SWIG_fail;
34355 {
34356 PyThreadState* __tstate = wxPyBeginAllowThreads();
34357 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
34358
34359 wxPyEndAllowThreads(__tstate);
34360 if (PyErr_Occurred()) SWIG_fail;
34361 }
34362 {
34363 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34364 }
34365 return resultobj;
34366 fail:
34367 return NULL;
34368 }
34369
34370
34371 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34372 PyObject *resultobj;
34373 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34374 size_t arg2 ;
34375 wxMenu *result;
34376 PyObject * obj0 = 0 ;
34377 PyObject * obj1 = 0 ;
34378 char *kwnames[] = {
34379 (char *) "self",(char *) "pos", NULL
34380 };
34381
34382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
34383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34384 if (SWIG_arg_fail(1)) SWIG_fail;
34385 {
34386 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34387 if (SWIG_arg_fail(2)) SWIG_fail;
34388 }
34389 {
34390 PyThreadState* __tstate = wxPyBeginAllowThreads();
34391 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
34392
34393 wxPyEndAllowThreads(__tstate);
34394 if (PyErr_Occurred()) SWIG_fail;
34395 }
34396 {
34397 resultobj = wxPyMake_wxObject(result, 0);
34398 }
34399 return resultobj;
34400 fail:
34401 return NULL;
34402 }
34403
34404
34405 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
34406 PyObject *resultobj;
34407 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34408 size_t arg2 ;
34409 wxMenu *arg3 = (wxMenu *) 0 ;
34410 wxString *arg4 = 0 ;
34411 wxMenu *result;
34412 bool temp4 = false ;
34413 PyObject * obj0 = 0 ;
34414 PyObject * obj1 = 0 ;
34415 PyObject * obj2 = 0 ;
34416 PyObject * obj3 = 0 ;
34417 char *kwnames[] = {
34418 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34419 };
34420
34421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34423 if (SWIG_arg_fail(1)) SWIG_fail;
34424 {
34425 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34426 if (SWIG_arg_fail(2)) SWIG_fail;
34427 }
34428 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34429 if (SWIG_arg_fail(3)) SWIG_fail;
34430 {
34431 arg4 = wxString_in_helper(obj3);
34432 if (arg4 == NULL) SWIG_fail;
34433 temp4 = true;
34434 }
34435 {
34436 PyThreadState* __tstate = wxPyBeginAllowThreads();
34437 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
34438
34439 wxPyEndAllowThreads(__tstate);
34440 if (PyErr_Occurred()) SWIG_fail;
34441 }
34442 {
34443 resultobj = wxPyMake_wxObject(result, 0);
34444 }
34445 {
34446 if (temp4)
34447 delete arg4;
34448 }
34449 return resultobj;
34450 fail:
34451 {
34452 if (temp4)
34453 delete arg4;
34454 }
34455 return NULL;
34456 }
34457
34458
34459 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34460 PyObject *resultobj;
34461 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34462 size_t arg2 ;
34463 wxMenu *result;
34464 PyObject * obj0 = 0 ;
34465 PyObject * obj1 = 0 ;
34466 char *kwnames[] = {
34467 (char *) "self",(char *) "pos", NULL
34468 };
34469
34470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
34471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34472 if (SWIG_arg_fail(1)) SWIG_fail;
34473 {
34474 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34475 if (SWIG_arg_fail(2)) SWIG_fail;
34476 }
34477 {
34478 PyThreadState* __tstate = wxPyBeginAllowThreads();
34479 result = (wxMenu *)(arg1)->Remove(arg2);
34480
34481 wxPyEndAllowThreads(__tstate);
34482 if (PyErr_Occurred()) SWIG_fail;
34483 }
34484 {
34485 resultobj = wxPyMake_wxObject(result, 0);
34486 }
34487 return resultobj;
34488 fail:
34489 return NULL;
34490 }
34491
34492
34493 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
34494 PyObject *resultobj;
34495 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34496 size_t arg2 ;
34497 bool arg3 ;
34498 PyObject * obj0 = 0 ;
34499 PyObject * obj1 = 0 ;
34500 PyObject * obj2 = 0 ;
34501 char *kwnames[] = {
34502 (char *) "self",(char *) "pos",(char *) "enable", NULL
34503 };
34504
34505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34507 if (SWIG_arg_fail(1)) SWIG_fail;
34508 {
34509 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34510 if (SWIG_arg_fail(2)) SWIG_fail;
34511 }
34512 {
34513 arg3 = (bool)(SWIG_As_bool(obj2));
34514 if (SWIG_arg_fail(3)) SWIG_fail;
34515 }
34516 {
34517 PyThreadState* __tstate = wxPyBeginAllowThreads();
34518 (arg1)->EnableTop(arg2,arg3);
34519
34520 wxPyEndAllowThreads(__tstate);
34521 if (PyErr_Occurred()) SWIG_fail;
34522 }
34523 Py_INCREF(Py_None); resultobj = Py_None;
34524 return resultobj;
34525 fail:
34526 return NULL;
34527 }
34528
34529
34530 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
34531 PyObject *resultobj;
34532 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34533 size_t arg2 ;
34534 bool result;
34535 PyObject * obj0 = 0 ;
34536 PyObject * obj1 = 0 ;
34537 char *kwnames[] = {
34538 (char *) "self",(char *) "pos", NULL
34539 };
34540
34541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
34542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34543 if (SWIG_arg_fail(1)) SWIG_fail;
34544 {
34545 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34546 if (SWIG_arg_fail(2)) SWIG_fail;
34547 }
34548 {
34549 PyThreadState* __tstate = wxPyBeginAllowThreads();
34550 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
34551
34552 wxPyEndAllowThreads(__tstate);
34553 if (PyErr_Occurred()) SWIG_fail;
34554 }
34555 {
34556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34557 }
34558 return resultobj;
34559 fail:
34560 return NULL;
34561 }
34562
34563
34564 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34565 PyObject *resultobj;
34566 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34567 size_t arg2 ;
34568 wxString *arg3 = 0 ;
34569 bool temp3 = false ;
34570 PyObject * obj0 = 0 ;
34571 PyObject * obj1 = 0 ;
34572 PyObject * obj2 = 0 ;
34573 char *kwnames[] = {
34574 (char *) "self",(char *) "pos",(char *) "label", NULL
34575 };
34576
34577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
34578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34579 if (SWIG_arg_fail(1)) SWIG_fail;
34580 {
34581 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34582 if (SWIG_arg_fail(2)) SWIG_fail;
34583 }
34584 {
34585 arg3 = wxString_in_helper(obj2);
34586 if (arg3 == NULL) SWIG_fail;
34587 temp3 = true;
34588 }
34589 {
34590 PyThreadState* __tstate = wxPyBeginAllowThreads();
34591 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
34592
34593 wxPyEndAllowThreads(__tstate);
34594 if (PyErr_Occurred()) SWIG_fail;
34595 }
34596 Py_INCREF(Py_None); resultobj = Py_None;
34597 {
34598 if (temp3)
34599 delete arg3;
34600 }
34601 return resultobj;
34602 fail:
34603 {
34604 if (temp3)
34605 delete arg3;
34606 }
34607 return NULL;
34608 }
34609
34610
34611 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
34612 PyObject *resultobj;
34613 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34614 size_t arg2 ;
34615 wxString result;
34616 PyObject * obj0 = 0 ;
34617 PyObject * obj1 = 0 ;
34618 char *kwnames[] = {
34619 (char *) "self",(char *) "pos", NULL
34620 };
34621
34622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
34623 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34624 if (SWIG_arg_fail(1)) SWIG_fail;
34625 {
34626 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34627 if (SWIG_arg_fail(2)) SWIG_fail;
34628 }
34629 {
34630 PyThreadState* __tstate = wxPyBeginAllowThreads();
34631 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
34632
34633 wxPyEndAllowThreads(__tstate);
34634 if (PyErr_Occurred()) SWIG_fail;
34635 }
34636 {
34637 #if wxUSE_UNICODE
34638 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34639 #else
34640 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34641 #endif
34642 }
34643 return resultobj;
34644 fail:
34645 return NULL;
34646 }
34647
34648
34649 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
34650 PyObject *resultobj;
34651 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34652 wxString *arg2 = 0 ;
34653 wxString *arg3 = 0 ;
34654 int result;
34655 bool temp2 = false ;
34656 bool temp3 = false ;
34657 PyObject * obj0 = 0 ;
34658 PyObject * obj1 = 0 ;
34659 PyObject * obj2 = 0 ;
34660 char *kwnames[] = {
34661 (char *) "self",(char *) "menu",(char *) "item", NULL
34662 };
34663
34664 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
34665 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34666 if (SWIG_arg_fail(1)) SWIG_fail;
34667 {
34668 arg2 = wxString_in_helper(obj1);
34669 if (arg2 == NULL) SWIG_fail;
34670 temp2 = true;
34671 }
34672 {
34673 arg3 = wxString_in_helper(obj2);
34674 if (arg3 == NULL) SWIG_fail;
34675 temp3 = true;
34676 }
34677 {
34678 PyThreadState* __tstate = wxPyBeginAllowThreads();
34679 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
34680
34681 wxPyEndAllowThreads(__tstate);
34682 if (PyErr_Occurred()) SWIG_fail;
34683 }
34684 {
34685 resultobj = SWIG_From_int((int)(result));
34686 }
34687 {
34688 if (temp2)
34689 delete arg2;
34690 }
34691 {
34692 if (temp3)
34693 delete arg3;
34694 }
34695 return resultobj;
34696 fail:
34697 {
34698 if (temp2)
34699 delete arg2;
34700 }
34701 {
34702 if (temp3)
34703 delete arg3;
34704 }
34705 return NULL;
34706 }
34707
34708
34709 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34710 PyObject *resultobj;
34711 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34712 int arg2 ;
34713 wxMenuItem *result;
34714 PyObject * obj0 = 0 ;
34715 PyObject * obj1 = 0 ;
34716 char *kwnames[] = {
34717 (char *) "self",(char *) "id", NULL
34718 };
34719
34720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34722 if (SWIG_arg_fail(1)) SWIG_fail;
34723 {
34724 arg2 = (int)(SWIG_As_int(obj1));
34725 if (SWIG_arg_fail(2)) SWIG_fail;
34726 }
34727 {
34728 PyThreadState* __tstate = wxPyBeginAllowThreads();
34729 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
34730
34731 wxPyEndAllowThreads(__tstate);
34732 if (PyErr_Occurred()) SWIG_fail;
34733 }
34734 {
34735 resultobj = wxPyMake_wxObject(result, 0);
34736 }
34737 return resultobj;
34738 fail:
34739 return NULL;
34740 }
34741
34742
34743 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34744 PyObject *resultobj;
34745 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34746 wxString *arg2 = 0 ;
34747 int result;
34748 bool temp2 = false ;
34749 PyObject * obj0 = 0 ;
34750 PyObject * obj1 = 0 ;
34751 char *kwnames[] = {
34752 (char *) "self",(char *) "title", NULL
34753 };
34754
34755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
34756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34757 if (SWIG_arg_fail(1)) SWIG_fail;
34758 {
34759 arg2 = wxString_in_helper(obj1);
34760 if (arg2 == NULL) SWIG_fail;
34761 temp2 = true;
34762 }
34763 {
34764 PyThreadState* __tstate = wxPyBeginAllowThreads();
34765 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
34766
34767 wxPyEndAllowThreads(__tstate);
34768 if (PyErr_Occurred()) SWIG_fail;
34769 }
34770 {
34771 resultobj = SWIG_From_int((int)(result));
34772 }
34773 {
34774 if (temp2)
34775 delete arg2;
34776 }
34777 return resultobj;
34778 fail:
34779 {
34780 if (temp2)
34781 delete arg2;
34782 }
34783 return NULL;
34784 }
34785
34786
34787 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34788 PyObject *resultobj;
34789 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34790 int arg2 ;
34791 bool arg3 ;
34792 PyObject * obj0 = 0 ;
34793 PyObject * obj1 = 0 ;
34794 PyObject * obj2 = 0 ;
34795 char *kwnames[] = {
34796 (char *) "self",(char *) "id",(char *) "enable", NULL
34797 };
34798
34799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34801 if (SWIG_arg_fail(1)) SWIG_fail;
34802 {
34803 arg2 = (int)(SWIG_As_int(obj1));
34804 if (SWIG_arg_fail(2)) SWIG_fail;
34805 }
34806 {
34807 arg3 = (bool)(SWIG_As_bool(obj2));
34808 if (SWIG_arg_fail(3)) SWIG_fail;
34809 }
34810 {
34811 PyThreadState* __tstate = wxPyBeginAllowThreads();
34812 (arg1)->Enable(arg2,arg3);
34813
34814 wxPyEndAllowThreads(__tstate);
34815 if (PyErr_Occurred()) SWIG_fail;
34816 }
34817 Py_INCREF(Py_None); resultobj = Py_None;
34818 return resultobj;
34819 fail:
34820 return NULL;
34821 }
34822
34823
34824 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34825 PyObject *resultobj;
34826 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34827 int arg2 ;
34828 bool arg3 ;
34829 PyObject * obj0 = 0 ;
34830 PyObject * obj1 = 0 ;
34831 PyObject * obj2 = 0 ;
34832 char *kwnames[] = {
34833 (char *) "self",(char *) "id",(char *) "check", NULL
34834 };
34835
34836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34838 if (SWIG_arg_fail(1)) SWIG_fail;
34839 {
34840 arg2 = (int)(SWIG_As_int(obj1));
34841 if (SWIG_arg_fail(2)) SWIG_fail;
34842 }
34843 {
34844 arg3 = (bool)(SWIG_As_bool(obj2));
34845 if (SWIG_arg_fail(3)) SWIG_fail;
34846 }
34847 {
34848 PyThreadState* __tstate = wxPyBeginAllowThreads();
34849 (arg1)->Check(arg2,arg3);
34850
34851 wxPyEndAllowThreads(__tstate);
34852 if (PyErr_Occurred()) SWIG_fail;
34853 }
34854 Py_INCREF(Py_None); resultobj = Py_None;
34855 return resultobj;
34856 fail:
34857 return NULL;
34858 }
34859
34860
34861 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34862 PyObject *resultobj;
34863 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34864 int arg2 ;
34865 bool result;
34866 PyObject * obj0 = 0 ;
34867 PyObject * obj1 = 0 ;
34868 char *kwnames[] = {
34869 (char *) "self",(char *) "id", NULL
34870 };
34871
34872 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34873 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34874 if (SWIG_arg_fail(1)) SWIG_fail;
34875 {
34876 arg2 = (int)(SWIG_As_int(obj1));
34877 if (SWIG_arg_fail(2)) SWIG_fail;
34878 }
34879 {
34880 PyThreadState* __tstate = wxPyBeginAllowThreads();
34881 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
34882
34883 wxPyEndAllowThreads(__tstate);
34884 if (PyErr_Occurred()) SWIG_fail;
34885 }
34886 {
34887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34888 }
34889 return resultobj;
34890 fail:
34891 return NULL;
34892 }
34893
34894
34895 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34896 PyObject *resultobj;
34897 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34898 int arg2 ;
34899 bool result;
34900 PyObject * obj0 = 0 ;
34901 PyObject * obj1 = 0 ;
34902 char *kwnames[] = {
34903 (char *) "self",(char *) "id", NULL
34904 };
34905
34906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34908 if (SWIG_arg_fail(1)) SWIG_fail;
34909 {
34910 arg2 = (int)(SWIG_As_int(obj1));
34911 if (SWIG_arg_fail(2)) SWIG_fail;
34912 }
34913 {
34914 PyThreadState* __tstate = wxPyBeginAllowThreads();
34915 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
34916
34917 wxPyEndAllowThreads(__tstate);
34918 if (PyErr_Occurred()) SWIG_fail;
34919 }
34920 {
34921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34922 }
34923 return resultobj;
34924 fail:
34925 return NULL;
34926 }
34927
34928
34929 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34930 PyObject *resultobj;
34931 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34932 int arg2 ;
34933 wxString *arg3 = 0 ;
34934 bool temp3 = false ;
34935 PyObject * obj0 = 0 ;
34936 PyObject * obj1 = 0 ;
34937 PyObject * obj2 = 0 ;
34938 char *kwnames[] = {
34939 (char *) "self",(char *) "id",(char *) "label", NULL
34940 };
34941
34942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34944 if (SWIG_arg_fail(1)) SWIG_fail;
34945 {
34946 arg2 = (int)(SWIG_As_int(obj1));
34947 if (SWIG_arg_fail(2)) SWIG_fail;
34948 }
34949 {
34950 arg3 = wxString_in_helper(obj2);
34951 if (arg3 == NULL) SWIG_fail;
34952 temp3 = true;
34953 }
34954 {
34955 PyThreadState* __tstate = wxPyBeginAllowThreads();
34956 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34957
34958 wxPyEndAllowThreads(__tstate);
34959 if (PyErr_Occurred()) SWIG_fail;
34960 }
34961 Py_INCREF(Py_None); resultobj = Py_None;
34962 {
34963 if (temp3)
34964 delete arg3;
34965 }
34966 return resultobj;
34967 fail:
34968 {
34969 if (temp3)
34970 delete arg3;
34971 }
34972 return NULL;
34973 }
34974
34975
34976 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34977 PyObject *resultobj;
34978 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34979 int arg2 ;
34980 wxString result;
34981 PyObject * obj0 = 0 ;
34982 PyObject * obj1 = 0 ;
34983 char *kwnames[] = {
34984 (char *) "self",(char *) "id", NULL
34985 };
34986
34987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34989 if (SWIG_arg_fail(1)) SWIG_fail;
34990 {
34991 arg2 = (int)(SWIG_As_int(obj1));
34992 if (SWIG_arg_fail(2)) SWIG_fail;
34993 }
34994 {
34995 PyThreadState* __tstate = wxPyBeginAllowThreads();
34996 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
34997
34998 wxPyEndAllowThreads(__tstate);
34999 if (PyErr_Occurred()) SWIG_fail;
35000 }
35001 {
35002 #if wxUSE_UNICODE
35003 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35004 #else
35005 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35006 #endif
35007 }
35008 return resultobj;
35009 fail:
35010 return NULL;
35011 }
35012
35013
35014 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35015 PyObject *resultobj;
35016 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35017 int arg2 ;
35018 wxString *arg3 = 0 ;
35019 bool temp3 = false ;
35020 PyObject * obj0 = 0 ;
35021 PyObject * obj1 = 0 ;
35022 PyObject * obj2 = 0 ;
35023 char *kwnames[] = {
35024 (char *) "self",(char *) "id",(char *) "helpString", NULL
35025 };
35026
35027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35029 if (SWIG_arg_fail(1)) SWIG_fail;
35030 {
35031 arg2 = (int)(SWIG_As_int(obj1));
35032 if (SWIG_arg_fail(2)) SWIG_fail;
35033 }
35034 {
35035 arg3 = wxString_in_helper(obj2);
35036 if (arg3 == NULL) SWIG_fail;
35037 temp3 = true;
35038 }
35039 {
35040 PyThreadState* __tstate = wxPyBeginAllowThreads();
35041 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35042
35043 wxPyEndAllowThreads(__tstate);
35044 if (PyErr_Occurred()) SWIG_fail;
35045 }
35046 Py_INCREF(Py_None); resultobj = Py_None;
35047 {
35048 if (temp3)
35049 delete arg3;
35050 }
35051 return resultobj;
35052 fail:
35053 {
35054 if (temp3)
35055 delete arg3;
35056 }
35057 return NULL;
35058 }
35059
35060
35061 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35062 PyObject *resultobj;
35063 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35064 int arg2 ;
35065 wxString result;
35066 PyObject * obj0 = 0 ;
35067 PyObject * obj1 = 0 ;
35068 char *kwnames[] = {
35069 (char *) "self",(char *) "id", NULL
35070 };
35071
35072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35074 if (SWIG_arg_fail(1)) SWIG_fail;
35075 {
35076 arg2 = (int)(SWIG_As_int(obj1));
35077 if (SWIG_arg_fail(2)) SWIG_fail;
35078 }
35079 {
35080 PyThreadState* __tstate = wxPyBeginAllowThreads();
35081 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35082
35083 wxPyEndAllowThreads(__tstate);
35084 if (PyErr_Occurred()) SWIG_fail;
35085 }
35086 {
35087 #if wxUSE_UNICODE
35088 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35089 #else
35090 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35091 #endif
35092 }
35093 return resultobj;
35094 fail:
35095 return NULL;
35096 }
35097
35098
35099 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35100 PyObject *resultobj;
35101 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35102 wxFrame *result;
35103 PyObject * obj0 = 0 ;
35104 char *kwnames[] = {
35105 (char *) "self", NULL
35106 };
35107
35108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35110 if (SWIG_arg_fail(1)) SWIG_fail;
35111 {
35112 PyThreadState* __tstate = wxPyBeginAllowThreads();
35113 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35114
35115 wxPyEndAllowThreads(__tstate);
35116 if (PyErr_Occurred()) SWIG_fail;
35117 }
35118 {
35119 resultobj = wxPyMake_wxObject(result, 0);
35120 }
35121 return resultobj;
35122 fail:
35123 return NULL;
35124 }
35125
35126
35127 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35128 PyObject *resultobj;
35129 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35130 bool result;
35131 PyObject * obj0 = 0 ;
35132 char *kwnames[] = {
35133 (char *) "self", NULL
35134 };
35135
35136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35138 if (SWIG_arg_fail(1)) SWIG_fail;
35139 {
35140 PyThreadState* __tstate = wxPyBeginAllowThreads();
35141 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35142
35143 wxPyEndAllowThreads(__tstate);
35144 if (PyErr_Occurred()) SWIG_fail;
35145 }
35146 {
35147 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35148 }
35149 return resultobj;
35150 fail:
35151 return NULL;
35152 }
35153
35154
35155 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35156 PyObject *resultobj;
35157 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35158 wxFrame *arg2 = (wxFrame *) 0 ;
35159 PyObject * obj0 = 0 ;
35160 PyObject * obj1 = 0 ;
35161 char *kwnames[] = {
35162 (char *) "self",(char *) "frame", NULL
35163 };
35164
35165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35167 if (SWIG_arg_fail(1)) SWIG_fail;
35168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35169 if (SWIG_arg_fail(2)) SWIG_fail;
35170 {
35171 PyThreadState* __tstate = wxPyBeginAllowThreads();
35172 (arg1)->Attach(arg2);
35173
35174 wxPyEndAllowThreads(__tstate);
35175 if (PyErr_Occurred()) SWIG_fail;
35176 }
35177 Py_INCREF(Py_None); resultobj = Py_None;
35178 return resultobj;
35179 fail:
35180 return NULL;
35181 }
35182
35183
35184 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35185 PyObject *resultobj;
35186 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35187 PyObject * obj0 = 0 ;
35188 char *kwnames[] = {
35189 (char *) "self", NULL
35190 };
35191
35192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
35193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35194 if (SWIG_arg_fail(1)) SWIG_fail;
35195 {
35196 PyThreadState* __tstate = wxPyBeginAllowThreads();
35197 (arg1)->Detach();
35198
35199 wxPyEndAllowThreads(__tstate);
35200 if (PyErr_Occurred()) SWIG_fail;
35201 }
35202 Py_INCREF(Py_None); resultobj = Py_None;
35203 return resultobj;
35204 fail:
35205 return NULL;
35206 }
35207
35208
35209 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35210 PyObject *obj;
35211 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35212 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35213 Py_INCREF(obj);
35214 return Py_BuildValue((char *)"");
35215 }
35216 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35217 PyObject *resultobj;
35218 wxMenu *arg1 = (wxMenu *) NULL ;
35219 int arg2 = (int) wxID_ANY ;
35220 wxString const &arg3_defvalue = wxPyEmptyString ;
35221 wxString *arg3 = (wxString *) &arg3_defvalue ;
35222 wxString const &arg4_defvalue = wxPyEmptyString ;
35223 wxString *arg4 = (wxString *) &arg4_defvalue ;
35224 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35225 wxMenu *arg6 = (wxMenu *) NULL ;
35226 wxMenuItem *result;
35227 bool temp3 = false ;
35228 bool temp4 = false ;
35229 PyObject * obj0 = 0 ;
35230 PyObject * obj1 = 0 ;
35231 PyObject * obj2 = 0 ;
35232 PyObject * obj3 = 0 ;
35233 PyObject * obj4 = 0 ;
35234 PyObject * obj5 = 0 ;
35235 char *kwnames[] = {
35236 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35237 };
35238
35239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35240 if (obj0) {
35241 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35242 if (SWIG_arg_fail(1)) SWIG_fail;
35243 }
35244 if (obj1) {
35245 {
35246 arg2 = (int)(SWIG_As_int(obj1));
35247 if (SWIG_arg_fail(2)) SWIG_fail;
35248 }
35249 }
35250 if (obj2) {
35251 {
35252 arg3 = wxString_in_helper(obj2);
35253 if (arg3 == NULL) SWIG_fail;
35254 temp3 = true;
35255 }
35256 }
35257 if (obj3) {
35258 {
35259 arg4 = wxString_in_helper(obj3);
35260 if (arg4 == NULL) SWIG_fail;
35261 temp4 = true;
35262 }
35263 }
35264 if (obj4) {
35265 {
35266 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35267 if (SWIG_arg_fail(5)) SWIG_fail;
35268 }
35269 }
35270 if (obj5) {
35271 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35272 if (SWIG_arg_fail(6)) SWIG_fail;
35273 }
35274 {
35275 PyThreadState* __tstate = wxPyBeginAllowThreads();
35276 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35277
35278 wxPyEndAllowThreads(__tstate);
35279 if (PyErr_Occurred()) SWIG_fail;
35280 }
35281 {
35282 resultobj = wxPyMake_wxObject(result, 1);
35283 }
35284 {
35285 if (temp3)
35286 delete arg3;
35287 }
35288 {
35289 if (temp4)
35290 delete arg4;
35291 }
35292 return resultobj;
35293 fail:
35294 {
35295 if (temp3)
35296 delete arg3;
35297 }
35298 {
35299 if (temp4)
35300 delete arg4;
35301 }
35302 return NULL;
35303 }
35304
35305
35306 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35307 PyObject *resultobj;
35308 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35309 wxMenu *result;
35310 PyObject * obj0 = 0 ;
35311 char *kwnames[] = {
35312 (char *) "self", NULL
35313 };
35314
35315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35317 if (SWIG_arg_fail(1)) SWIG_fail;
35318 {
35319 PyThreadState* __tstate = wxPyBeginAllowThreads();
35320 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35321
35322 wxPyEndAllowThreads(__tstate);
35323 if (PyErr_Occurred()) SWIG_fail;
35324 }
35325 {
35326 resultobj = wxPyMake_wxObject(result, 0);
35327 }
35328 return resultobj;
35329 fail:
35330 return NULL;
35331 }
35332
35333
35334 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35335 PyObject *resultobj;
35336 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35337 wxMenu *arg2 = (wxMenu *) 0 ;
35338 PyObject * obj0 = 0 ;
35339 PyObject * obj1 = 0 ;
35340 char *kwnames[] = {
35341 (char *) "self",(char *) "menu", NULL
35342 };
35343
35344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35346 if (SWIG_arg_fail(1)) SWIG_fail;
35347 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35348 if (SWIG_arg_fail(2)) SWIG_fail;
35349 {
35350 PyThreadState* __tstate = wxPyBeginAllowThreads();
35351 (arg1)->SetMenu(arg2);
35352
35353 wxPyEndAllowThreads(__tstate);
35354 if (PyErr_Occurred()) SWIG_fail;
35355 }
35356 Py_INCREF(Py_None); resultobj = Py_None;
35357 return resultobj;
35358 fail:
35359 return NULL;
35360 }
35361
35362
35363 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
35364 PyObject *resultobj;
35365 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35366 int arg2 ;
35367 PyObject * obj0 = 0 ;
35368 PyObject * obj1 = 0 ;
35369 char *kwnames[] = {
35370 (char *) "self",(char *) "id", NULL
35371 };
35372
35373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
35374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35375 if (SWIG_arg_fail(1)) SWIG_fail;
35376 {
35377 arg2 = (int)(SWIG_As_int(obj1));
35378 if (SWIG_arg_fail(2)) SWIG_fail;
35379 }
35380 {
35381 PyThreadState* __tstate = wxPyBeginAllowThreads();
35382 (arg1)->SetId(arg2);
35383
35384 wxPyEndAllowThreads(__tstate);
35385 if (PyErr_Occurred()) SWIG_fail;
35386 }
35387 Py_INCREF(Py_None); resultobj = Py_None;
35388 return resultobj;
35389 fail:
35390 return NULL;
35391 }
35392
35393
35394 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
35395 PyObject *resultobj;
35396 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35397 int result;
35398 PyObject * obj0 = 0 ;
35399 char *kwnames[] = {
35400 (char *) "self", NULL
35401 };
35402
35403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
35404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35405 if (SWIG_arg_fail(1)) SWIG_fail;
35406 {
35407 PyThreadState* __tstate = wxPyBeginAllowThreads();
35408 result = (int)((wxMenuItem const *)arg1)->GetId();
35409
35410 wxPyEndAllowThreads(__tstate);
35411 if (PyErr_Occurred()) SWIG_fail;
35412 }
35413 {
35414 resultobj = SWIG_From_int((int)(result));
35415 }
35416 return resultobj;
35417 fail:
35418 return NULL;
35419 }
35420
35421
35422 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
35423 PyObject *resultobj;
35424 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35425 bool result;
35426 PyObject * obj0 = 0 ;
35427 char *kwnames[] = {
35428 (char *) "self", NULL
35429 };
35430
35431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
35432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35433 if (SWIG_arg_fail(1)) SWIG_fail;
35434 {
35435 PyThreadState* __tstate = wxPyBeginAllowThreads();
35436 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
35437
35438 wxPyEndAllowThreads(__tstate);
35439 if (PyErr_Occurred()) SWIG_fail;
35440 }
35441 {
35442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35443 }
35444 return resultobj;
35445 fail:
35446 return NULL;
35447 }
35448
35449
35450 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
35451 PyObject *resultobj;
35452 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35453 wxString *arg2 = 0 ;
35454 bool temp2 = false ;
35455 PyObject * obj0 = 0 ;
35456 PyObject * obj1 = 0 ;
35457 char *kwnames[] = {
35458 (char *) "self",(char *) "str", NULL
35459 };
35460
35461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
35462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35463 if (SWIG_arg_fail(1)) SWIG_fail;
35464 {
35465 arg2 = wxString_in_helper(obj1);
35466 if (arg2 == NULL) SWIG_fail;
35467 temp2 = true;
35468 }
35469 {
35470 PyThreadState* __tstate = wxPyBeginAllowThreads();
35471 (arg1)->SetText((wxString const &)*arg2);
35472
35473 wxPyEndAllowThreads(__tstate);
35474 if (PyErr_Occurred()) SWIG_fail;
35475 }
35476 Py_INCREF(Py_None); resultobj = Py_None;
35477 {
35478 if (temp2)
35479 delete arg2;
35480 }
35481 return resultobj;
35482 fail:
35483 {
35484 if (temp2)
35485 delete arg2;
35486 }
35487 return NULL;
35488 }
35489
35490
35491 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35492 PyObject *resultobj;
35493 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35494 wxString result;
35495 PyObject * obj0 = 0 ;
35496 char *kwnames[] = {
35497 (char *) "self", NULL
35498 };
35499
35500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
35501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35502 if (SWIG_arg_fail(1)) SWIG_fail;
35503 {
35504 PyThreadState* __tstate = wxPyBeginAllowThreads();
35505 result = ((wxMenuItem const *)arg1)->GetLabel();
35506
35507 wxPyEndAllowThreads(__tstate);
35508 if (PyErr_Occurred()) SWIG_fail;
35509 }
35510 {
35511 #if wxUSE_UNICODE
35512 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35513 #else
35514 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35515 #endif
35516 }
35517 return resultobj;
35518 fail:
35519 return NULL;
35520 }
35521
35522
35523 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
35524 PyObject *resultobj;
35525 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35526 wxString *result;
35527 PyObject * obj0 = 0 ;
35528 char *kwnames[] = {
35529 (char *) "self", NULL
35530 };
35531
35532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
35533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35534 if (SWIG_arg_fail(1)) SWIG_fail;
35535 {
35536 PyThreadState* __tstate = wxPyBeginAllowThreads();
35537 {
35538 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
35539 result = (wxString *) &_result_ref;
35540 }
35541
35542 wxPyEndAllowThreads(__tstate);
35543 if (PyErr_Occurred()) SWIG_fail;
35544 }
35545 {
35546 #if wxUSE_UNICODE
35547 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
35548 #else
35549 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
35550 #endif
35551 }
35552 return resultobj;
35553 fail:
35554 return NULL;
35555 }
35556
35557
35558 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
35559 PyObject *resultobj;
35560 wxString *arg1 = 0 ;
35561 wxString result;
35562 bool temp1 = false ;
35563 PyObject * obj0 = 0 ;
35564 char *kwnames[] = {
35565 (char *) "text", NULL
35566 };
35567
35568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
35569 {
35570 arg1 = wxString_in_helper(obj0);
35571 if (arg1 == NULL) SWIG_fail;
35572 temp1 = true;
35573 }
35574 {
35575 PyThreadState* __tstate = wxPyBeginAllowThreads();
35576 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
35577
35578 wxPyEndAllowThreads(__tstate);
35579 if (PyErr_Occurred()) SWIG_fail;
35580 }
35581 {
35582 #if wxUSE_UNICODE
35583 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35584 #else
35585 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35586 #endif
35587 }
35588 {
35589 if (temp1)
35590 delete arg1;
35591 }
35592 return resultobj;
35593 fail:
35594 {
35595 if (temp1)
35596 delete arg1;
35597 }
35598 return NULL;
35599 }
35600
35601
35602 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35603 PyObject *resultobj;
35604 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35605 wxItemKind result;
35606 PyObject * obj0 = 0 ;
35607 char *kwnames[] = {
35608 (char *) "self", NULL
35609 };
35610
35611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
35612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35613 if (SWIG_arg_fail(1)) SWIG_fail;
35614 {
35615 PyThreadState* __tstate = wxPyBeginAllowThreads();
35616 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
35617
35618 wxPyEndAllowThreads(__tstate);
35619 if (PyErr_Occurred()) SWIG_fail;
35620 }
35621 resultobj = SWIG_From_int((result));
35622 return resultobj;
35623 fail:
35624 return NULL;
35625 }
35626
35627
35628 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
35629 PyObject *resultobj;
35630 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35631 wxItemKind arg2 ;
35632 PyObject * obj0 = 0 ;
35633 PyObject * obj1 = 0 ;
35634 char *kwnames[] = {
35635 (char *) "self",(char *) "kind", NULL
35636 };
35637
35638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
35639 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35640 if (SWIG_arg_fail(1)) SWIG_fail;
35641 {
35642 arg2 = (wxItemKind)(SWIG_As_int(obj1));
35643 if (SWIG_arg_fail(2)) SWIG_fail;
35644 }
35645 {
35646 PyThreadState* __tstate = wxPyBeginAllowThreads();
35647 (arg1)->SetKind((wxItemKind )arg2);
35648
35649 wxPyEndAllowThreads(__tstate);
35650 if (PyErr_Occurred()) SWIG_fail;
35651 }
35652 Py_INCREF(Py_None); resultobj = Py_None;
35653 return resultobj;
35654 fail:
35655 return NULL;
35656 }
35657
35658
35659 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35660 PyObject *resultobj;
35661 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35662 bool arg2 ;
35663 PyObject * obj0 = 0 ;
35664 PyObject * obj1 = 0 ;
35665 char *kwnames[] = {
35666 (char *) "self",(char *) "checkable", NULL
35667 };
35668
35669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
35670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35671 if (SWIG_arg_fail(1)) SWIG_fail;
35672 {
35673 arg2 = (bool)(SWIG_As_bool(obj1));
35674 if (SWIG_arg_fail(2)) SWIG_fail;
35675 }
35676 {
35677 PyThreadState* __tstate = wxPyBeginAllowThreads();
35678 (arg1)->SetCheckable(arg2);
35679
35680 wxPyEndAllowThreads(__tstate);
35681 if (PyErr_Occurred()) SWIG_fail;
35682 }
35683 Py_INCREF(Py_None); resultobj = Py_None;
35684 return resultobj;
35685 fail:
35686 return NULL;
35687 }
35688
35689
35690 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
35691 PyObject *resultobj;
35692 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35693 bool result;
35694 PyObject * obj0 = 0 ;
35695 char *kwnames[] = {
35696 (char *) "self", NULL
35697 };
35698
35699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
35700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35701 if (SWIG_arg_fail(1)) SWIG_fail;
35702 {
35703 PyThreadState* __tstate = wxPyBeginAllowThreads();
35704 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
35705
35706 wxPyEndAllowThreads(__tstate);
35707 if (PyErr_Occurred()) SWIG_fail;
35708 }
35709 {
35710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35711 }
35712 return resultobj;
35713 fail:
35714 return NULL;
35715 }
35716
35717
35718 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35719 PyObject *resultobj;
35720 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35721 bool result;
35722 PyObject * obj0 = 0 ;
35723 char *kwnames[] = {
35724 (char *) "self", NULL
35725 };
35726
35727 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
35728 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35729 if (SWIG_arg_fail(1)) SWIG_fail;
35730 {
35731 PyThreadState* __tstate = wxPyBeginAllowThreads();
35732 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
35733
35734 wxPyEndAllowThreads(__tstate);
35735 if (PyErr_Occurred()) SWIG_fail;
35736 }
35737 {
35738 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35739 }
35740 return resultobj;
35741 fail:
35742 return NULL;
35743 }
35744
35745
35746 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35747 PyObject *resultobj;
35748 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35749 wxMenu *arg2 = (wxMenu *) 0 ;
35750 PyObject * obj0 = 0 ;
35751 PyObject * obj1 = 0 ;
35752 char *kwnames[] = {
35753 (char *) "self",(char *) "menu", NULL
35754 };
35755
35756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
35757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35758 if (SWIG_arg_fail(1)) SWIG_fail;
35759 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35760 if (SWIG_arg_fail(2)) SWIG_fail;
35761 {
35762 PyThreadState* __tstate = wxPyBeginAllowThreads();
35763 (arg1)->SetSubMenu(arg2);
35764
35765 wxPyEndAllowThreads(__tstate);
35766 if (PyErr_Occurred()) SWIG_fail;
35767 }
35768 Py_INCREF(Py_None); resultobj = Py_None;
35769 return resultobj;
35770 fail:
35771 return NULL;
35772 }
35773
35774
35775 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35776 PyObject *resultobj;
35777 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35778 wxMenu *result;
35779 PyObject * obj0 = 0 ;
35780 char *kwnames[] = {
35781 (char *) "self", NULL
35782 };
35783
35784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
35785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35786 if (SWIG_arg_fail(1)) SWIG_fail;
35787 {
35788 PyThreadState* __tstate = wxPyBeginAllowThreads();
35789 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
35790
35791 wxPyEndAllowThreads(__tstate);
35792 if (PyErr_Occurred()) SWIG_fail;
35793 }
35794 {
35795 resultobj = wxPyMake_wxObject(result, 0);
35796 }
35797 return resultobj;
35798 fail:
35799 return NULL;
35800 }
35801
35802
35803 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35804 PyObject *resultobj;
35805 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35806 bool arg2 = (bool) true ;
35807 PyObject * obj0 = 0 ;
35808 PyObject * obj1 = 0 ;
35809 char *kwnames[] = {
35810 (char *) "self",(char *) "enable", NULL
35811 };
35812
35813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
35814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35815 if (SWIG_arg_fail(1)) SWIG_fail;
35816 if (obj1) {
35817 {
35818 arg2 = (bool)(SWIG_As_bool(obj1));
35819 if (SWIG_arg_fail(2)) SWIG_fail;
35820 }
35821 }
35822 {
35823 PyThreadState* __tstate = wxPyBeginAllowThreads();
35824 (arg1)->Enable(arg2);
35825
35826 wxPyEndAllowThreads(__tstate);
35827 if (PyErr_Occurred()) SWIG_fail;
35828 }
35829 Py_INCREF(Py_None); resultobj = Py_None;
35830 return resultobj;
35831 fail:
35832 return NULL;
35833 }
35834
35835
35836 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35837 PyObject *resultobj;
35838 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35839 bool result;
35840 PyObject * obj0 = 0 ;
35841 char *kwnames[] = {
35842 (char *) "self", NULL
35843 };
35844
35845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
35846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35847 if (SWIG_arg_fail(1)) SWIG_fail;
35848 {
35849 PyThreadState* __tstate = wxPyBeginAllowThreads();
35850 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
35851
35852 wxPyEndAllowThreads(__tstate);
35853 if (PyErr_Occurred()) SWIG_fail;
35854 }
35855 {
35856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35857 }
35858 return resultobj;
35859 fail:
35860 return NULL;
35861 }
35862
35863
35864 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35865 PyObject *resultobj;
35866 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35867 bool arg2 = (bool) true ;
35868 PyObject * obj0 = 0 ;
35869 PyObject * obj1 = 0 ;
35870 char *kwnames[] = {
35871 (char *) "self",(char *) "check", NULL
35872 };
35873
35874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
35875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35876 if (SWIG_arg_fail(1)) SWIG_fail;
35877 if (obj1) {
35878 {
35879 arg2 = (bool)(SWIG_As_bool(obj1));
35880 if (SWIG_arg_fail(2)) SWIG_fail;
35881 }
35882 }
35883 {
35884 PyThreadState* __tstate = wxPyBeginAllowThreads();
35885 (arg1)->Check(arg2);
35886
35887 wxPyEndAllowThreads(__tstate);
35888 if (PyErr_Occurred()) SWIG_fail;
35889 }
35890 Py_INCREF(Py_None); resultobj = Py_None;
35891 return resultobj;
35892 fail:
35893 return NULL;
35894 }
35895
35896
35897 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35898 PyObject *resultobj;
35899 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35900 bool result;
35901 PyObject * obj0 = 0 ;
35902 char *kwnames[] = {
35903 (char *) "self", NULL
35904 };
35905
35906 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
35907 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35908 if (SWIG_arg_fail(1)) SWIG_fail;
35909 {
35910 PyThreadState* __tstate = wxPyBeginAllowThreads();
35911 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
35912
35913 wxPyEndAllowThreads(__tstate);
35914 if (PyErr_Occurred()) SWIG_fail;
35915 }
35916 {
35917 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35918 }
35919 return resultobj;
35920 fail:
35921 return NULL;
35922 }
35923
35924
35925 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
35926 PyObject *resultobj;
35927 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35928 PyObject * obj0 = 0 ;
35929 char *kwnames[] = {
35930 (char *) "self", NULL
35931 };
35932
35933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
35934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35935 if (SWIG_arg_fail(1)) SWIG_fail;
35936 {
35937 PyThreadState* __tstate = wxPyBeginAllowThreads();
35938 (arg1)->Toggle();
35939
35940 wxPyEndAllowThreads(__tstate);
35941 if (PyErr_Occurred()) SWIG_fail;
35942 }
35943 Py_INCREF(Py_None); resultobj = Py_None;
35944 return resultobj;
35945 fail:
35946 return NULL;
35947 }
35948
35949
35950 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
35951 PyObject *resultobj;
35952 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35953 wxString *arg2 = 0 ;
35954 bool temp2 = false ;
35955 PyObject * obj0 = 0 ;
35956 PyObject * obj1 = 0 ;
35957 char *kwnames[] = {
35958 (char *) "self",(char *) "str", NULL
35959 };
35960
35961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
35962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35963 if (SWIG_arg_fail(1)) SWIG_fail;
35964 {
35965 arg2 = wxString_in_helper(obj1);
35966 if (arg2 == NULL) SWIG_fail;
35967 temp2 = true;
35968 }
35969 {
35970 PyThreadState* __tstate = wxPyBeginAllowThreads();
35971 (arg1)->SetHelp((wxString const &)*arg2);
35972
35973 wxPyEndAllowThreads(__tstate);
35974 if (PyErr_Occurred()) SWIG_fail;
35975 }
35976 Py_INCREF(Py_None); resultobj = Py_None;
35977 {
35978 if (temp2)
35979 delete arg2;
35980 }
35981 return resultobj;
35982 fail:
35983 {
35984 if (temp2)
35985 delete arg2;
35986 }
35987 return NULL;
35988 }
35989
35990
35991 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
35992 PyObject *resultobj;
35993 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35994 wxString *result;
35995 PyObject * obj0 = 0 ;
35996 char *kwnames[] = {
35997 (char *) "self", NULL
35998 };
35999
36000 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36001 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36002 if (SWIG_arg_fail(1)) SWIG_fail;
36003 {
36004 PyThreadState* __tstate = wxPyBeginAllowThreads();
36005 {
36006 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36007 result = (wxString *) &_result_ref;
36008 }
36009
36010 wxPyEndAllowThreads(__tstate);
36011 if (PyErr_Occurred()) SWIG_fail;
36012 }
36013 {
36014 #if wxUSE_UNICODE
36015 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36016 #else
36017 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36018 #endif
36019 }
36020 return resultobj;
36021 fail:
36022 return NULL;
36023 }
36024
36025
36026 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36027 PyObject *resultobj;
36028 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36029 wxAcceleratorEntry *result;
36030 PyObject * obj0 = 0 ;
36031 char *kwnames[] = {
36032 (char *) "self", NULL
36033 };
36034
36035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36037 if (SWIG_arg_fail(1)) SWIG_fail;
36038 {
36039 PyThreadState* __tstate = wxPyBeginAllowThreads();
36040 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36041
36042 wxPyEndAllowThreads(__tstate);
36043 if (PyErr_Occurred()) SWIG_fail;
36044 }
36045 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36046 return resultobj;
36047 fail:
36048 return NULL;
36049 }
36050
36051
36052 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36053 PyObject *resultobj;
36054 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36055 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36056 PyObject * obj0 = 0 ;
36057 PyObject * obj1 = 0 ;
36058 char *kwnames[] = {
36059 (char *) "self",(char *) "accel", NULL
36060 };
36061
36062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36064 if (SWIG_arg_fail(1)) SWIG_fail;
36065 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36066 if (SWIG_arg_fail(2)) SWIG_fail;
36067 {
36068 PyThreadState* __tstate = wxPyBeginAllowThreads();
36069 (arg1)->SetAccel(arg2);
36070
36071 wxPyEndAllowThreads(__tstate);
36072 if (PyErr_Occurred()) SWIG_fail;
36073 }
36074 Py_INCREF(Py_None); resultobj = Py_None;
36075 return resultobj;
36076 fail:
36077 return NULL;
36078 }
36079
36080
36081 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
36082 PyObject *resultobj;
36083 int result;
36084 char *kwnames[] = {
36085 NULL
36086 };
36087
36088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
36089 {
36090 PyThreadState* __tstate = wxPyBeginAllowThreads();
36091 result = (int)MenuItem_GetDefaultMarginWidth();
36092
36093 wxPyEndAllowThreads(__tstate);
36094 if (PyErr_Occurred()) SWIG_fail;
36095 }
36096 {
36097 resultobj = SWIG_From_int((int)(result));
36098 }
36099 return resultobj;
36100 fail:
36101 return NULL;
36102 }
36103
36104
36105 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36106 PyObject *resultobj;
36107 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36108 wxBitmap *arg2 = 0 ;
36109 PyObject * obj0 = 0 ;
36110 PyObject * obj1 = 0 ;
36111 char *kwnames[] = {
36112 (char *) "self",(char *) "bitmap", NULL
36113 };
36114
36115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
36116 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36117 if (SWIG_arg_fail(1)) SWIG_fail;
36118 {
36119 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36120 if (SWIG_arg_fail(2)) SWIG_fail;
36121 if (arg2 == NULL) {
36122 SWIG_null_ref("wxBitmap");
36123 }
36124 if (SWIG_arg_fail(2)) SWIG_fail;
36125 }
36126 {
36127 PyThreadState* __tstate = wxPyBeginAllowThreads();
36128 (arg1)->SetBitmap((wxBitmap const &)*arg2);
36129
36130 wxPyEndAllowThreads(__tstate);
36131 if (PyErr_Occurred()) SWIG_fail;
36132 }
36133 Py_INCREF(Py_None); resultobj = Py_None;
36134 return resultobj;
36135 fail:
36136 return NULL;
36137 }
36138
36139
36140 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36141 PyObject *resultobj;
36142 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36143 wxBitmap *result;
36144 PyObject * obj0 = 0 ;
36145 char *kwnames[] = {
36146 (char *) "self", NULL
36147 };
36148
36149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
36150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36151 if (SWIG_arg_fail(1)) SWIG_fail;
36152 {
36153 PyThreadState* __tstate = wxPyBeginAllowThreads();
36154 {
36155 wxBitmap const &_result_ref = (arg1)->GetBitmap();
36156 result = (wxBitmap *) &_result_ref;
36157 }
36158
36159 wxPyEndAllowThreads(__tstate);
36160 if (PyErr_Occurred()) SWIG_fail;
36161 }
36162 {
36163 wxBitmap* resultptr = new wxBitmap(*result);
36164 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
36165 }
36166 return resultobj;
36167 fail:
36168 return NULL;
36169 }
36170
36171
36172 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
36173 PyObject *obj;
36174 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36175 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
36176 Py_INCREF(obj);
36177 return Py_BuildValue((char *)"");
36178 }
36179 static int _wrap_ControlNameStr_set(PyObject *) {
36180 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
36181 return 1;
36182 }
36183
36184
36185 static PyObject *_wrap_ControlNameStr_get(void) {
36186 PyObject *pyobj;
36187
36188 {
36189 #if wxUSE_UNICODE
36190 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36191 #else
36192 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
36193 #endif
36194 }
36195 return pyobj;
36196 }
36197
36198
36199 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
36200 PyObject *resultobj;
36201 wxWindow *arg1 = (wxWindow *) 0 ;
36202 int arg2 = (int) -1 ;
36203 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36204 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36205 wxSize const &arg4_defvalue = wxDefaultSize ;
36206 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
36207 long arg5 = (long) 0 ;
36208 wxValidator const &arg6_defvalue = wxDefaultValidator ;
36209 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
36210 wxString const &arg7_defvalue = wxPyControlNameStr ;
36211 wxString *arg7 = (wxString *) &arg7_defvalue ;
36212 wxControl *result;
36213 wxPoint temp3 ;
36214 wxSize temp4 ;
36215 bool temp7 = false ;
36216 PyObject * obj0 = 0 ;
36217 PyObject * obj1 = 0 ;
36218 PyObject * obj2 = 0 ;
36219 PyObject * obj3 = 0 ;
36220 PyObject * obj4 = 0 ;
36221 PyObject * obj5 = 0 ;
36222 PyObject * obj6 = 0 ;
36223 char *kwnames[] = {
36224 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36225 };
36226
36227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
36228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36229 if (SWIG_arg_fail(1)) SWIG_fail;
36230 if (obj1) {
36231 {
36232 arg2 = (int)(SWIG_As_int(obj1));
36233 if (SWIG_arg_fail(2)) SWIG_fail;
36234 }
36235 }
36236 if (obj2) {
36237 {
36238 arg3 = &temp3;
36239 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36240 }
36241 }
36242 if (obj3) {
36243 {
36244 arg4 = &temp4;
36245 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
36246 }
36247 }
36248 if (obj4) {
36249 {
36250 arg5 = (long)(SWIG_As_long(obj4));
36251 if (SWIG_arg_fail(5)) SWIG_fail;
36252 }
36253 }
36254 if (obj5) {
36255 {
36256 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36257 if (SWIG_arg_fail(6)) SWIG_fail;
36258 if (arg6 == NULL) {
36259 SWIG_null_ref("wxValidator");
36260 }
36261 if (SWIG_arg_fail(6)) SWIG_fail;
36262 }
36263 }
36264 if (obj6) {
36265 {
36266 arg7 = wxString_in_helper(obj6);
36267 if (arg7 == NULL) SWIG_fail;
36268 temp7 = true;
36269 }
36270 }
36271 {
36272 if (!wxPyCheckForApp()) SWIG_fail;
36273 PyThreadState* __tstate = wxPyBeginAllowThreads();
36274 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
36275
36276 wxPyEndAllowThreads(__tstate);
36277 if (PyErr_Occurred()) SWIG_fail;
36278 }
36279 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36280 {
36281 if (temp7)
36282 delete arg7;
36283 }
36284 return resultobj;
36285 fail:
36286 {
36287 if (temp7)
36288 delete arg7;
36289 }
36290 return NULL;
36291 }
36292
36293
36294 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
36295 PyObject *resultobj;
36296 wxControl *result;
36297 char *kwnames[] = {
36298 NULL
36299 };
36300
36301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
36302 {
36303 if (!wxPyCheckForApp()) SWIG_fail;
36304 PyThreadState* __tstate = wxPyBeginAllowThreads();
36305 result = (wxControl *)new wxControl();
36306
36307 wxPyEndAllowThreads(__tstate);
36308 if (PyErr_Occurred()) SWIG_fail;
36309 }
36310 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
36311 return resultobj;
36312 fail:
36313 return NULL;
36314 }
36315
36316
36317 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
36318 PyObject *resultobj;
36319 wxControl *arg1 = (wxControl *) 0 ;
36320 wxWindow *arg2 = (wxWindow *) 0 ;
36321 int arg3 = (int) -1 ;
36322 wxPoint const &arg4_defvalue = wxDefaultPosition ;
36323 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
36324 wxSize const &arg5_defvalue = wxDefaultSize ;
36325 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
36326 long arg6 = (long) 0 ;
36327 wxValidator const &arg7_defvalue = wxDefaultValidator ;
36328 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
36329 wxString const &arg8_defvalue = wxPyControlNameStr ;
36330 wxString *arg8 = (wxString *) &arg8_defvalue ;
36331 bool result;
36332 wxPoint temp4 ;
36333 wxSize temp5 ;
36334 bool temp8 = false ;
36335 PyObject * obj0 = 0 ;
36336 PyObject * obj1 = 0 ;
36337 PyObject * obj2 = 0 ;
36338 PyObject * obj3 = 0 ;
36339 PyObject * obj4 = 0 ;
36340 PyObject * obj5 = 0 ;
36341 PyObject * obj6 = 0 ;
36342 PyObject * obj7 = 0 ;
36343 char *kwnames[] = {
36344 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
36345 };
36346
36347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
36348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36349 if (SWIG_arg_fail(1)) SWIG_fail;
36350 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
36351 if (SWIG_arg_fail(2)) SWIG_fail;
36352 if (obj2) {
36353 {
36354 arg3 = (int)(SWIG_As_int(obj2));
36355 if (SWIG_arg_fail(3)) SWIG_fail;
36356 }
36357 }
36358 if (obj3) {
36359 {
36360 arg4 = &temp4;
36361 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
36362 }
36363 }
36364 if (obj4) {
36365 {
36366 arg5 = &temp5;
36367 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
36368 }
36369 }
36370 if (obj5) {
36371 {
36372 arg6 = (long)(SWIG_As_long(obj5));
36373 if (SWIG_arg_fail(6)) SWIG_fail;
36374 }
36375 }
36376 if (obj6) {
36377 {
36378 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
36379 if (SWIG_arg_fail(7)) SWIG_fail;
36380 if (arg7 == NULL) {
36381 SWIG_null_ref("wxValidator");
36382 }
36383 if (SWIG_arg_fail(7)) SWIG_fail;
36384 }
36385 }
36386 if (obj7) {
36387 {
36388 arg8 = wxString_in_helper(obj7);
36389 if (arg8 == NULL) SWIG_fail;
36390 temp8 = true;
36391 }
36392 }
36393 {
36394 PyThreadState* __tstate = wxPyBeginAllowThreads();
36395 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
36396
36397 wxPyEndAllowThreads(__tstate);
36398 if (PyErr_Occurred()) SWIG_fail;
36399 }
36400 {
36401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36402 }
36403 {
36404 if (temp8)
36405 delete arg8;
36406 }
36407 return resultobj;
36408 fail:
36409 {
36410 if (temp8)
36411 delete arg8;
36412 }
36413 return NULL;
36414 }
36415
36416
36417 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
36418 PyObject *resultobj;
36419 wxControl *arg1 = (wxControl *) 0 ;
36420 wxCommandEvent *arg2 = 0 ;
36421 PyObject * obj0 = 0 ;
36422 PyObject * obj1 = 0 ;
36423 char *kwnames[] = {
36424 (char *) "self",(char *) "event", NULL
36425 };
36426
36427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
36428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36429 if (SWIG_arg_fail(1)) SWIG_fail;
36430 {
36431 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
36432 if (SWIG_arg_fail(2)) SWIG_fail;
36433 if (arg2 == NULL) {
36434 SWIG_null_ref("wxCommandEvent");
36435 }
36436 if (SWIG_arg_fail(2)) SWIG_fail;
36437 }
36438 {
36439 PyThreadState* __tstate = wxPyBeginAllowThreads();
36440 (arg1)->Command(*arg2);
36441
36442 wxPyEndAllowThreads(__tstate);
36443 if (PyErr_Occurred()) SWIG_fail;
36444 }
36445 Py_INCREF(Py_None); resultobj = Py_None;
36446 return resultobj;
36447 fail:
36448 return NULL;
36449 }
36450
36451
36452 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36453 PyObject *resultobj;
36454 wxControl *arg1 = (wxControl *) 0 ;
36455 wxString result;
36456 PyObject * obj0 = 0 ;
36457 char *kwnames[] = {
36458 (char *) "self", NULL
36459 };
36460
36461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
36462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36463 if (SWIG_arg_fail(1)) SWIG_fail;
36464 {
36465 PyThreadState* __tstate = wxPyBeginAllowThreads();
36466 result = (arg1)->GetLabel();
36467
36468 wxPyEndAllowThreads(__tstate);
36469 if (PyErr_Occurred()) SWIG_fail;
36470 }
36471 {
36472 #if wxUSE_UNICODE
36473 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36474 #else
36475 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36476 #endif
36477 }
36478 return resultobj;
36479 fail:
36480 return NULL;
36481 }
36482
36483
36484 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36485 PyObject *resultobj;
36486 wxControl *arg1 = (wxControl *) 0 ;
36487 wxString *arg2 = 0 ;
36488 bool temp2 = false ;
36489 PyObject * obj0 = 0 ;
36490 PyObject * obj1 = 0 ;
36491 char *kwnames[] = {
36492 (char *) "self",(char *) "label", NULL
36493 };
36494
36495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
36496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
36497 if (SWIG_arg_fail(1)) SWIG_fail;
36498 {
36499 arg2 = wxString_in_helper(obj1);
36500 if (arg2 == NULL) SWIG_fail;
36501 temp2 = true;
36502 }
36503 {
36504 PyThreadState* __tstate = wxPyBeginAllowThreads();
36505 (arg1)->SetLabel((wxString const &)*arg2);
36506
36507 wxPyEndAllowThreads(__tstate);
36508 if (PyErr_Occurred()) SWIG_fail;
36509 }
36510 Py_INCREF(Py_None); resultobj = Py_None;
36511 {
36512 if (temp2)
36513 delete arg2;
36514 }
36515 return resultobj;
36516 fail:
36517 {
36518 if (temp2)
36519 delete arg2;
36520 }
36521 return NULL;
36522 }
36523
36524
36525 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
36526 PyObject *resultobj;
36527 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
36528 wxVisualAttributes result;
36529 PyObject * obj0 = 0 ;
36530 char *kwnames[] = {
36531 (char *) "variant", NULL
36532 };
36533
36534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
36535 if (obj0) {
36536 {
36537 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
36538 if (SWIG_arg_fail(1)) SWIG_fail;
36539 }
36540 }
36541 {
36542 if (!wxPyCheckForApp()) SWIG_fail;
36543 PyThreadState* __tstate = wxPyBeginAllowThreads();
36544 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
36545
36546 wxPyEndAllowThreads(__tstate);
36547 if (PyErr_Occurred()) SWIG_fail;
36548 }
36549 {
36550 wxVisualAttributes * resultptr;
36551 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
36552 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
36553 }
36554 return resultobj;
36555 fail:
36556 return NULL;
36557 }
36558
36559
36560 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
36561 PyObject *obj;
36562 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36563 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
36564 Py_INCREF(obj);
36565 return Py_BuildValue((char *)"");
36566 }
36567 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
36568 PyObject *resultobj;
36569 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36570 wxString *arg2 = 0 ;
36571 PyObject *arg3 = (PyObject *) NULL ;
36572 int result;
36573 bool temp2 = false ;
36574 PyObject * obj0 = 0 ;
36575 PyObject * obj1 = 0 ;
36576 PyObject * obj2 = 0 ;
36577 char *kwnames[] = {
36578 (char *) "self",(char *) "item",(char *) "clientData", NULL
36579 };
36580
36581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
36582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36583 if (SWIG_arg_fail(1)) SWIG_fail;
36584 {
36585 arg2 = wxString_in_helper(obj1);
36586 if (arg2 == NULL) SWIG_fail;
36587 temp2 = true;
36588 }
36589 if (obj2) {
36590 arg3 = obj2;
36591 }
36592 {
36593 PyThreadState* __tstate = wxPyBeginAllowThreads();
36594 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
36595
36596 wxPyEndAllowThreads(__tstate);
36597 if (PyErr_Occurred()) SWIG_fail;
36598 }
36599 {
36600 resultobj = SWIG_From_int((int)(result));
36601 }
36602 {
36603 if (temp2)
36604 delete arg2;
36605 }
36606 return resultobj;
36607 fail:
36608 {
36609 if (temp2)
36610 delete arg2;
36611 }
36612 return NULL;
36613 }
36614
36615
36616 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
36617 PyObject *resultobj;
36618 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36619 wxArrayString *arg2 = 0 ;
36620 bool temp2 = false ;
36621 PyObject * obj0 = 0 ;
36622 PyObject * obj1 = 0 ;
36623 char *kwnames[] = {
36624 (char *) "self",(char *) "strings", NULL
36625 };
36626
36627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
36628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36629 if (SWIG_arg_fail(1)) SWIG_fail;
36630 {
36631 if (! PySequence_Check(obj1)) {
36632 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
36633 SWIG_fail;
36634 }
36635 arg2 = new wxArrayString;
36636 temp2 = true;
36637 int i, len=PySequence_Length(obj1);
36638 for (i=0; i<len; i++) {
36639 PyObject* item = PySequence_GetItem(obj1, i);
36640 #if wxUSE_UNICODE
36641 PyObject* str = PyObject_Unicode(item);
36642 #else
36643 PyObject* str = PyObject_Str(item);
36644 #endif
36645 if (PyErr_Occurred()) SWIG_fail;
36646 arg2->Add(Py2wxString(str));
36647 Py_DECREF(item);
36648 Py_DECREF(str);
36649 }
36650 }
36651 {
36652 PyThreadState* __tstate = wxPyBeginAllowThreads();
36653 (arg1)->Append((wxArrayString const &)*arg2);
36654
36655 wxPyEndAllowThreads(__tstate);
36656 if (PyErr_Occurred()) SWIG_fail;
36657 }
36658 Py_INCREF(Py_None); resultobj = Py_None;
36659 {
36660 if (temp2) delete arg2;
36661 }
36662 return resultobj;
36663 fail:
36664 {
36665 if (temp2) delete arg2;
36666 }
36667 return NULL;
36668 }
36669
36670
36671 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
36672 PyObject *resultobj;
36673 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36674 wxString *arg2 = 0 ;
36675 int arg3 ;
36676 PyObject *arg4 = (PyObject *) NULL ;
36677 int result;
36678 bool temp2 = false ;
36679 PyObject * obj0 = 0 ;
36680 PyObject * obj1 = 0 ;
36681 PyObject * obj2 = 0 ;
36682 PyObject * obj3 = 0 ;
36683 char *kwnames[] = {
36684 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
36685 };
36686
36687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
36688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36689 if (SWIG_arg_fail(1)) SWIG_fail;
36690 {
36691 arg2 = wxString_in_helper(obj1);
36692 if (arg2 == NULL) SWIG_fail;
36693 temp2 = true;
36694 }
36695 {
36696 arg3 = (int)(SWIG_As_int(obj2));
36697 if (SWIG_arg_fail(3)) SWIG_fail;
36698 }
36699 if (obj3) {
36700 arg4 = obj3;
36701 }
36702 {
36703 PyThreadState* __tstate = wxPyBeginAllowThreads();
36704 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
36705
36706 wxPyEndAllowThreads(__tstate);
36707 if (PyErr_Occurred()) SWIG_fail;
36708 }
36709 {
36710 resultobj = SWIG_From_int((int)(result));
36711 }
36712 {
36713 if (temp2)
36714 delete arg2;
36715 }
36716 return resultobj;
36717 fail:
36718 {
36719 if (temp2)
36720 delete arg2;
36721 }
36722 return NULL;
36723 }
36724
36725
36726 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
36727 PyObject *resultobj;
36728 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36729 PyObject * obj0 = 0 ;
36730 char *kwnames[] = {
36731 (char *) "self", NULL
36732 };
36733
36734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
36735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36736 if (SWIG_arg_fail(1)) SWIG_fail;
36737 {
36738 PyThreadState* __tstate = wxPyBeginAllowThreads();
36739 (arg1)->Clear();
36740
36741 wxPyEndAllowThreads(__tstate);
36742 if (PyErr_Occurred()) SWIG_fail;
36743 }
36744 Py_INCREF(Py_None); resultobj = Py_None;
36745 return resultobj;
36746 fail:
36747 return NULL;
36748 }
36749
36750
36751 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
36752 PyObject *resultobj;
36753 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36754 int arg2 ;
36755 PyObject * obj0 = 0 ;
36756 PyObject * obj1 = 0 ;
36757 char *kwnames[] = {
36758 (char *) "self",(char *) "n", NULL
36759 };
36760
36761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
36762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36763 if (SWIG_arg_fail(1)) SWIG_fail;
36764 {
36765 arg2 = (int)(SWIG_As_int(obj1));
36766 if (SWIG_arg_fail(2)) SWIG_fail;
36767 }
36768 {
36769 PyThreadState* __tstate = wxPyBeginAllowThreads();
36770 (arg1)->Delete(arg2);
36771
36772 wxPyEndAllowThreads(__tstate);
36773 if (PyErr_Occurred()) SWIG_fail;
36774 }
36775 Py_INCREF(Py_None); resultobj = Py_None;
36776 return resultobj;
36777 fail:
36778 return NULL;
36779 }
36780
36781
36782 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
36783 PyObject *resultobj;
36784 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36785 int arg2 ;
36786 PyObject *result;
36787 PyObject * obj0 = 0 ;
36788 PyObject * obj1 = 0 ;
36789 char *kwnames[] = {
36790 (char *) "self",(char *) "n", NULL
36791 };
36792
36793 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
36794 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36795 if (SWIG_arg_fail(1)) SWIG_fail;
36796 {
36797 arg2 = (int)(SWIG_As_int(obj1));
36798 if (SWIG_arg_fail(2)) SWIG_fail;
36799 }
36800 {
36801 PyThreadState* __tstate = wxPyBeginAllowThreads();
36802 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
36803
36804 wxPyEndAllowThreads(__tstate);
36805 if (PyErr_Occurred()) SWIG_fail;
36806 }
36807 resultobj = result;
36808 return resultobj;
36809 fail:
36810 return NULL;
36811 }
36812
36813
36814 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
36815 PyObject *resultobj;
36816 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36817 int arg2 ;
36818 PyObject *arg3 = (PyObject *) 0 ;
36819 PyObject * obj0 = 0 ;
36820 PyObject * obj1 = 0 ;
36821 PyObject * obj2 = 0 ;
36822 char *kwnames[] = {
36823 (char *) "self",(char *) "n",(char *) "clientData", NULL
36824 };
36825
36826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
36827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36828 if (SWIG_arg_fail(1)) SWIG_fail;
36829 {
36830 arg2 = (int)(SWIG_As_int(obj1));
36831 if (SWIG_arg_fail(2)) SWIG_fail;
36832 }
36833 arg3 = obj2;
36834 {
36835 PyThreadState* __tstate = wxPyBeginAllowThreads();
36836 wxItemContainer_SetClientData(arg1,arg2,arg3);
36837
36838 wxPyEndAllowThreads(__tstate);
36839 if (PyErr_Occurred()) SWIG_fail;
36840 }
36841 Py_INCREF(Py_None); resultobj = Py_None;
36842 return resultobj;
36843 fail:
36844 return NULL;
36845 }
36846
36847
36848 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
36849 PyObject *resultobj;
36850 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36851 int result;
36852 PyObject * obj0 = 0 ;
36853 char *kwnames[] = {
36854 (char *) "self", NULL
36855 };
36856
36857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
36858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36859 if (SWIG_arg_fail(1)) SWIG_fail;
36860 {
36861 PyThreadState* __tstate = wxPyBeginAllowThreads();
36862 result = (int)((wxItemContainer const *)arg1)->GetCount();
36863
36864 wxPyEndAllowThreads(__tstate);
36865 if (PyErr_Occurred()) SWIG_fail;
36866 }
36867 {
36868 resultobj = SWIG_From_int((int)(result));
36869 }
36870 return resultobj;
36871 fail:
36872 return NULL;
36873 }
36874
36875
36876 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
36877 PyObject *resultobj;
36878 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36879 bool result;
36880 PyObject * obj0 = 0 ;
36881 char *kwnames[] = {
36882 (char *) "self", NULL
36883 };
36884
36885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
36886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36887 if (SWIG_arg_fail(1)) SWIG_fail;
36888 {
36889 PyThreadState* __tstate = wxPyBeginAllowThreads();
36890 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
36891
36892 wxPyEndAllowThreads(__tstate);
36893 if (PyErr_Occurred()) SWIG_fail;
36894 }
36895 {
36896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36897 }
36898 return resultobj;
36899 fail:
36900 return NULL;
36901 }
36902
36903
36904 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
36905 PyObject *resultobj;
36906 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36907 int arg2 ;
36908 wxString result;
36909 PyObject * obj0 = 0 ;
36910 PyObject * obj1 = 0 ;
36911 char *kwnames[] = {
36912 (char *) "self",(char *) "n", NULL
36913 };
36914
36915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
36916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36917 if (SWIG_arg_fail(1)) SWIG_fail;
36918 {
36919 arg2 = (int)(SWIG_As_int(obj1));
36920 if (SWIG_arg_fail(2)) SWIG_fail;
36921 }
36922 {
36923 PyThreadState* __tstate = wxPyBeginAllowThreads();
36924 result = ((wxItemContainer const *)arg1)->GetString(arg2);
36925
36926 wxPyEndAllowThreads(__tstate);
36927 if (PyErr_Occurred()) SWIG_fail;
36928 }
36929 {
36930 #if wxUSE_UNICODE
36931 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36932 #else
36933 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36934 #endif
36935 }
36936 return resultobj;
36937 fail:
36938 return NULL;
36939 }
36940
36941
36942 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
36943 PyObject *resultobj;
36944 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36945 wxArrayString result;
36946 PyObject * obj0 = 0 ;
36947 char *kwnames[] = {
36948 (char *) "self", NULL
36949 };
36950
36951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
36952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36953 if (SWIG_arg_fail(1)) SWIG_fail;
36954 {
36955 PyThreadState* __tstate = wxPyBeginAllowThreads();
36956 result = ((wxItemContainer const *)arg1)->GetStrings();
36957
36958 wxPyEndAllowThreads(__tstate);
36959 if (PyErr_Occurred()) SWIG_fail;
36960 }
36961 {
36962 resultobj = wxArrayString2PyList_helper(result);
36963 }
36964 return resultobj;
36965 fail:
36966 return NULL;
36967 }
36968
36969
36970 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
36971 PyObject *resultobj;
36972 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
36973 int arg2 ;
36974 wxString *arg3 = 0 ;
36975 bool temp3 = false ;
36976 PyObject * obj0 = 0 ;
36977 PyObject * obj1 = 0 ;
36978 PyObject * obj2 = 0 ;
36979 char *kwnames[] = {
36980 (char *) "self",(char *) "n",(char *) "s", NULL
36981 };
36982
36983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
36984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
36985 if (SWIG_arg_fail(1)) SWIG_fail;
36986 {
36987 arg2 = (int)(SWIG_As_int(obj1));
36988 if (SWIG_arg_fail(2)) SWIG_fail;
36989 }
36990 {
36991 arg3 = wxString_in_helper(obj2);
36992 if (arg3 == NULL) SWIG_fail;
36993 temp3 = true;
36994 }
36995 {
36996 PyThreadState* __tstate = wxPyBeginAllowThreads();
36997 (arg1)->SetString(arg2,(wxString const &)*arg3);
36998
36999 wxPyEndAllowThreads(__tstate);
37000 if (PyErr_Occurred()) SWIG_fail;
37001 }
37002 Py_INCREF(Py_None); resultobj = Py_None;
37003 {
37004 if (temp3)
37005 delete arg3;
37006 }
37007 return resultobj;
37008 fail:
37009 {
37010 if (temp3)
37011 delete arg3;
37012 }
37013 return NULL;
37014 }
37015
37016
37017 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
37018 PyObject *resultobj;
37019 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37020 wxString *arg2 = 0 ;
37021 int result;
37022 bool temp2 = false ;
37023 PyObject * obj0 = 0 ;
37024 PyObject * obj1 = 0 ;
37025 char *kwnames[] = {
37026 (char *) "self",(char *) "s", NULL
37027 };
37028
37029 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
37030 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37031 if (SWIG_arg_fail(1)) SWIG_fail;
37032 {
37033 arg2 = wxString_in_helper(obj1);
37034 if (arg2 == NULL) SWIG_fail;
37035 temp2 = true;
37036 }
37037 {
37038 PyThreadState* __tstate = wxPyBeginAllowThreads();
37039 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
37040
37041 wxPyEndAllowThreads(__tstate);
37042 if (PyErr_Occurred()) SWIG_fail;
37043 }
37044 {
37045 resultobj = SWIG_From_int((int)(result));
37046 }
37047 {
37048 if (temp2)
37049 delete arg2;
37050 }
37051 return resultobj;
37052 fail:
37053 {
37054 if (temp2)
37055 delete arg2;
37056 }
37057 return NULL;
37058 }
37059
37060
37061 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37062 PyObject *resultobj;
37063 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37064 int arg2 ;
37065 PyObject * obj0 = 0 ;
37066 PyObject * obj1 = 0 ;
37067 char *kwnames[] = {
37068 (char *) "self",(char *) "n", NULL
37069 };
37070
37071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
37072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37073 if (SWIG_arg_fail(1)) SWIG_fail;
37074 {
37075 arg2 = (int)(SWIG_As_int(obj1));
37076 if (SWIG_arg_fail(2)) SWIG_fail;
37077 }
37078 {
37079 PyThreadState* __tstate = wxPyBeginAllowThreads();
37080 (arg1)->SetSelection(arg2);
37081
37082 wxPyEndAllowThreads(__tstate);
37083 if (PyErr_Occurred()) SWIG_fail;
37084 }
37085 Py_INCREF(Py_None); resultobj = Py_None;
37086 return resultobj;
37087 fail:
37088 return NULL;
37089 }
37090
37091
37092 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37093 PyObject *resultobj;
37094 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37095 int result;
37096 PyObject * obj0 = 0 ;
37097 char *kwnames[] = {
37098 (char *) "self", NULL
37099 };
37100
37101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
37102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37103 if (SWIG_arg_fail(1)) SWIG_fail;
37104 {
37105 PyThreadState* __tstate = wxPyBeginAllowThreads();
37106 result = (int)((wxItemContainer const *)arg1)->GetSelection();
37107
37108 wxPyEndAllowThreads(__tstate);
37109 if (PyErr_Occurred()) SWIG_fail;
37110 }
37111 {
37112 resultobj = SWIG_From_int((int)(result));
37113 }
37114 return resultobj;
37115 fail:
37116 return NULL;
37117 }
37118
37119
37120 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37121 PyObject *resultobj;
37122 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37123 wxString *arg2 = 0 ;
37124 bool result;
37125 bool temp2 = false ;
37126 PyObject * obj0 = 0 ;
37127 PyObject * obj1 = 0 ;
37128 char *kwnames[] = {
37129 (char *) "self",(char *) "s", NULL
37130 };
37131
37132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
37133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37134 if (SWIG_arg_fail(1)) SWIG_fail;
37135 {
37136 arg2 = wxString_in_helper(obj1);
37137 if (arg2 == NULL) SWIG_fail;
37138 temp2 = true;
37139 }
37140 {
37141 PyThreadState* __tstate = wxPyBeginAllowThreads();
37142 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
37143
37144 wxPyEndAllowThreads(__tstate);
37145 if (PyErr_Occurred()) SWIG_fail;
37146 }
37147 {
37148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37149 }
37150 {
37151 if (temp2)
37152 delete arg2;
37153 }
37154 return resultobj;
37155 fail:
37156 {
37157 if (temp2)
37158 delete arg2;
37159 }
37160 return NULL;
37161 }
37162
37163
37164 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
37165 PyObject *resultobj;
37166 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37167 wxString result;
37168 PyObject * obj0 = 0 ;
37169 char *kwnames[] = {
37170 (char *) "self", NULL
37171 };
37172
37173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
37174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37175 if (SWIG_arg_fail(1)) SWIG_fail;
37176 {
37177 PyThreadState* __tstate = wxPyBeginAllowThreads();
37178 result = ((wxItemContainer const *)arg1)->GetStringSelection();
37179
37180 wxPyEndAllowThreads(__tstate);
37181 if (PyErr_Occurred()) SWIG_fail;
37182 }
37183 {
37184 #if wxUSE_UNICODE
37185 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37186 #else
37187 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37188 #endif
37189 }
37190 return resultobj;
37191 fail:
37192 return NULL;
37193 }
37194
37195
37196 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
37197 PyObject *resultobj;
37198 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37199 int arg2 ;
37200 PyObject * obj0 = 0 ;
37201 PyObject * obj1 = 0 ;
37202 char *kwnames[] = {
37203 (char *) "self",(char *) "n", NULL
37204 };
37205
37206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
37207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37208 if (SWIG_arg_fail(1)) SWIG_fail;
37209 {
37210 arg2 = (int)(SWIG_As_int(obj1));
37211 if (SWIG_arg_fail(2)) SWIG_fail;
37212 }
37213 {
37214 PyThreadState* __tstate = wxPyBeginAllowThreads();
37215 (arg1)->Select(arg2);
37216
37217 wxPyEndAllowThreads(__tstate);
37218 if (PyErr_Occurred()) SWIG_fail;
37219 }
37220 Py_INCREF(Py_None); resultobj = Py_None;
37221 return resultobj;
37222 fail:
37223 return NULL;
37224 }
37225
37226
37227 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
37228 PyObject *obj;
37229 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37230 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
37231 Py_INCREF(obj);
37232 return Py_BuildValue((char *)"");
37233 }
37234 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
37235 PyObject *obj;
37236 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37237 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
37238 Py_INCREF(obj);
37239 return Py_BuildValue((char *)"");
37240 }
37241 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
37242 PyObject *resultobj;
37243 wxSizerItem *result;
37244 char *kwnames[] = {
37245 NULL
37246 };
37247
37248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
37249 {
37250 PyThreadState* __tstate = wxPyBeginAllowThreads();
37251 result = (wxSizerItem *)new wxSizerItem();
37252
37253 wxPyEndAllowThreads(__tstate);
37254 if (PyErr_Occurred()) SWIG_fail;
37255 }
37256 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37257 return resultobj;
37258 fail:
37259 return NULL;
37260 }
37261
37262
37263 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37264 PyObject *resultobj;
37265 wxWindow *arg1 = (wxWindow *) 0 ;
37266 int arg2 ;
37267 int arg3 ;
37268 int arg4 ;
37269 PyObject *arg5 = (PyObject *) NULL ;
37270 wxSizerItem *result;
37271 PyObject * obj0 = 0 ;
37272 PyObject * obj1 = 0 ;
37273 PyObject * obj2 = 0 ;
37274 PyObject * obj3 = 0 ;
37275 PyObject * obj4 = 0 ;
37276 char *kwnames[] = {
37277 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37278 };
37279
37280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37282 if (SWIG_arg_fail(1)) SWIG_fail;
37283 {
37284 arg2 = (int)(SWIG_As_int(obj1));
37285 if (SWIG_arg_fail(2)) SWIG_fail;
37286 }
37287 {
37288 arg3 = (int)(SWIG_As_int(obj2));
37289 if (SWIG_arg_fail(3)) SWIG_fail;
37290 }
37291 {
37292 arg4 = (int)(SWIG_As_int(obj3));
37293 if (SWIG_arg_fail(4)) SWIG_fail;
37294 }
37295 if (obj4) {
37296 arg5 = obj4;
37297 }
37298 {
37299 PyThreadState* __tstate = wxPyBeginAllowThreads();
37300 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37301
37302 wxPyEndAllowThreads(__tstate);
37303 if (PyErr_Occurred()) SWIG_fail;
37304 }
37305 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37306 return resultobj;
37307 fail:
37308 return NULL;
37309 }
37310
37311
37312 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37313 PyObject *resultobj;
37314 int arg1 ;
37315 int arg2 ;
37316 int arg3 ;
37317 int arg4 ;
37318 int arg5 ;
37319 PyObject *arg6 = (PyObject *) NULL ;
37320 wxSizerItem *result;
37321 PyObject * obj0 = 0 ;
37322 PyObject * obj1 = 0 ;
37323 PyObject * obj2 = 0 ;
37324 PyObject * obj3 = 0 ;
37325 PyObject * obj4 = 0 ;
37326 PyObject * obj5 = 0 ;
37327 char *kwnames[] = {
37328 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37329 };
37330
37331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
37332 {
37333 arg1 = (int)(SWIG_As_int(obj0));
37334 if (SWIG_arg_fail(1)) SWIG_fail;
37335 }
37336 {
37337 arg2 = (int)(SWIG_As_int(obj1));
37338 if (SWIG_arg_fail(2)) SWIG_fail;
37339 }
37340 {
37341 arg3 = (int)(SWIG_As_int(obj2));
37342 if (SWIG_arg_fail(3)) SWIG_fail;
37343 }
37344 {
37345 arg4 = (int)(SWIG_As_int(obj3));
37346 if (SWIG_arg_fail(4)) SWIG_fail;
37347 }
37348 {
37349 arg5 = (int)(SWIG_As_int(obj4));
37350 if (SWIG_arg_fail(5)) SWIG_fail;
37351 }
37352 if (obj5) {
37353 arg6 = obj5;
37354 }
37355 {
37356 PyThreadState* __tstate = wxPyBeginAllowThreads();
37357 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
37358
37359 wxPyEndAllowThreads(__tstate);
37360 if (PyErr_Occurred()) SWIG_fail;
37361 }
37362 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37363 return resultobj;
37364 fail:
37365 return NULL;
37366 }
37367
37368
37369 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37370 PyObject *resultobj;
37371 wxSizer *arg1 = (wxSizer *) 0 ;
37372 int arg2 ;
37373 int arg3 ;
37374 int arg4 ;
37375 PyObject *arg5 = (PyObject *) NULL ;
37376 wxSizerItem *result;
37377 PyObject * obj0 = 0 ;
37378 PyObject * obj1 = 0 ;
37379 PyObject * obj2 = 0 ;
37380 PyObject * obj3 = 0 ;
37381 PyObject * obj4 = 0 ;
37382 char *kwnames[] = {
37383 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
37384 };
37385
37386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
37387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
37388 if (SWIG_arg_fail(1)) SWIG_fail;
37389 {
37390 arg2 = (int)(SWIG_As_int(obj1));
37391 if (SWIG_arg_fail(2)) SWIG_fail;
37392 }
37393 {
37394 arg3 = (int)(SWIG_As_int(obj2));
37395 if (SWIG_arg_fail(3)) SWIG_fail;
37396 }
37397 {
37398 arg4 = (int)(SWIG_As_int(obj3));
37399 if (SWIG_arg_fail(4)) SWIG_fail;
37400 }
37401 if (obj4) {
37402 arg5 = obj4;
37403 }
37404 {
37405 PyThreadState* __tstate = wxPyBeginAllowThreads();
37406 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
37407
37408 wxPyEndAllowThreads(__tstate);
37409 if (PyErr_Occurred()) SWIG_fail;
37410 }
37411 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
37412 return resultobj;
37413 fail:
37414 return NULL;
37415 }
37416
37417
37418 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
37419 PyObject *resultobj;
37420 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37421 PyObject * obj0 = 0 ;
37422 char *kwnames[] = {
37423 (char *) "self", NULL
37424 };
37425
37426 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
37427 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37428 if (SWIG_arg_fail(1)) SWIG_fail;
37429 {
37430 PyThreadState* __tstate = wxPyBeginAllowThreads();
37431 (arg1)->DeleteWindows();
37432
37433 wxPyEndAllowThreads(__tstate);
37434 if (PyErr_Occurred()) SWIG_fail;
37435 }
37436 Py_INCREF(Py_None); resultobj = Py_None;
37437 return resultobj;
37438 fail:
37439 return NULL;
37440 }
37441
37442
37443 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37444 PyObject *resultobj;
37445 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37446 PyObject * obj0 = 0 ;
37447 char *kwnames[] = {
37448 (char *) "self", NULL
37449 };
37450
37451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
37452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37453 if (SWIG_arg_fail(1)) SWIG_fail;
37454 {
37455 PyThreadState* __tstate = wxPyBeginAllowThreads();
37456 (arg1)->DetachSizer();
37457
37458 wxPyEndAllowThreads(__tstate);
37459 if (PyErr_Occurred()) SWIG_fail;
37460 }
37461 Py_INCREF(Py_None); resultobj = Py_None;
37462 return resultobj;
37463 fail:
37464 return NULL;
37465 }
37466
37467
37468 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
37469 PyObject *resultobj;
37470 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37471 wxSize result;
37472 PyObject * obj0 = 0 ;
37473 char *kwnames[] = {
37474 (char *) "self", NULL
37475 };
37476
37477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
37478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37479 if (SWIG_arg_fail(1)) SWIG_fail;
37480 {
37481 PyThreadState* __tstate = wxPyBeginAllowThreads();
37482 result = (arg1)->GetSize();
37483
37484 wxPyEndAllowThreads(__tstate);
37485 if (PyErr_Occurred()) SWIG_fail;
37486 }
37487 {
37488 wxSize * resultptr;
37489 resultptr = new wxSize((wxSize &)(result));
37490 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37491 }
37492 return resultobj;
37493 fail:
37494 return NULL;
37495 }
37496
37497
37498 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
37499 PyObject *resultobj;
37500 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37501 wxSize result;
37502 PyObject * obj0 = 0 ;
37503 char *kwnames[] = {
37504 (char *) "self", NULL
37505 };
37506
37507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
37508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37509 if (SWIG_arg_fail(1)) SWIG_fail;
37510 {
37511 PyThreadState* __tstate = wxPyBeginAllowThreads();
37512 result = (arg1)->CalcMin();
37513
37514 wxPyEndAllowThreads(__tstate);
37515 if (PyErr_Occurred()) SWIG_fail;
37516 }
37517 {
37518 wxSize * resultptr;
37519 resultptr = new wxSize((wxSize &)(result));
37520 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37521 }
37522 return resultobj;
37523 fail:
37524 return NULL;
37525 }
37526
37527
37528 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
37529 PyObject *resultobj;
37530 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37531 wxPoint arg2 ;
37532 wxSize arg3 ;
37533 PyObject * obj0 = 0 ;
37534 PyObject * obj1 = 0 ;
37535 PyObject * obj2 = 0 ;
37536 char *kwnames[] = {
37537 (char *) "self",(char *) "pos",(char *) "size", NULL
37538 };
37539
37540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
37541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37542 if (SWIG_arg_fail(1)) SWIG_fail;
37543 {
37544 wxPoint * argp;
37545 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
37546 if (SWIG_arg_fail(2)) SWIG_fail;
37547 if (argp == NULL) {
37548 SWIG_null_ref("wxPoint");
37549 }
37550 if (SWIG_arg_fail(2)) SWIG_fail;
37551 arg2 = *argp;
37552 }
37553 {
37554 wxSize * argp;
37555 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
37556 if (SWIG_arg_fail(3)) SWIG_fail;
37557 if (argp == NULL) {
37558 SWIG_null_ref("wxSize");
37559 }
37560 if (SWIG_arg_fail(3)) SWIG_fail;
37561 arg3 = *argp;
37562 }
37563 {
37564 PyThreadState* __tstate = wxPyBeginAllowThreads();
37565 (arg1)->SetDimension(arg2,arg3);
37566
37567 wxPyEndAllowThreads(__tstate);
37568 if (PyErr_Occurred()) SWIG_fail;
37569 }
37570 Py_INCREF(Py_None); resultobj = Py_None;
37571 return resultobj;
37572 fail:
37573 return NULL;
37574 }
37575
37576
37577 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
37578 PyObject *resultobj;
37579 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37580 wxSize result;
37581 PyObject * obj0 = 0 ;
37582 char *kwnames[] = {
37583 (char *) "self", NULL
37584 };
37585
37586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
37587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37588 if (SWIG_arg_fail(1)) SWIG_fail;
37589 {
37590 PyThreadState* __tstate = wxPyBeginAllowThreads();
37591 result = (arg1)->GetMinSize();
37592
37593 wxPyEndAllowThreads(__tstate);
37594 if (PyErr_Occurred()) SWIG_fail;
37595 }
37596 {
37597 wxSize * resultptr;
37598 resultptr = new wxSize((wxSize &)(result));
37599 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37600 }
37601 return resultobj;
37602 fail:
37603 return NULL;
37604 }
37605
37606
37607 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
37608 PyObject *resultobj;
37609 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37610 wxSize result;
37611 PyObject * obj0 = 0 ;
37612 char *kwnames[] = {
37613 (char *) "self", NULL
37614 };
37615
37616 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
37617 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37618 if (SWIG_arg_fail(1)) SWIG_fail;
37619 {
37620 PyThreadState* __tstate = wxPyBeginAllowThreads();
37621 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
37622
37623 wxPyEndAllowThreads(__tstate);
37624 if (PyErr_Occurred()) SWIG_fail;
37625 }
37626 {
37627 wxSize * resultptr;
37628 resultptr = new wxSize((wxSize &)(result));
37629 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
37630 }
37631 return resultobj;
37632 fail:
37633 return NULL;
37634 }
37635
37636
37637 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
37638 PyObject *resultobj;
37639 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37640 int arg2 ;
37641 int arg3 ;
37642 PyObject * obj0 = 0 ;
37643 PyObject * obj1 = 0 ;
37644 PyObject * obj2 = 0 ;
37645 char *kwnames[] = {
37646 (char *) "self",(char *) "x",(char *) "y", NULL
37647 };
37648
37649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
37650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37651 if (SWIG_arg_fail(1)) SWIG_fail;
37652 {
37653 arg2 = (int)(SWIG_As_int(obj1));
37654 if (SWIG_arg_fail(2)) SWIG_fail;
37655 }
37656 {
37657 arg3 = (int)(SWIG_As_int(obj2));
37658 if (SWIG_arg_fail(3)) SWIG_fail;
37659 }
37660 {
37661 PyThreadState* __tstate = wxPyBeginAllowThreads();
37662 (arg1)->SetInitSize(arg2,arg3);
37663
37664 wxPyEndAllowThreads(__tstate);
37665 if (PyErr_Occurred()) SWIG_fail;
37666 }
37667 Py_INCREF(Py_None); resultobj = Py_None;
37668 return resultobj;
37669 fail:
37670 return NULL;
37671 }
37672
37673
37674 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
37675 PyObject *resultobj;
37676 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37677 int arg2 ;
37678 int arg3 ;
37679 PyObject * obj0 = 0 ;
37680 PyObject * obj1 = 0 ;
37681 PyObject * obj2 = 0 ;
37682 char *kwnames[] = {
37683 (char *) "self",(char *) "width",(char *) "height", NULL
37684 };
37685
37686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
37687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37688 if (SWIG_arg_fail(1)) SWIG_fail;
37689 {
37690 arg2 = (int)(SWIG_As_int(obj1));
37691 if (SWIG_arg_fail(2)) SWIG_fail;
37692 }
37693 {
37694 arg3 = (int)(SWIG_As_int(obj2));
37695 if (SWIG_arg_fail(3)) SWIG_fail;
37696 }
37697 {
37698 PyThreadState* __tstate = wxPyBeginAllowThreads();
37699 (arg1)->SetRatio(arg2,arg3);
37700
37701 wxPyEndAllowThreads(__tstate);
37702 if (PyErr_Occurred()) SWIG_fail;
37703 }
37704 Py_INCREF(Py_None); resultobj = Py_None;
37705 return resultobj;
37706 fail:
37707 return NULL;
37708 }
37709
37710
37711 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
37712 PyObject *resultobj;
37713 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37714 wxSize arg2 ;
37715 PyObject * obj0 = 0 ;
37716 PyObject * obj1 = 0 ;
37717 char *kwnames[] = {
37718 (char *) "self",(char *) "size", NULL
37719 };
37720
37721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
37722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37723 if (SWIG_arg_fail(1)) SWIG_fail;
37724 {
37725 wxSize * argp;
37726 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
37727 if (SWIG_arg_fail(2)) SWIG_fail;
37728 if (argp == NULL) {
37729 SWIG_null_ref("wxSize");
37730 }
37731 if (SWIG_arg_fail(2)) SWIG_fail;
37732 arg2 = *argp;
37733 }
37734 {
37735 PyThreadState* __tstate = wxPyBeginAllowThreads();
37736 (arg1)->SetRatio(arg2);
37737
37738 wxPyEndAllowThreads(__tstate);
37739 if (PyErr_Occurred()) SWIG_fail;
37740 }
37741 Py_INCREF(Py_None); resultobj = Py_None;
37742 return resultobj;
37743 fail:
37744 return NULL;
37745 }
37746
37747
37748 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
37749 PyObject *resultobj;
37750 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37751 float arg2 ;
37752 PyObject * obj0 = 0 ;
37753 PyObject * obj1 = 0 ;
37754 char *kwnames[] = {
37755 (char *) "self",(char *) "ratio", NULL
37756 };
37757
37758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
37759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37760 if (SWIG_arg_fail(1)) SWIG_fail;
37761 {
37762 arg2 = (float)(SWIG_As_float(obj1));
37763 if (SWIG_arg_fail(2)) SWIG_fail;
37764 }
37765 {
37766 PyThreadState* __tstate = wxPyBeginAllowThreads();
37767 (arg1)->SetRatio(arg2);
37768
37769 wxPyEndAllowThreads(__tstate);
37770 if (PyErr_Occurred()) SWIG_fail;
37771 }
37772 Py_INCREF(Py_None); resultobj = Py_None;
37773 return resultobj;
37774 fail:
37775 return NULL;
37776 }
37777
37778
37779 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
37780 PyObject *resultobj;
37781 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37782 float result;
37783 PyObject * obj0 = 0 ;
37784 char *kwnames[] = {
37785 (char *) "self", NULL
37786 };
37787
37788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
37789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37790 if (SWIG_arg_fail(1)) SWIG_fail;
37791 {
37792 PyThreadState* __tstate = wxPyBeginAllowThreads();
37793 result = (float)(arg1)->GetRatio();
37794
37795 wxPyEndAllowThreads(__tstate);
37796 if (PyErr_Occurred()) SWIG_fail;
37797 }
37798 {
37799 resultobj = SWIG_From_float((float)(result));
37800 }
37801 return resultobj;
37802 fail:
37803 return NULL;
37804 }
37805
37806
37807 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
37808 PyObject *resultobj;
37809 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37810 wxRect result;
37811 PyObject * obj0 = 0 ;
37812 char *kwnames[] = {
37813 (char *) "self", NULL
37814 };
37815
37816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
37817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37818 if (SWIG_arg_fail(1)) SWIG_fail;
37819 {
37820 PyThreadState* __tstate = wxPyBeginAllowThreads();
37821 result = (arg1)->GetRect();
37822
37823 wxPyEndAllowThreads(__tstate);
37824 if (PyErr_Occurred()) SWIG_fail;
37825 }
37826 {
37827 wxRect * resultptr;
37828 resultptr = new wxRect((wxRect &)(result));
37829 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
37830 }
37831 return resultobj;
37832 fail:
37833 return NULL;
37834 }
37835
37836
37837 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
37838 PyObject *resultobj;
37839 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37840 bool result;
37841 PyObject * obj0 = 0 ;
37842 char *kwnames[] = {
37843 (char *) "self", NULL
37844 };
37845
37846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
37847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37848 if (SWIG_arg_fail(1)) SWIG_fail;
37849 {
37850 PyThreadState* __tstate = wxPyBeginAllowThreads();
37851 result = (bool)(arg1)->IsWindow();
37852
37853 wxPyEndAllowThreads(__tstate);
37854 if (PyErr_Occurred()) SWIG_fail;
37855 }
37856 {
37857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37858 }
37859 return resultobj;
37860 fail:
37861 return NULL;
37862 }
37863
37864
37865 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
37866 PyObject *resultobj;
37867 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37868 bool result;
37869 PyObject * obj0 = 0 ;
37870 char *kwnames[] = {
37871 (char *) "self", NULL
37872 };
37873
37874 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
37875 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37876 if (SWIG_arg_fail(1)) SWIG_fail;
37877 {
37878 PyThreadState* __tstate = wxPyBeginAllowThreads();
37879 result = (bool)(arg1)->IsSizer();
37880
37881 wxPyEndAllowThreads(__tstate);
37882 if (PyErr_Occurred()) SWIG_fail;
37883 }
37884 {
37885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37886 }
37887 return resultobj;
37888 fail:
37889 return NULL;
37890 }
37891
37892
37893 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
37894 PyObject *resultobj;
37895 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37896 bool result;
37897 PyObject * obj0 = 0 ;
37898 char *kwnames[] = {
37899 (char *) "self", NULL
37900 };
37901
37902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
37903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37904 if (SWIG_arg_fail(1)) SWIG_fail;
37905 {
37906 PyThreadState* __tstate = wxPyBeginAllowThreads();
37907 result = (bool)(arg1)->IsSpacer();
37908
37909 wxPyEndAllowThreads(__tstate);
37910 if (PyErr_Occurred()) SWIG_fail;
37911 }
37912 {
37913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37914 }
37915 return resultobj;
37916 fail:
37917 return NULL;
37918 }
37919
37920
37921 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
37922 PyObject *resultobj;
37923 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37924 int arg2 ;
37925 PyObject * obj0 = 0 ;
37926 PyObject * obj1 = 0 ;
37927 char *kwnames[] = {
37928 (char *) "self",(char *) "proportion", NULL
37929 };
37930
37931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
37932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37933 if (SWIG_arg_fail(1)) SWIG_fail;
37934 {
37935 arg2 = (int)(SWIG_As_int(obj1));
37936 if (SWIG_arg_fail(2)) SWIG_fail;
37937 }
37938 {
37939 PyThreadState* __tstate = wxPyBeginAllowThreads();
37940 (arg1)->SetProportion(arg2);
37941
37942 wxPyEndAllowThreads(__tstate);
37943 if (PyErr_Occurred()) SWIG_fail;
37944 }
37945 Py_INCREF(Py_None); resultobj = Py_None;
37946 return resultobj;
37947 fail:
37948 return NULL;
37949 }
37950
37951
37952 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
37953 PyObject *resultobj;
37954 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37955 int result;
37956 PyObject * obj0 = 0 ;
37957 char *kwnames[] = {
37958 (char *) "self", NULL
37959 };
37960
37961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
37962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37963 if (SWIG_arg_fail(1)) SWIG_fail;
37964 {
37965 PyThreadState* __tstate = wxPyBeginAllowThreads();
37966 result = (int)(arg1)->GetProportion();
37967
37968 wxPyEndAllowThreads(__tstate);
37969 if (PyErr_Occurred()) SWIG_fail;
37970 }
37971 {
37972 resultobj = SWIG_From_int((int)(result));
37973 }
37974 return resultobj;
37975 fail:
37976 return NULL;
37977 }
37978
37979
37980 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
37981 PyObject *resultobj;
37982 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
37983 int arg2 ;
37984 PyObject * obj0 = 0 ;
37985 PyObject * obj1 = 0 ;
37986 char *kwnames[] = {
37987 (char *) "self",(char *) "flag", NULL
37988 };
37989
37990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
37991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
37992 if (SWIG_arg_fail(1)) SWIG_fail;
37993 {
37994 arg2 = (int)(SWIG_As_int(obj1));
37995 if (SWIG_arg_fail(2)) SWIG_fail;
37996 }
37997 {
37998 PyThreadState* __tstate = wxPyBeginAllowThreads();
37999 (arg1)->SetFlag(arg2);
38000
38001 wxPyEndAllowThreads(__tstate);
38002 if (PyErr_Occurred()) SWIG_fail;
38003 }
38004 Py_INCREF(Py_None); resultobj = Py_None;
38005 return resultobj;
38006 fail:
38007 return NULL;
38008 }
38009
38010
38011 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
38012 PyObject *resultobj;
38013 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38014 int result;
38015 PyObject * obj0 = 0 ;
38016 char *kwnames[] = {
38017 (char *) "self", NULL
38018 };
38019
38020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
38021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38022 if (SWIG_arg_fail(1)) SWIG_fail;
38023 {
38024 PyThreadState* __tstate = wxPyBeginAllowThreads();
38025 result = (int)(arg1)->GetFlag();
38026
38027 wxPyEndAllowThreads(__tstate);
38028 if (PyErr_Occurred()) SWIG_fail;
38029 }
38030 {
38031 resultobj = SWIG_From_int((int)(result));
38032 }
38033 return resultobj;
38034 fail:
38035 return NULL;
38036 }
38037
38038
38039 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38040 PyObject *resultobj;
38041 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38042 int arg2 ;
38043 PyObject * obj0 = 0 ;
38044 PyObject * obj1 = 0 ;
38045 char *kwnames[] = {
38046 (char *) "self",(char *) "border", NULL
38047 };
38048
38049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
38050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38051 if (SWIG_arg_fail(1)) SWIG_fail;
38052 {
38053 arg2 = (int)(SWIG_As_int(obj1));
38054 if (SWIG_arg_fail(2)) SWIG_fail;
38055 }
38056 {
38057 PyThreadState* __tstate = wxPyBeginAllowThreads();
38058 (arg1)->SetBorder(arg2);
38059
38060 wxPyEndAllowThreads(__tstate);
38061 if (PyErr_Occurred()) SWIG_fail;
38062 }
38063 Py_INCREF(Py_None); resultobj = Py_None;
38064 return resultobj;
38065 fail:
38066 return NULL;
38067 }
38068
38069
38070 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38071 PyObject *resultobj;
38072 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38073 int result;
38074 PyObject * obj0 = 0 ;
38075 char *kwnames[] = {
38076 (char *) "self", NULL
38077 };
38078
38079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
38080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38081 if (SWIG_arg_fail(1)) SWIG_fail;
38082 {
38083 PyThreadState* __tstate = wxPyBeginAllowThreads();
38084 result = (int)(arg1)->GetBorder();
38085
38086 wxPyEndAllowThreads(__tstate);
38087 if (PyErr_Occurred()) SWIG_fail;
38088 }
38089 {
38090 resultobj = SWIG_From_int((int)(result));
38091 }
38092 return resultobj;
38093 fail:
38094 return NULL;
38095 }
38096
38097
38098 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38099 PyObject *resultobj;
38100 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38101 wxWindow *result;
38102 PyObject * obj0 = 0 ;
38103 char *kwnames[] = {
38104 (char *) "self", NULL
38105 };
38106
38107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
38108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38109 if (SWIG_arg_fail(1)) SWIG_fail;
38110 {
38111 PyThreadState* __tstate = wxPyBeginAllowThreads();
38112 result = (wxWindow *)(arg1)->GetWindow();
38113
38114 wxPyEndAllowThreads(__tstate);
38115 if (PyErr_Occurred()) SWIG_fail;
38116 }
38117 {
38118 resultobj = wxPyMake_wxObject(result, 0);
38119 }
38120 return resultobj;
38121 fail:
38122 return NULL;
38123 }
38124
38125
38126 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38127 PyObject *resultobj;
38128 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38129 wxWindow *arg2 = (wxWindow *) 0 ;
38130 PyObject * obj0 = 0 ;
38131 PyObject * obj1 = 0 ;
38132 char *kwnames[] = {
38133 (char *) "self",(char *) "window", NULL
38134 };
38135
38136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
38137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38138 if (SWIG_arg_fail(1)) SWIG_fail;
38139 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38140 if (SWIG_arg_fail(2)) SWIG_fail;
38141 {
38142 PyThreadState* __tstate = wxPyBeginAllowThreads();
38143 (arg1)->SetWindow(arg2);
38144
38145 wxPyEndAllowThreads(__tstate);
38146 if (PyErr_Occurred()) SWIG_fail;
38147 }
38148 Py_INCREF(Py_None); resultobj = Py_None;
38149 return resultobj;
38150 fail:
38151 return NULL;
38152 }
38153
38154
38155 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38156 PyObject *resultobj;
38157 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38158 wxSizer *result;
38159 PyObject * obj0 = 0 ;
38160 char *kwnames[] = {
38161 (char *) "self", NULL
38162 };
38163
38164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
38165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38166 if (SWIG_arg_fail(1)) SWIG_fail;
38167 {
38168 PyThreadState* __tstate = wxPyBeginAllowThreads();
38169 result = (wxSizer *)(arg1)->GetSizer();
38170
38171 wxPyEndAllowThreads(__tstate);
38172 if (PyErr_Occurred()) SWIG_fail;
38173 }
38174 {
38175 resultobj = wxPyMake_wxSizer(result, 0);
38176 }
38177 return resultobj;
38178 fail:
38179 return NULL;
38180 }
38181
38182
38183 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38184 PyObject *resultobj;
38185 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38186 wxSizer *arg2 = (wxSizer *) 0 ;
38187 PyObject * obj0 = 0 ;
38188 PyObject * obj1 = 0 ;
38189 char *kwnames[] = {
38190 (char *) "self",(char *) "sizer", NULL
38191 };
38192
38193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
38194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38195 if (SWIG_arg_fail(1)) SWIG_fail;
38196 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38197 if (SWIG_arg_fail(2)) SWIG_fail;
38198 {
38199 PyThreadState* __tstate = wxPyBeginAllowThreads();
38200 (arg1)->SetSizer(arg2);
38201
38202 wxPyEndAllowThreads(__tstate);
38203 if (PyErr_Occurred()) SWIG_fail;
38204 }
38205 Py_INCREF(Py_None); resultobj = Py_None;
38206 return resultobj;
38207 fail:
38208 return NULL;
38209 }
38210
38211
38212 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38213 PyObject *resultobj;
38214 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38215 wxSize *result;
38216 PyObject * obj0 = 0 ;
38217 char *kwnames[] = {
38218 (char *) "self", NULL
38219 };
38220
38221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
38222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38223 if (SWIG_arg_fail(1)) SWIG_fail;
38224 {
38225 PyThreadState* __tstate = wxPyBeginAllowThreads();
38226 {
38227 wxSize const &_result_ref = (arg1)->GetSpacer();
38228 result = (wxSize *) &_result_ref;
38229 }
38230
38231 wxPyEndAllowThreads(__tstate);
38232 if (PyErr_Occurred()) SWIG_fail;
38233 }
38234 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
38235 return resultobj;
38236 fail:
38237 return NULL;
38238 }
38239
38240
38241 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38242 PyObject *resultobj;
38243 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38244 wxSize *arg2 = 0 ;
38245 wxSize temp2 ;
38246 PyObject * obj0 = 0 ;
38247 PyObject * obj1 = 0 ;
38248 char *kwnames[] = {
38249 (char *) "self",(char *) "size", NULL
38250 };
38251
38252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
38253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38254 if (SWIG_arg_fail(1)) SWIG_fail;
38255 {
38256 arg2 = &temp2;
38257 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38258 }
38259 {
38260 PyThreadState* __tstate = wxPyBeginAllowThreads();
38261 (arg1)->SetSpacer((wxSize const &)*arg2);
38262
38263 wxPyEndAllowThreads(__tstate);
38264 if (PyErr_Occurred()) SWIG_fail;
38265 }
38266 Py_INCREF(Py_None); resultobj = Py_None;
38267 return resultobj;
38268 fail:
38269 return NULL;
38270 }
38271
38272
38273 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
38274 PyObject *resultobj;
38275 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38276 bool arg2 ;
38277 PyObject * obj0 = 0 ;
38278 PyObject * obj1 = 0 ;
38279 char *kwnames[] = {
38280 (char *) "self",(char *) "show", NULL
38281 };
38282
38283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
38284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38285 if (SWIG_arg_fail(1)) SWIG_fail;
38286 {
38287 arg2 = (bool)(SWIG_As_bool(obj1));
38288 if (SWIG_arg_fail(2)) SWIG_fail;
38289 }
38290 {
38291 PyThreadState* __tstate = wxPyBeginAllowThreads();
38292 (arg1)->Show(arg2);
38293
38294 wxPyEndAllowThreads(__tstate);
38295 if (PyErr_Occurred()) SWIG_fail;
38296 }
38297 Py_INCREF(Py_None); resultobj = Py_None;
38298 return resultobj;
38299 fail:
38300 return NULL;
38301 }
38302
38303
38304 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
38305 PyObject *resultobj;
38306 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38307 bool result;
38308 PyObject * obj0 = 0 ;
38309 char *kwnames[] = {
38310 (char *) "self", NULL
38311 };
38312
38313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
38314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38315 if (SWIG_arg_fail(1)) SWIG_fail;
38316 {
38317 PyThreadState* __tstate = wxPyBeginAllowThreads();
38318 result = (bool)(arg1)->IsShown();
38319
38320 wxPyEndAllowThreads(__tstate);
38321 if (PyErr_Occurred()) SWIG_fail;
38322 }
38323 {
38324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38325 }
38326 return resultobj;
38327 fail:
38328 return NULL;
38329 }
38330
38331
38332 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38333 PyObject *resultobj;
38334 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38335 wxPoint result;
38336 PyObject * obj0 = 0 ;
38337 char *kwnames[] = {
38338 (char *) "self", NULL
38339 };
38340
38341 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
38342 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38343 if (SWIG_arg_fail(1)) SWIG_fail;
38344 {
38345 PyThreadState* __tstate = wxPyBeginAllowThreads();
38346 result = (arg1)->GetPosition();
38347
38348 wxPyEndAllowThreads(__tstate);
38349 if (PyErr_Occurred()) SWIG_fail;
38350 }
38351 {
38352 wxPoint * resultptr;
38353 resultptr = new wxPoint((wxPoint &)(result));
38354 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38355 }
38356 return resultobj;
38357 fail:
38358 return NULL;
38359 }
38360
38361
38362 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
38363 PyObject *resultobj;
38364 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38365 PyObject *result;
38366 PyObject * obj0 = 0 ;
38367 char *kwnames[] = {
38368 (char *) "self", NULL
38369 };
38370
38371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
38372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38373 if (SWIG_arg_fail(1)) SWIG_fail;
38374 {
38375 PyThreadState* __tstate = wxPyBeginAllowThreads();
38376 result = (PyObject *)wxSizerItem_GetUserData(arg1);
38377
38378 wxPyEndAllowThreads(__tstate);
38379 if (PyErr_Occurred()) SWIG_fail;
38380 }
38381 resultobj = result;
38382 return resultobj;
38383 fail:
38384 return NULL;
38385 }
38386
38387
38388 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
38389 PyObject *obj;
38390 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38391 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
38392 Py_INCREF(obj);
38393 return Py_BuildValue((char *)"");
38394 }
38395 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
38396 PyObject *resultobj;
38397 wxSizer *arg1 = (wxSizer *) 0 ;
38398 PyObject *arg2 = (PyObject *) 0 ;
38399 PyObject * obj0 = 0 ;
38400 PyObject * obj1 = 0 ;
38401 char *kwnames[] = {
38402 (char *) "self",(char *) "_self", NULL
38403 };
38404
38405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
38406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38407 if (SWIG_arg_fail(1)) SWIG_fail;
38408 arg2 = obj1;
38409 {
38410 PyThreadState* __tstate = wxPyBeginAllowThreads();
38411 wxSizer__setOORInfo(arg1,arg2);
38412
38413 wxPyEndAllowThreads(__tstate);
38414 if (PyErr_Occurred()) SWIG_fail;
38415 }
38416 Py_INCREF(Py_None); resultobj = Py_None;
38417 return resultobj;
38418 fail:
38419 return NULL;
38420 }
38421
38422
38423 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
38424 PyObject *resultobj;
38425 wxSizer *arg1 = (wxSizer *) 0 ;
38426 PyObject *arg2 = (PyObject *) 0 ;
38427 int arg3 = (int) 0 ;
38428 int arg4 = (int) 0 ;
38429 int arg5 = (int) 0 ;
38430 PyObject *arg6 = (PyObject *) NULL ;
38431 wxSizerItem *result;
38432 PyObject * obj0 = 0 ;
38433 PyObject * obj1 = 0 ;
38434 PyObject * obj2 = 0 ;
38435 PyObject * obj3 = 0 ;
38436 PyObject * obj4 = 0 ;
38437 PyObject * obj5 = 0 ;
38438 char *kwnames[] = {
38439 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38440 };
38441
38442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38444 if (SWIG_arg_fail(1)) SWIG_fail;
38445 arg2 = obj1;
38446 if (obj2) {
38447 {
38448 arg3 = (int)(SWIG_As_int(obj2));
38449 if (SWIG_arg_fail(3)) SWIG_fail;
38450 }
38451 }
38452 if (obj3) {
38453 {
38454 arg4 = (int)(SWIG_As_int(obj3));
38455 if (SWIG_arg_fail(4)) SWIG_fail;
38456 }
38457 }
38458 if (obj4) {
38459 {
38460 arg5 = (int)(SWIG_As_int(obj4));
38461 if (SWIG_arg_fail(5)) SWIG_fail;
38462 }
38463 }
38464 if (obj5) {
38465 arg6 = obj5;
38466 }
38467 {
38468 PyThreadState* __tstate = wxPyBeginAllowThreads();
38469 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
38470
38471 wxPyEndAllowThreads(__tstate);
38472 if (PyErr_Occurred()) SWIG_fail;
38473 }
38474 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38475 return resultobj;
38476 fail:
38477 return NULL;
38478 }
38479
38480
38481 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38482 PyObject *resultobj;
38483 wxSizer *arg1 = (wxSizer *) 0 ;
38484 int arg2 ;
38485 PyObject *arg3 = (PyObject *) 0 ;
38486 int arg4 = (int) 0 ;
38487 int arg5 = (int) 0 ;
38488 int arg6 = (int) 0 ;
38489 PyObject *arg7 = (PyObject *) NULL ;
38490 wxSizerItem *result;
38491 PyObject * obj0 = 0 ;
38492 PyObject * obj1 = 0 ;
38493 PyObject * obj2 = 0 ;
38494 PyObject * obj3 = 0 ;
38495 PyObject * obj4 = 0 ;
38496 PyObject * obj5 = 0 ;
38497 PyObject * obj6 = 0 ;
38498 char *kwnames[] = {
38499 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38500 };
38501
38502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
38503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38504 if (SWIG_arg_fail(1)) SWIG_fail;
38505 {
38506 arg2 = (int)(SWIG_As_int(obj1));
38507 if (SWIG_arg_fail(2)) SWIG_fail;
38508 }
38509 arg3 = obj2;
38510 if (obj3) {
38511 {
38512 arg4 = (int)(SWIG_As_int(obj3));
38513 if (SWIG_arg_fail(4)) SWIG_fail;
38514 }
38515 }
38516 if (obj4) {
38517 {
38518 arg5 = (int)(SWIG_As_int(obj4));
38519 if (SWIG_arg_fail(5)) SWIG_fail;
38520 }
38521 }
38522 if (obj5) {
38523 {
38524 arg6 = (int)(SWIG_As_int(obj5));
38525 if (SWIG_arg_fail(6)) SWIG_fail;
38526 }
38527 }
38528 if (obj6) {
38529 arg7 = obj6;
38530 }
38531 {
38532 PyThreadState* __tstate = wxPyBeginAllowThreads();
38533 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
38534
38535 wxPyEndAllowThreads(__tstate);
38536 if (PyErr_Occurred()) SWIG_fail;
38537 }
38538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38539 return resultobj;
38540 fail:
38541 return NULL;
38542 }
38543
38544
38545 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
38546 PyObject *resultobj;
38547 wxSizer *arg1 = (wxSizer *) 0 ;
38548 PyObject *arg2 = (PyObject *) 0 ;
38549 int arg3 = (int) 0 ;
38550 int arg4 = (int) 0 ;
38551 int arg5 = (int) 0 ;
38552 PyObject *arg6 = (PyObject *) NULL ;
38553 wxSizerItem *result;
38554 PyObject * obj0 = 0 ;
38555 PyObject * obj1 = 0 ;
38556 PyObject * obj2 = 0 ;
38557 PyObject * obj3 = 0 ;
38558 PyObject * obj4 = 0 ;
38559 PyObject * obj5 = 0 ;
38560 char *kwnames[] = {
38561 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38562 };
38563
38564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38566 if (SWIG_arg_fail(1)) SWIG_fail;
38567 arg2 = obj1;
38568 if (obj2) {
38569 {
38570 arg3 = (int)(SWIG_As_int(obj2));
38571 if (SWIG_arg_fail(3)) SWIG_fail;
38572 }
38573 }
38574 if (obj3) {
38575 {
38576 arg4 = (int)(SWIG_As_int(obj3));
38577 if (SWIG_arg_fail(4)) SWIG_fail;
38578 }
38579 }
38580 if (obj4) {
38581 {
38582 arg5 = (int)(SWIG_As_int(obj4));
38583 if (SWIG_arg_fail(5)) SWIG_fail;
38584 }
38585 }
38586 if (obj5) {
38587 arg6 = obj5;
38588 }
38589 {
38590 PyThreadState* __tstate = wxPyBeginAllowThreads();
38591 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
38592
38593 wxPyEndAllowThreads(__tstate);
38594 if (PyErr_Occurred()) SWIG_fail;
38595 }
38596 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38597 return resultobj;
38598 fail:
38599 return NULL;
38600 }
38601
38602
38603 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
38604 PyObject *resultobj;
38605 wxSizer *arg1 = (wxSizer *) 0 ;
38606 PyObject *arg2 = (PyObject *) 0 ;
38607 bool result;
38608 PyObject * obj0 = 0 ;
38609 PyObject * obj1 = 0 ;
38610 char *kwnames[] = {
38611 (char *) "self",(char *) "item", NULL
38612 };
38613
38614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
38615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38616 if (SWIG_arg_fail(1)) SWIG_fail;
38617 arg2 = obj1;
38618 {
38619 PyThreadState* __tstate = wxPyBeginAllowThreads();
38620 result = (bool)wxSizer_Remove(arg1,arg2);
38621
38622 wxPyEndAllowThreads(__tstate);
38623 if (PyErr_Occurred()) SWIG_fail;
38624 }
38625 {
38626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38627 }
38628 return resultobj;
38629 fail:
38630 return NULL;
38631 }
38632
38633
38634 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
38635 PyObject *resultobj;
38636 wxSizer *arg1 = (wxSizer *) 0 ;
38637 PyObject *arg2 = (PyObject *) 0 ;
38638 bool result;
38639 PyObject * obj0 = 0 ;
38640 PyObject * obj1 = 0 ;
38641 char *kwnames[] = {
38642 (char *) "self",(char *) "item", NULL
38643 };
38644
38645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
38646 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38647 if (SWIG_arg_fail(1)) SWIG_fail;
38648 arg2 = obj1;
38649 {
38650 PyThreadState* __tstate = wxPyBeginAllowThreads();
38651 result = (bool)wxSizer_Detach(arg1,arg2);
38652
38653 wxPyEndAllowThreads(__tstate);
38654 if (PyErr_Occurred()) SWIG_fail;
38655 }
38656 {
38657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38658 }
38659 return resultobj;
38660 fail:
38661 return NULL;
38662 }
38663
38664
38665 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
38666 PyObject *resultobj;
38667 wxSizer *arg1 = (wxSizer *) 0 ;
38668 PyObject *arg2 = (PyObject *) 0 ;
38669 wxSizerItem *result;
38670 PyObject * obj0 = 0 ;
38671 PyObject * obj1 = 0 ;
38672 char *kwnames[] = {
38673 (char *) "self",(char *) "item", NULL
38674 };
38675
38676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
38677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38678 if (SWIG_arg_fail(1)) SWIG_fail;
38679 arg2 = obj1;
38680 {
38681 PyThreadState* __tstate = wxPyBeginAllowThreads();
38682 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
38683
38684 wxPyEndAllowThreads(__tstate);
38685 if (PyErr_Occurred()) SWIG_fail;
38686 }
38687 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38688 return resultobj;
38689 fail:
38690 return NULL;
38691 }
38692
38693
38694 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38695 PyObject *resultobj;
38696 wxSizer *arg1 = (wxSizer *) 0 ;
38697 PyObject *arg2 = (PyObject *) 0 ;
38698 wxSize *arg3 = 0 ;
38699 wxSize temp3 ;
38700 PyObject * obj0 = 0 ;
38701 PyObject * obj1 = 0 ;
38702 PyObject * obj2 = 0 ;
38703 char *kwnames[] = {
38704 (char *) "self",(char *) "item",(char *) "size", NULL
38705 };
38706
38707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38709 if (SWIG_arg_fail(1)) SWIG_fail;
38710 arg2 = obj1;
38711 {
38712 arg3 = &temp3;
38713 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
38714 }
38715 {
38716 PyThreadState* __tstate = wxPyBeginAllowThreads();
38717 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
38718
38719 wxPyEndAllowThreads(__tstate);
38720 if (PyErr_Occurred()) SWIG_fail;
38721 }
38722 Py_INCREF(Py_None); resultobj = Py_None;
38723 return resultobj;
38724 fail:
38725 return NULL;
38726 }
38727
38728
38729 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
38730 PyObject *resultobj;
38731 wxSizer *arg1 = (wxSizer *) 0 ;
38732 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
38733 wxSizerItem *result;
38734 PyObject * obj0 = 0 ;
38735 PyObject * obj1 = 0 ;
38736 char *kwnames[] = {
38737 (char *) "self",(char *) "item", NULL
38738 };
38739
38740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
38741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38742 if (SWIG_arg_fail(1)) SWIG_fail;
38743 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38744 if (SWIG_arg_fail(2)) SWIG_fail;
38745 {
38746 PyThreadState* __tstate = wxPyBeginAllowThreads();
38747 result = (wxSizerItem *)(arg1)->Add(arg2);
38748
38749 wxPyEndAllowThreads(__tstate);
38750 if (PyErr_Occurred()) SWIG_fail;
38751 }
38752 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38753 return resultobj;
38754 fail:
38755 return NULL;
38756 }
38757
38758
38759 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
38760 PyObject *resultobj;
38761 wxSizer *arg1 = (wxSizer *) 0 ;
38762 size_t arg2 ;
38763 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
38764 wxSizerItem *result;
38765 PyObject * obj0 = 0 ;
38766 PyObject * obj1 = 0 ;
38767 PyObject * obj2 = 0 ;
38768 char *kwnames[] = {
38769 (char *) "self",(char *) "index",(char *) "item", NULL
38770 };
38771
38772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
38773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38774 if (SWIG_arg_fail(1)) SWIG_fail;
38775 {
38776 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
38777 if (SWIG_arg_fail(2)) SWIG_fail;
38778 }
38779 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38780 if (SWIG_arg_fail(3)) SWIG_fail;
38781 {
38782 PyThreadState* __tstate = wxPyBeginAllowThreads();
38783 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
38784
38785 wxPyEndAllowThreads(__tstate);
38786 if (PyErr_Occurred()) SWIG_fail;
38787 }
38788 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38789 return resultobj;
38790 fail:
38791 return NULL;
38792 }
38793
38794
38795 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
38796 PyObject *resultobj;
38797 wxSizer *arg1 = (wxSizer *) 0 ;
38798 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
38799 wxSizerItem *result;
38800 PyObject * obj0 = 0 ;
38801 PyObject * obj1 = 0 ;
38802 char *kwnames[] = {
38803 (char *) "self",(char *) "item", NULL
38804 };
38805
38806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
38807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38808 if (SWIG_arg_fail(1)) SWIG_fail;
38809 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38810 if (SWIG_arg_fail(2)) SWIG_fail;
38811 {
38812 PyThreadState* __tstate = wxPyBeginAllowThreads();
38813 result = (wxSizerItem *)(arg1)->Prepend(arg2);
38814
38815 wxPyEndAllowThreads(__tstate);
38816 if (PyErr_Occurred()) SWIG_fail;
38817 }
38818 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
38819 return resultobj;
38820 fail:
38821 return NULL;
38822 }
38823
38824
38825 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38826 PyObject *resultobj;
38827 wxSizer *arg1 = (wxSizer *) 0 ;
38828 int arg2 ;
38829 int arg3 ;
38830 int arg4 ;
38831 int arg5 ;
38832 PyObject * obj0 = 0 ;
38833 PyObject * obj1 = 0 ;
38834 PyObject * obj2 = 0 ;
38835 PyObject * obj3 = 0 ;
38836 PyObject * obj4 = 0 ;
38837 char *kwnames[] = {
38838 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
38839 };
38840
38841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38843 if (SWIG_arg_fail(1)) SWIG_fail;
38844 {
38845 arg2 = (int)(SWIG_As_int(obj1));
38846 if (SWIG_arg_fail(2)) SWIG_fail;
38847 }
38848 {
38849 arg3 = (int)(SWIG_As_int(obj2));
38850 if (SWIG_arg_fail(3)) SWIG_fail;
38851 }
38852 {
38853 arg4 = (int)(SWIG_As_int(obj3));
38854 if (SWIG_arg_fail(4)) SWIG_fail;
38855 }
38856 {
38857 arg5 = (int)(SWIG_As_int(obj4));
38858 if (SWIG_arg_fail(5)) SWIG_fail;
38859 }
38860 {
38861 PyThreadState* __tstate = wxPyBeginAllowThreads();
38862 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
38863
38864 wxPyEndAllowThreads(__tstate);
38865 if (PyErr_Occurred()) SWIG_fail;
38866 }
38867 Py_INCREF(Py_None); resultobj = Py_None;
38868 return resultobj;
38869 fail:
38870 return NULL;
38871 }
38872
38873
38874 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38875 PyObject *resultobj;
38876 wxSizer *arg1 = (wxSizer *) 0 ;
38877 wxSize *arg2 = 0 ;
38878 wxSize temp2 ;
38879 PyObject * obj0 = 0 ;
38880 PyObject * obj1 = 0 ;
38881 char *kwnames[] = {
38882 (char *) "self",(char *) "size", NULL
38883 };
38884
38885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
38886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38887 if (SWIG_arg_fail(1)) SWIG_fail;
38888 {
38889 arg2 = &temp2;
38890 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38891 }
38892 {
38893 PyThreadState* __tstate = wxPyBeginAllowThreads();
38894 (arg1)->SetMinSize((wxSize const &)*arg2);
38895
38896 wxPyEndAllowThreads(__tstate);
38897 if (PyErr_Occurred()) SWIG_fail;
38898 }
38899 Py_INCREF(Py_None); resultobj = Py_None;
38900 return resultobj;
38901 fail:
38902 return NULL;
38903 }
38904
38905
38906 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38907 PyObject *resultobj;
38908 wxSizer *arg1 = (wxSizer *) 0 ;
38909 wxSize result;
38910 PyObject * obj0 = 0 ;
38911 char *kwnames[] = {
38912 (char *) "self", NULL
38913 };
38914
38915 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
38916 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38917 if (SWIG_arg_fail(1)) SWIG_fail;
38918 {
38919 PyThreadState* __tstate = wxPyBeginAllowThreads();
38920 result = (arg1)->GetSize();
38921
38922 wxPyEndAllowThreads(__tstate);
38923 if (PyErr_Occurred()) SWIG_fail;
38924 }
38925 {
38926 wxSize * resultptr;
38927 resultptr = new wxSize((wxSize &)(result));
38928 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38929 }
38930 return resultobj;
38931 fail:
38932 return NULL;
38933 }
38934
38935
38936 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
38937 PyObject *resultobj;
38938 wxSizer *arg1 = (wxSizer *) 0 ;
38939 wxPoint result;
38940 PyObject * obj0 = 0 ;
38941 char *kwnames[] = {
38942 (char *) "self", NULL
38943 };
38944
38945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
38946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38947 if (SWIG_arg_fail(1)) SWIG_fail;
38948 {
38949 PyThreadState* __tstate = wxPyBeginAllowThreads();
38950 result = (arg1)->GetPosition();
38951
38952 wxPyEndAllowThreads(__tstate);
38953 if (PyErr_Occurred()) SWIG_fail;
38954 }
38955 {
38956 wxPoint * resultptr;
38957 resultptr = new wxPoint((wxPoint &)(result));
38958 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
38959 }
38960 return resultobj;
38961 fail:
38962 return NULL;
38963 }
38964
38965
38966 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38967 PyObject *resultobj;
38968 wxSizer *arg1 = (wxSizer *) 0 ;
38969 wxSize result;
38970 PyObject * obj0 = 0 ;
38971 char *kwnames[] = {
38972 (char *) "self", NULL
38973 };
38974
38975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
38976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38977 if (SWIG_arg_fail(1)) SWIG_fail;
38978 {
38979 PyThreadState* __tstate = wxPyBeginAllowThreads();
38980 result = (arg1)->GetMinSize();
38981
38982 wxPyEndAllowThreads(__tstate);
38983 if (PyErr_Occurred()) SWIG_fail;
38984 }
38985 {
38986 wxSize * resultptr;
38987 resultptr = new wxSize((wxSize &)(result));
38988 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38989 }
38990 return resultobj;
38991 fail:
38992 return NULL;
38993 }
38994
38995
38996 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
38997 PyObject *resultobj;
38998 wxSizer *arg1 = (wxSizer *) 0 ;
38999 PyObject * obj0 = 0 ;
39000 char *kwnames[] = {
39001 (char *) "self", NULL
39002 };
39003
39004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
39005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39006 if (SWIG_arg_fail(1)) SWIG_fail;
39007 {
39008 PyThreadState* __tstate = wxPyBeginAllowThreads();
39009 (arg1)->RecalcSizes();
39010
39011 wxPyEndAllowThreads(__tstate);
39012 if (PyErr_Occurred()) SWIG_fail;
39013 }
39014 Py_INCREF(Py_None); resultobj = Py_None;
39015 return resultobj;
39016 fail:
39017 return NULL;
39018 }
39019
39020
39021 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39022 PyObject *resultobj;
39023 wxSizer *arg1 = (wxSizer *) 0 ;
39024 wxSize result;
39025 PyObject * obj0 = 0 ;
39026 char *kwnames[] = {
39027 (char *) "self", NULL
39028 };
39029
39030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
39031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39032 if (SWIG_arg_fail(1)) SWIG_fail;
39033 {
39034 PyThreadState* __tstate = wxPyBeginAllowThreads();
39035 result = (arg1)->CalcMin();
39036
39037 wxPyEndAllowThreads(__tstate);
39038 if (PyErr_Occurred()) SWIG_fail;
39039 }
39040 {
39041 wxSize * resultptr;
39042 resultptr = new wxSize((wxSize &)(result));
39043 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39044 }
39045 return resultobj;
39046 fail:
39047 return NULL;
39048 }
39049
39050
39051 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
39052 PyObject *resultobj;
39053 wxSizer *arg1 = (wxSizer *) 0 ;
39054 PyObject * obj0 = 0 ;
39055 char *kwnames[] = {
39056 (char *) "self", NULL
39057 };
39058
39059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
39060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39061 if (SWIG_arg_fail(1)) SWIG_fail;
39062 {
39063 PyThreadState* __tstate = wxPyBeginAllowThreads();
39064 (arg1)->Layout();
39065
39066 wxPyEndAllowThreads(__tstate);
39067 if (PyErr_Occurred()) SWIG_fail;
39068 }
39069 Py_INCREF(Py_None); resultobj = Py_None;
39070 return resultobj;
39071 fail:
39072 return NULL;
39073 }
39074
39075
39076 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
39077 PyObject *resultobj;
39078 wxSizer *arg1 = (wxSizer *) 0 ;
39079 wxWindow *arg2 = (wxWindow *) 0 ;
39080 wxSize result;
39081 PyObject * obj0 = 0 ;
39082 PyObject * obj1 = 0 ;
39083 char *kwnames[] = {
39084 (char *) "self",(char *) "window", NULL
39085 };
39086
39087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
39088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39089 if (SWIG_arg_fail(1)) SWIG_fail;
39090 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39091 if (SWIG_arg_fail(2)) SWIG_fail;
39092 {
39093 PyThreadState* __tstate = wxPyBeginAllowThreads();
39094 result = (arg1)->Fit(arg2);
39095
39096 wxPyEndAllowThreads(__tstate);
39097 if (PyErr_Occurred()) SWIG_fail;
39098 }
39099 {
39100 wxSize * resultptr;
39101 resultptr = new wxSize((wxSize &)(result));
39102 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39103 }
39104 return resultobj;
39105 fail:
39106 return NULL;
39107 }
39108
39109
39110 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
39111 PyObject *resultobj;
39112 wxSizer *arg1 = (wxSizer *) 0 ;
39113 wxWindow *arg2 = (wxWindow *) 0 ;
39114 PyObject * obj0 = 0 ;
39115 PyObject * obj1 = 0 ;
39116 char *kwnames[] = {
39117 (char *) "self",(char *) "window", NULL
39118 };
39119
39120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
39121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39122 if (SWIG_arg_fail(1)) SWIG_fail;
39123 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39124 if (SWIG_arg_fail(2)) SWIG_fail;
39125 {
39126 PyThreadState* __tstate = wxPyBeginAllowThreads();
39127 (arg1)->FitInside(arg2);
39128
39129 wxPyEndAllowThreads(__tstate);
39130 if (PyErr_Occurred()) SWIG_fail;
39131 }
39132 Py_INCREF(Py_None); resultobj = Py_None;
39133 return resultobj;
39134 fail:
39135 return NULL;
39136 }
39137
39138
39139 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39140 PyObject *resultobj;
39141 wxSizer *arg1 = (wxSizer *) 0 ;
39142 wxWindow *arg2 = (wxWindow *) 0 ;
39143 PyObject * obj0 = 0 ;
39144 PyObject * obj1 = 0 ;
39145 char *kwnames[] = {
39146 (char *) "self",(char *) "window", NULL
39147 };
39148
39149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
39150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39151 if (SWIG_arg_fail(1)) SWIG_fail;
39152 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39153 if (SWIG_arg_fail(2)) SWIG_fail;
39154 {
39155 PyThreadState* __tstate = wxPyBeginAllowThreads();
39156 (arg1)->SetSizeHints(arg2);
39157
39158 wxPyEndAllowThreads(__tstate);
39159 if (PyErr_Occurred()) SWIG_fail;
39160 }
39161 Py_INCREF(Py_None); resultobj = Py_None;
39162 return resultobj;
39163 fail:
39164 return NULL;
39165 }
39166
39167
39168 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
39169 PyObject *resultobj;
39170 wxSizer *arg1 = (wxSizer *) 0 ;
39171 wxWindow *arg2 = (wxWindow *) 0 ;
39172 PyObject * obj0 = 0 ;
39173 PyObject * obj1 = 0 ;
39174 char *kwnames[] = {
39175 (char *) "self",(char *) "window", NULL
39176 };
39177
39178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
39179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39180 if (SWIG_arg_fail(1)) SWIG_fail;
39181 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39182 if (SWIG_arg_fail(2)) SWIG_fail;
39183 {
39184 PyThreadState* __tstate = wxPyBeginAllowThreads();
39185 (arg1)->SetVirtualSizeHints(arg2);
39186
39187 wxPyEndAllowThreads(__tstate);
39188 if (PyErr_Occurred()) SWIG_fail;
39189 }
39190 Py_INCREF(Py_None); resultobj = Py_None;
39191 return resultobj;
39192 fail:
39193 return NULL;
39194 }
39195
39196
39197 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
39198 PyObject *resultobj;
39199 wxSizer *arg1 = (wxSizer *) 0 ;
39200 bool arg2 = (bool) false ;
39201 PyObject * obj0 = 0 ;
39202 PyObject * obj1 = 0 ;
39203 char *kwnames[] = {
39204 (char *) "self",(char *) "deleteWindows", NULL
39205 };
39206
39207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
39208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39209 if (SWIG_arg_fail(1)) SWIG_fail;
39210 if (obj1) {
39211 {
39212 arg2 = (bool)(SWIG_As_bool(obj1));
39213 if (SWIG_arg_fail(2)) SWIG_fail;
39214 }
39215 }
39216 {
39217 PyThreadState* __tstate = wxPyBeginAllowThreads();
39218 (arg1)->Clear(arg2);
39219
39220 wxPyEndAllowThreads(__tstate);
39221 if (PyErr_Occurred()) SWIG_fail;
39222 }
39223 Py_INCREF(Py_None); resultobj = Py_None;
39224 return resultobj;
39225 fail:
39226 return NULL;
39227 }
39228
39229
39230 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39231 PyObject *resultobj;
39232 wxSizer *arg1 = (wxSizer *) 0 ;
39233 PyObject * obj0 = 0 ;
39234 char *kwnames[] = {
39235 (char *) "self", NULL
39236 };
39237
39238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
39239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39240 if (SWIG_arg_fail(1)) SWIG_fail;
39241 {
39242 PyThreadState* __tstate = wxPyBeginAllowThreads();
39243 (arg1)->DeleteWindows();
39244
39245 wxPyEndAllowThreads(__tstate);
39246 if (PyErr_Occurred()) SWIG_fail;
39247 }
39248 Py_INCREF(Py_None); resultobj = Py_None;
39249 return resultobj;
39250 fail:
39251 return NULL;
39252 }
39253
39254
39255 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
39256 PyObject *resultobj;
39257 wxSizer *arg1 = (wxSizer *) 0 ;
39258 PyObject *result;
39259 PyObject * obj0 = 0 ;
39260 char *kwnames[] = {
39261 (char *) "self", NULL
39262 };
39263
39264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
39265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39266 if (SWIG_arg_fail(1)) SWIG_fail;
39267 {
39268 PyThreadState* __tstate = wxPyBeginAllowThreads();
39269 result = (PyObject *)wxSizer_GetChildren(arg1);
39270
39271 wxPyEndAllowThreads(__tstate);
39272 if (PyErr_Occurred()) SWIG_fail;
39273 }
39274 resultobj = result;
39275 return resultobj;
39276 fail:
39277 return NULL;
39278 }
39279
39280
39281 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39282 PyObject *resultobj;
39283 wxSizer *arg1 = (wxSizer *) 0 ;
39284 PyObject *arg2 = (PyObject *) 0 ;
39285 bool arg3 = (bool) true ;
39286 bool arg4 = (bool) false ;
39287 bool result;
39288 PyObject * obj0 = 0 ;
39289 PyObject * obj1 = 0 ;
39290 PyObject * obj2 = 0 ;
39291 PyObject * obj3 = 0 ;
39292 char *kwnames[] = {
39293 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
39294 };
39295
39296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39298 if (SWIG_arg_fail(1)) SWIG_fail;
39299 arg2 = obj1;
39300 if (obj2) {
39301 {
39302 arg3 = (bool)(SWIG_As_bool(obj2));
39303 if (SWIG_arg_fail(3)) SWIG_fail;
39304 }
39305 }
39306 if (obj3) {
39307 {
39308 arg4 = (bool)(SWIG_As_bool(obj3));
39309 if (SWIG_arg_fail(4)) SWIG_fail;
39310 }
39311 }
39312 {
39313 PyThreadState* __tstate = wxPyBeginAllowThreads();
39314 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
39315
39316 wxPyEndAllowThreads(__tstate);
39317 if (PyErr_Occurred()) SWIG_fail;
39318 }
39319 {
39320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39321 }
39322 return resultobj;
39323 fail:
39324 return NULL;
39325 }
39326
39327
39328 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39329 PyObject *resultobj;
39330 wxSizer *arg1 = (wxSizer *) 0 ;
39331 PyObject *arg2 = (PyObject *) 0 ;
39332 bool result;
39333 PyObject * obj0 = 0 ;
39334 PyObject * obj1 = 0 ;
39335 char *kwnames[] = {
39336 (char *) "self",(char *) "item", NULL
39337 };
39338
39339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
39340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39341 if (SWIG_arg_fail(1)) SWIG_fail;
39342 arg2 = obj1;
39343 {
39344 PyThreadState* __tstate = wxPyBeginAllowThreads();
39345 result = (bool)wxSizer_IsShown(arg1,arg2);
39346
39347 wxPyEndAllowThreads(__tstate);
39348 if (PyErr_Occurred()) SWIG_fail;
39349 }
39350 {
39351 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39352 }
39353 return resultobj;
39354 fail:
39355 return NULL;
39356 }
39357
39358
39359 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
39360 PyObject *resultobj;
39361 wxSizer *arg1 = (wxSizer *) 0 ;
39362 bool arg2 ;
39363 PyObject * obj0 = 0 ;
39364 PyObject * obj1 = 0 ;
39365 char *kwnames[] = {
39366 (char *) "self",(char *) "show", NULL
39367 };
39368
39369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
39370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39371 if (SWIG_arg_fail(1)) SWIG_fail;
39372 {
39373 arg2 = (bool)(SWIG_As_bool(obj1));
39374 if (SWIG_arg_fail(2)) SWIG_fail;
39375 }
39376 {
39377 PyThreadState* __tstate = wxPyBeginAllowThreads();
39378 (arg1)->ShowItems(arg2);
39379
39380 wxPyEndAllowThreads(__tstate);
39381 if (PyErr_Occurred()) SWIG_fail;
39382 }
39383 Py_INCREF(Py_None); resultobj = Py_None;
39384 return resultobj;
39385 fail:
39386 return NULL;
39387 }
39388
39389
39390 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
39391 PyObject *obj;
39392 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39393 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
39394 Py_INCREF(obj);
39395 return Py_BuildValue((char *)"");
39396 }
39397 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
39398 PyObject *resultobj;
39399 wxPySizer *result;
39400 char *kwnames[] = {
39401 NULL
39402 };
39403
39404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
39405 {
39406 PyThreadState* __tstate = wxPyBeginAllowThreads();
39407 result = (wxPySizer *)new wxPySizer();
39408
39409 wxPyEndAllowThreads(__tstate);
39410 if (PyErr_Occurred()) SWIG_fail;
39411 }
39412 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
39413 return resultobj;
39414 fail:
39415 return NULL;
39416 }
39417
39418
39419 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39420 PyObject *resultobj;
39421 wxPySizer *arg1 = (wxPySizer *) 0 ;
39422 PyObject *arg2 = (PyObject *) 0 ;
39423 PyObject *arg3 = (PyObject *) 0 ;
39424 PyObject * obj0 = 0 ;
39425 PyObject * obj1 = 0 ;
39426 PyObject * obj2 = 0 ;
39427 char *kwnames[] = {
39428 (char *) "self",(char *) "self",(char *) "_class", NULL
39429 };
39430
39431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
39432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
39433 if (SWIG_arg_fail(1)) SWIG_fail;
39434 arg2 = obj1;
39435 arg3 = obj2;
39436 {
39437 PyThreadState* __tstate = wxPyBeginAllowThreads();
39438 (arg1)->_setCallbackInfo(arg2,arg3);
39439
39440 wxPyEndAllowThreads(__tstate);
39441 if (PyErr_Occurred()) SWIG_fail;
39442 }
39443 Py_INCREF(Py_None); resultobj = Py_None;
39444 return resultobj;
39445 fail:
39446 return NULL;
39447 }
39448
39449
39450 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
39451 PyObject *obj;
39452 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39453 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
39454 Py_INCREF(obj);
39455 return Py_BuildValue((char *)"");
39456 }
39457 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39458 PyObject *resultobj;
39459 int arg1 = (int) wxHORIZONTAL ;
39460 wxBoxSizer *result;
39461 PyObject * obj0 = 0 ;
39462 char *kwnames[] = {
39463 (char *) "orient", NULL
39464 };
39465
39466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
39467 if (obj0) {
39468 {
39469 arg1 = (int)(SWIG_As_int(obj0));
39470 if (SWIG_arg_fail(1)) SWIG_fail;
39471 }
39472 }
39473 {
39474 PyThreadState* __tstate = wxPyBeginAllowThreads();
39475 result = (wxBoxSizer *)new wxBoxSizer(arg1);
39476
39477 wxPyEndAllowThreads(__tstate);
39478 if (PyErr_Occurred()) SWIG_fail;
39479 }
39480 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
39481 return resultobj;
39482 fail:
39483 return NULL;
39484 }
39485
39486
39487 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
39488 PyObject *resultobj;
39489 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
39490 int result;
39491 PyObject * obj0 = 0 ;
39492 char *kwnames[] = {
39493 (char *) "self", NULL
39494 };
39495
39496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
39497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39498 if (SWIG_arg_fail(1)) SWIG_fail;
39499 {
39500 PyThreadState* __tstate = wxPyBeginAllowThreads();
39501 result = (int)(arg1)->GetOrientation();
39502
39503 wxPyEndAllowThreads(__tstate);
39504 if (PyErr_Occurred()) SWIG_fail;
39505 }
39506 {
39507 resultobj = SWIG_From_int((int)(result));
39508 }
39509 return resultobj;
39510 fail:
39511 return NULL;
39512 }
39513
39514
39515 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
39516 PyObject *resultobj;
39517 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
39518 int arg2 ;
39519 PyObject * obj0 = 0 ;
39520 PyObject * obj1 = 0 ;
39521 char *kwnames[] = {
39522 (char *) "self",(char *) "orient", NULL
39523 };
39524
39525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
39526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39527 if (SWIG_arg_fail(1)) SWIG_fail;
39528 {
39529 arg2 = (int)(SWIG_As_int(obj1));
39530 if (SWIG_arg_fail(2)) SWIG_fail;
39531 }
39532 {
39533 PyThreadState* __tstate = wxPyBeginAllowThreads();
39534 (arg1)->SetOrientation(arg2);
39535
39536 wxPyEndAllowThreads(__tstate);
39537 if (PyErr_Occurred()) SWIG_fail;
39538 }
39539 Py_INCREF(Py_None); resultobj = Py_None;
39540 return resultobj;
39541 fail:
39542 return NULL;
39543 }
39544
39545
39546 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
39547 PyObject *obj;
39548 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39549 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
39550 Py_INCREF(obj);
39551 return Py_BuildValue((char *)"");
39552 }
39553 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39554 PyObject *resultobj;
39555 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
39556 int arg2 = (int) wxHORIZONTAL ;
39557 wxStaticBoxSizer *result;
39558 PyObject * obj0 = 0 ;
39559 PyObject * obj1 = 0 ;
39560 char *kwnames[] = {
39561 (char *) "box",(char *) "orient", NULL
39562 };
39563
39564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
39565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
39566 if (SWIG_arg_fail(1)) SWIG_fail;
39567 if (obj1) {
39568 {
39569 arg2 = (int)(SWIG_As_int(obj1));
39570 if (SWIG_arg_fail(2)) SWIG_fail;
39571 }
39572 }
39573 {
39574 PyThreadState* __tstate = wxPyBeginAllowThreads();
39575 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
39576
39577 wxPyEndAllowThreads(__tstate);
39578 if (PyErr_Occurred()) SWIG_fail;
39579 }
39580 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
39581 return resultobj;
39582 fail:
39583 return NULL;
39584 }
39585
39586
39587 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
39588 PyObject *resultobj;
39589 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
39590 wxStaticBox *result;
39591 PyObject * obj0 = 0 ;
39592 char *kwnames[] = {
39593 (char *) "self", NULL
39594 };
39595
39596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
39597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
39598 if (SWIG_arg_fail(1)) SWIG_fail;
39599 {
39600 PyThreadState* __tstate = wxPyBeginAllowThreads();
39601 result = (wxStaticBox *)(arg1)->GetStaticBox();
39602
39603 wxPyEndAllowThreads(__tstate);
39604 if (PyErr_Occurred()) SWIG_fail;
39605 }
39606 {
39607 resultobj = wxPyMake_wxObject(result, 0);
39608 }
39609 return resultobj;
39610 fail:
39611 return NULL;
39612 }
39613
39614
39615 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
39616 PyObject *obj;
39617 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39618 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
39619 Py_INCREF(obj);
39620 return Py_BuildValue((char *)"");
39621 }
39622 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39623 PyObject *resultobj;
39624 int arg1 = (int) 1 ;
39625 int arg2 = (int) 0 ;
39626 int arg3 = (int) 0 ;
39627 int arg4 = (int) 0 ;
39628 wxGridSizer *result;
39629 PyObject * obj0 = 0 ;
39630 PyObject * obj1 = 0 ;
39631 PyObject * obj2 = 0 ;
39632 PyObject * obj3 = 0 ;
39633 char *kwnames[] = {
39634 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
39635 };
39636
39637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39638 if (obj0) {
39639 {
39640 arg1 = (int)(SWIG_As_int(obj0));
39641 if (SWIG_arg_fail(1)) SWIG_fail;
39642 }
39643 }
39644 if (obj1) {
39645 {
39646 arg2 = (int)(SWIG_As_int(obj1));
39647 if (SWIG_arg_fail(2)) SWIG_fail;
39648 }
39649 }
39650 if (obj2) {
39651 {
39652 arg3 = (int)(SWIG_As_int(obj2));
39653 if (SWIG_arg_fail(3)) SWIG_fail;
39654 }
39655 }
39656 if (obj3) {
39657 {
39658 arg4 = (int)(SWIG_As_int(obj3));
39659 if (SWIG_arg_fail(4)) SWIG_fail;
39660 }
39661 }
39662 {
39663 PyThreadState* __tstate = wxPyBeginAllowThreads();
39664 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
39665
39666 wxPyEndAllowThreads(__tstate);
39667 if (PyErr_Occurred()) SWIG_fail;
39668 }
39669 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
39670 return resultobj;
39671 fail:
39672 return NULL;
39673 }
39674
39675
39676 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
39677 PyObject *resultobj;
39678 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39679 int arg2 ;
39680 PyObject * obj0 = 0 ;
39681 PyObject * obj1 = 0 ;
39682 char *kwnames[] = {
39683 (char *) "self",(char *) "cols", NULL
39684 };
39685
39686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
39687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39688 if (SWIG_arg_fail(1)) SWIG_fail;
39689 {
39690 arg2 = (int)(SWIG_As_int(obj1));
39691 if (SWIG_arg_fail(2)) SWIG_fail;
39692 }
39693 {
39694 PyThreadState* __tstate = wxPyBeginAllowThreads();
39695 (arg1)->SetCols(arg2);
39696
39697 wxPyEndAllowThreads(__tstate);
39698 if (PyErr_Occurred()) SWIG_fail;
39699 }
39700 Py_INCREF(Py_None); resultobj = Py_None;
39701 return resultobj;
39702 fail:
39703 return NULL;
39704 }
39705
39706
39707 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
39708 PyObject *resultobj;
39709 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39710 int arg2 ;
39711 PyObject * obj0 = 0 ;
39712 PyObject * obj1 = 0 ;
39713 char *kwnames[] = {
39714 (char *) "self",(char *) "rows", NULL
39715 };
39716
39717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
39718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39719 if (SWIG_arg_fail(1)) SWIG_fail;
39720 {
39721 arg2 = (int)(SWIG_As_int(obj1));
39722 if (SWIG_arg_fail(2)) SWIG_fail;
39723 }
39724 {
39725 PyThreadState* __tstate = wxPyBeginAllowThreads();
39726 (arg1)->SetRows(arg2);
39727
39728 wxPyEndAllowThreads(__tstate);
39729 if (PyErr_Occurred()) SWIG_fail;
39730 }
39731 Py_INCREF(Py_None); resultobj = Py_None;
39732 return resultobj;
39733 fail:
39734 return NULL;
39735 }
39736
39737
39738 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
39739 PyObject *resultobj;
39740 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39741 int arg2 ;
39742 PyObject * obj0 = 0 ;
39743 PyObject * obj1 = 0 ;
39744 char *kwnames[] = {
39745 (char *) "self",(char *) "gap", NULL
39746 };
39747
39748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
39749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39750 if (SWIG_arg_fail(1)) SWIG_fail;
39751 {
39752 arg2 = (int)(SWIG_As_int(obj1));
39753 if (SWIG_arg_fail(2)) SWIG_fail;
39754 }
39755 {
39756 PyThreadState* __tstate = wxPyBeginAllowThreads();
39757 (arg1)->SetVGap(arg2);
39758
39759 wxPyEndAllowThreads(__tstate);
39760 if (PyErr_Occurred()) SWIG_fail;
39761 }
39762 Py_INCREF(Py_None); resultobj = Py_None;
39763 return resultobj;
39764 fail:
39765 return NULL;
39766 }
39767
39768
39769 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
39770 PyObject *resultobj;
39771 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39772 int arg2 ;
39773 PyObject * obj0 = 0 ;
39774 PyObject * obj1 = 0 ;
39775 char *kwnames[] = {
39776 (char *) "self",(char *) "gap", NULL
39777 };
39778
39779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
39780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39781 if (SWIG_arg_fail(1)) SWIG_fail;
39782 {
39783 arg2 = (int)(SWIG_As_int(obj1));
39784 if (SWIG_arg_fail(2)) SWIG_fail;
39785 }
39786 {
39787 PyThreadState* __tstate = wxPyBeginAllowThreads();
39788 (arg1)->SetHGap(arg2);
39789
39790 wxPyEndAllowThreads(__tstate);
39791 if (PyErr_Occurred()) SWIG_fail;
39792 }
39793 Py_INCREF(Py_None); resultobj = Py_None;
39794 return resultobj;
39795 fail:
39796 return NULL;
39797 }
39798
39799
39800 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
39801 PyObject *resultobj;
39802 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39803 int result;
39804 PyObject * obj0 = 0 ;
39805 char *kwnames[] = {
39806 (char *) "self", NULL
39807 };
39808
39809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
39810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39811 if (SWIG_arg_fail(1)) SWIG_fail;
39812 {
39813 PyThreadState* __tstate = wxPyBeginAllowThreads();
39814 result = (int)(arg1)->GetCols();
39815
39816 wxPyEndAllowThreads(__tstate);
39817 if (PyErr_Occurred()) SWIG_fail;
39818 }
39819 {
39820 resultobj = SWIG_From_int((int)(result));
39821 }
39822 return resultobj;
39823 fail:
39824 return NULL;
39825 }
39826
39827
39828 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
39829 PyObject *resultobj;
39830 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39831 int result;
39832 PyObject * obj0 = 0 ;
39833 char *kwnames[] = {
39834 (char *) "self", NULL
39835 };
39836
39837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
39838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39839 if (SWIG_arg_fail(1)) SWIG_fail;
39840 {
39841 PyThreadState* __tstate = wxPyBeginAllowThreads();
39842 result = (int)(arg1)->GetRows();
39843
39844 wxPyEndAllowThreads(__tstate);
39845 if (PyErr_Occurred()) SWIG_fail;
39846 }
39847 {
39848 resultobj = SWIG_From_int((int)(result));
39849 }
39850 return resultobj;
39851 fail:
39852 return NULL;
39853 }
39854
39855
39856 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
39857 PyObject *resultobj;
39858 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39859 int result;
39860 PyObject * obj0 = 0 ;
39861 char *kwnames[] = {
39862 (char *) "self", NULL
39863 };
39864
39865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
39866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39867 if (SWIG_arg_fail(1)) SWIG_fail;
39868 {
39869 PyThreadState* __tstate = wxPyBeginAllowThreads();
39870 result = (int)(arg1)->GetVGap();
39871
39872 wxPyEndAllowThreads(__tstate);
39873 if (PyErr_Occurred()) SWIG_fail;
39874 }
39875 {
39876 resultobj = SWIG_From_int((int)(result));
39877 }
39878 return resultobj;
39879 fail:
39880 return NULL;
39881 }
39882
39883
39884 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
39885 PyObject *resultobj;
39886 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
39887 int result;
39888 PyObject * obj0 = 0 ;
39889 char *kwnames[] = {
39890 (char *) "self", NULL
39891 };
39892
39893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
39894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
39895 if (SWIG_arg_fail(1)) SWIG_fail;
39896 {
39897 PyThreadState* __tstate = wxPyBeginAllowThreads();
39898 result = (int)(arg1)->GetHGap();
39899
39900 wxPyEndAllowThreads(__tstate);
39901 if (PyErr_Occurred()) SWIG_fail;
39902 }
39903 {
39904 resultobj = SWIG_From_int((int)(result));
39905 }
39906 return resultobj;
39907 fail:
39908 return NULL;
39909 }
39910
39911
39912 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
39913 PyObject *obj;
39914 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39915 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
39916 Py_INCREF(obj);
39917 return Py_BuildValue((char *)"");
39918 }
39919 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39920 PyObject *resultobj;
39921 int arg1 = (int) 1 ;
39922 int arg2 = (int) 0 ;
39923 int arg3 = (int) 0 ;
39924 int arg4 = (int) 0 ;
39925 wxFlexGridSizer *result;
39926 PyObject * obj0 = 0 ;
39927 PyObject * obj1 = 0 ;
39928 PyObject * obj2 = 0 ;
39929 PyObject * obj3 = 0 ;
39930 char *kwnames[] = {
39931 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
39932 };
39933
39934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
39935 if (obj0) {
39936 {
39937 arg1 = (int)(SWIG_As_int(obj0));
39938 if (SWIG_arg_fail(1)) SWIG_fail;
39939 }
39940 }
39941 if (obj1) {
39942 {
39943 arg2 = (int)(SWIG_As_int(obj1));
39944 if (SWIG_arg_fail(2)) SWIG_fail;
39945 }
39946 }
39947 if (obj2) {
39948 {
39949 arg3 = (int)(SWIG_As_int(obj2));
39950 if (SWIG_arg_fail(3)) SWIG_fail;
39951 }
39952 }
39953 if (obj3) {
39954 {
39955 arg4 = (int)(SWIG_As_int(obj3));
39956 if (SWIG_arg_fail(4)) SWIG_fail;
39957 }
39958 }
39959 {
39960 PyThreadState* __tstate = wxPyBeginAllowThreads();
39961 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
39962
39963 wxPyEndAllowThreads(__tstate);
39964 if (PyErr_Occurred()) SWIG_fail;
39965 }
39966 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
39967 return resultobj;
39968 fail:
39969 return NULL;
39970 }
39971
39972
39973 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
39974 PyObject *resultobj;
39975 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
39976 size_t arg2 ;
39977 int arg3 = (int) 0 ;
39978 PyObject * obj0 = 0 ;
39979 PyObject * obj1 = 0 ;
39980 PyObject * obj2 = 0 ;
39981 char *kwnames[] = {
39982 (char *) "self",(char *) "idx",(char *) "proportion", NULL
39983 };
39984
39985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
39986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
39987 if (SWIG_arg_fail(1)) SWIG_fail;
39988 {
39989 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39990 if (SWIG_arg_fail(2)) SWIG_fail;
39991 }
39992 if (obj2) {
39993 {
39994 arg3 = (int)(SWIG_As_int(obj2));
39995 if (SWIG_arg_fail(3)) SWIG_fail;
39996 }
39997 }
39998 {
39999 PyThreadState* __tstate = wxPyBeginAllowThreads();
40000 (arg1)->AddGrowableRow(arg2,arg3);
40001
40002 wxPyEndAllowThreads(__tstate);
40003 if (PyErr_Occurred()) SWIG_fail;
40004 }
40005 Py_INCREF(Py_None); resultobj = Py_None;
40006 return resultobj;
40007 fail:
40008 return NULL;
40009 }
40010
40011
40012 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
40013 PyObject *resultobj;
40014 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40015 size_t arg2 ;
40016 PyObject * obj0 = 0 ;
40017 PyObject * obj1 = 0 ;
40018 char *kwnames[] = {
40019 (char *) "self",(char *) "idx", NULL
40020 };
40021
40022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
40023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40024 if (SWIG_arg_fail(1)) SWIG_fail;
40025 {
40026 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40027 if (SWIG_arg_fail(2)) SWIG_fail;
40028 }
40029 {
40030 PyThreadState* __tstate = wxPyBeginAllowThreads();
40031 (arg1)->RemoveGrowableRow(arg2);
40032
40033 wxPyEndAllowThreads(__tstate);
40034 if (PyErr_Occurred()) SWIG_fail;
40035 }
40036 Py_INCREF(Py_None); resultobj = Py_None;
40037 return resultobj;
40038 fail:
40039 return NULL;
40040 }
40041
40042
40043 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40044 PyObject *resultobj;
40045 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40046 size_t arg2 ;
40047 int arg3 = (int) 0 ;
40048 PyObject * obj0 = 0 ;
40049 PyObject * obj1 = 0 ;
40050 PyObject * obj2 = 0 ;
40051 char *kwnames[] = {
40052 (char *) "self",(char *) "idx",(char *) "proportion", NULL
40053 };
40054
40055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
40056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40057 if (SWIG_arg_fail(1)) SWIG_fail;
40058 {
40059 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40060 if (SWIG_arg_fail(2)) SWIG_fail;
40061 }
40062 if (obj2) {
40063 {
40064 arg3 = (int)(SWIG_As_int(obj2));
40065 if (SWIG_arg_fail(3)) SWIG_fail;
40066 }
40067 }
40068 {
40069 PyThreadState* __tstate = wxPyBeginAllowThreads();
40070 (arg1)->AddGrowableCol(arg2,arg3);
40071
40072 wxPyEndAllowThreads(__tstate);
40073 if (PyErr_Occurred()) SWIG_fail;
40074 }
40075 Py_INCREF(Py_None); resultobj = Py_None;
40076 return resultobj;
40077 fail:
40078 return NULL;
40079 }
40080
40081
40082 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
40083 PyObject *resultobj;
40084 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40085 size_t arg2 ;
40086 PyObject * obj0 = 0 ;
40087 PyObject * obj1 = 0 ;
40088 char *kwnames[] = {
40089 (char *) "self",(char *) "idx", NULL
40090 };
40091
40092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
40093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40094 if (SWIG_arg_fail(1)) SWIG_fail;
40095 {
40096 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40097 if (SWIG_arg_fail(2)) SWIG_fail;
40098 }
40099 {
40100 PyThreadState* __tstate = wxPyBeginAllowThreads();
40101 (arg1)->RemoveGrowableCol(arg2);
40102
40103 wxPyEndAllowThreads(__tstate);
40104 if (PyErr_Occurred()) SWIG_fail;
40105 }
40106 Py_INCREF(Py_None); resultobj = Py_None;
40107 return resultobj;
40108 fail:
40109 return NULL;
40110 }
40111
40112
40113 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40114 PyObject *resultobj;
40115 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40116 int arg2 ;
40117 PyObject * obj0 = 0 ;
40118 PyObject * obj1 = 0 ;
40119 char *kwnames[] = {
40120 (char *) "self",(char *) "direction", NULL
40121 };
40122
40123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
40124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40125 if (SWIG_arg_fail(1)) SWIG_fail;
40126 {
40127 arg2 = (int)(SWIG_As_int(obj1));
40128 if (SWIG_arg_fail(2)) SWIG_fail;
40129 }
40130 {
40131 PyThreadState* __tstate = wxPyBeginAllowThreads();
40132 (arg1)->SetFlexibleDirection(arg2);
40133
40134 wxPyEndAllowThreads(__tstate);
40135 if (PyErr_Occurred()) SWIG_fail;
40136 }
40137 Py_INCREF(Py_None); resultobj = Py_None;
40138 return resultobj;
40139 fail:
40140 return NULL;
40141 }
40142
40143
40144 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
40145 PyObject *resultobj;
40146 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40147 int result;
40148 PyObject * obj0 = 0 ;
40149 char *kwnames[] = {
40150 (char *) "self", NULL
40151 };
40152
40153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
40154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40155 if (SWIG_arg_fail(1)) SWIG_fail;
40156 {
40157 PyThreadState* __tstate = wxPyBeginAllowThreads();
40158 result = (int)(arg1)->GetFlexibleDirection();
40159
40160 wxPyEndAllowThreads(__tstate);
40161 if (PyErr_Occurred()) SWIG_fail;
40162 }
40163 {
40164 resultobj = SWIG_From_int((int)(result));
40165 }
40166 return resultobj;
40167 fail:
40168 return NULL;
40169 }
40170
40171
40172 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40173 PyObject *resultobj;
40174 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40175 wxFlexSizerGrowMode arg2 ;
40176 PyObject * obj0 = 0 ;
40177 PyObject * obj1 = 0 ;
40178 char *kwnames[] = {
40179 (char *) "self",(char *) "mode", NULL
40180 };
40181
40182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
40183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40184 if (SWIG_arg_fail(1)) SWIG_fail;
40185 {
40186 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
40187 if (SWIG_arg_fail(2)) SWIG_fail;
40188 }
40189 {
40190 PyThreadState* __tstate = wxPyBeginAllowThreads();
40191 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
40192
40193 wxPyEndAllowThreads(__tstate);
40194 if (PyErr_Occurred()) SWIG_fail;
40195 }
40196 Py_INCREF(Py_None); resultobj = Py_None;
40197 return resultobj;
40198 fail:
40199 return NULL;
40200 }
40201
40202
40203 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
40204 PyObject *resultobj;
40205 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40206 wxFlexSizerGrowMode result;
40207 PyObject * obj0 = 0 ;
40208 char *kwnames[] = {
40209 (char *) "self", NULL
40210 };
40211
40212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
40213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40214 if (SWIG_arg_fail(1)) SWIG_fail;
40215 {
40216 PyThreadState* __tstate = wxPyBeginAllowThreads();
40217 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
40218
40219 wxPyEndAllowThreads(__tstate);
40220 if (PyErr_Occurred()) SWIG_fail;
40221 }
40222 resultobj = SWIG_From_int((result));
40223 return resultobj;
40224 fail:
40225 return NULL;
40226 }
40227
40228
40229 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
40230 PyObject *resultobj;
40231 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40232 wxArrayInt *result;
40233 PyObject * obj0 = 0 ;
40234 char *kwnames[] = {
40235 (char *) "self", NULL
40236 };
40237
40238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
40239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40240 if (SWIG_arg_fail(1)) SWIG_fail;
40241 {
40242 PyThreadState* __tstate = wxPyBeginAllowThreads();
40243 {
40244 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
40245 result = (wxArrayInt *) &_result_ref;
40246 }
40247
40248 wxPyEndAllowThreads(__tstate);
40249 if (PyErr_Occurred()) SWIG_fail;
40250 }
40251 {
40252 resultobj = PyList_New(0);
40253 size_t idx;
40254 for (idx = 0; idx < result->GetCount(); idx += 1) {
40255 PyObject* val = PyInt_FromLong( result->Item(idx) );
40256 PyList_Append(resultobj, val);
40257 Py_DECREF(val);
40258 }
40259 }
40260 return resultobj;
40261 fail:
40262 return NULL;
40263 }
40264
40265
40266 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
40267 PyObject *resultobj;
40268 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
40269 wxArrayInt *result;
40270 PyObject * obj0 = 0 ;
40271 char *kwnames[] = {
40272 (char *) "self", NULL
40273 };
40274
40275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
40276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
40277 if (SWIG_arg_fail(1)) SWIG_fail;
40278 {
40279 PyThreadState* __tstate = wxPyBeginAllowThreads();
40280 {
40281 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
40282 result = (wxArrayInt *) &_result_ref;
40283 }
40284
40285 wxPyEndAllowThreads(__tstate);
40286 if (PyErr_Occurred()) SWIG_fail;
40287 }
40288 {
40289 resultobj = PyList_New(0);
40290 size_t idx;
40291 for (idx = 0; idx < result->GetCount(); idx += 1) {
40292 PyObject* val = PyInt_FromLong( result->Item(idx) );
40293 PyList_Append(resultobj, val);
40294 Py_DECREF(val);
40295 }
40296 }
40297 return resultobj;
40298 fail:
40299 return NULL;
40300 }
40301
40302
40303 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
40304 PyObject *obj;
40305 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40306 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
40307 Py_INCREF(obj);
40308 return Py_BuildValue((char *)"");
40309 }
40310 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40311 PyObject *resultobj;
40312 wxStdDialogButtonSizer *result;
40313 char *kwnames[] = {
40314 NULL
40315 };
40316
40317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
40318 {
40319 PyThreadState* __tstate = wxPyBeginAllowThreads();
40320 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
40321
40322 wxPyEndAllowThreads(__tstate);
40323 if (PyErr_Occurred()) SWIG_fail;
40324 }
40325 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
40326 return resultobj;
40327 fail:
40328 return NULL;
40329 }
40330
40331
40332 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
40333 PyObject *resultobj;
40334 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40335 wxButton *arg2 = (wxButton *) 0 ;
40336 PyObject * obj0 = 0 ;
40337 PyObject * obj1 = 0 ;
40338 char *kwnames[] = {
40339 (char *) "self",(char *) "button", NULL
40340 };
40341
40342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
40343 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40344 if (SWIG_arg_fail(1)) SWIG_fail;
40345 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40346 if (SWIG_arg_fail(2)) SWIG_fail;
40347 {
40348 PyThreadState* __tstate = wxPyBeginAllowThreads();
40349 (arg1)->AddButton(arg2);
40350
40351 wxPyEndAllowThreads(__tstate);
40352 if (PyErr_Occurred()) SWIG_fail;
40353 }
40354 Py_INCREF(Py_None); resultobj = Py_None;
40355 return resultobj;
40356 fail:
40357 return NULL;
40358 }
40359
40360
40361 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
40362 PyObject *resultobj;
40363 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40364 PyObject * obj0 = 0 ;
40365 char *kwnames[] = {
40366 (char *) "self", NULL
40367 };
40368
40369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
40370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40371 if (SWIG_arg_fail(1)) SWIG_fail;
40372 {
40373 PyThreadState* __tstate = wxPyBeginAllowThreads();
40374 (arg1)->Realize();
40375
40376 wxPyEndAllowThreads(__tstate);
40377 if (PyErr_Occurred()) SWIG_fail;
40378 }
40379 Py_INCREF(Py_None); resultobj = Py_None;
40380 return resultobj;
40381 fail:
40382 return NULL;
40383 }
40384
40385
40386 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40387 PyObject *resultobj;
40388 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40389 wxButton *arg2 = (wxButton *) 0 ;
40390 PyObject * obj0 = 0 ;
40391 PyObject * obj1 = 0 ;
40392 char *kwnames[] = {
40393 (char *) "self",(char *) "button", NULL
40394 };
40395
40396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
40397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40398 if (SWIG_arg_fail(1)) SWIG_fail;
40399 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40400 if (SWIG_arg_fail(2)) SWIG_fail;
40401 {
40402 PyThreadState* __tstate = wxPyBeginAllowThreads();
40403 (arg1)->SetAffirmativeButton(arg2);
40404
40405 wxPyEndAllowThreads(__tstate);
40406 if (PyErr_Occurred()) SWIG_fail;
40407 }
40408 Py_INCREF(Py_None); resultobj = Py_None;
40409 return resultobj;
40410 fail:
40411 return NULL;
40412 }
40413
40414
40415 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40416 PyObject *resultobj;
40417 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40418 wxButton *arg2 = (wxButton *) 0 ;
40419 PyObject * obj0 = 0 ;
40420 PyObject * obj1 = 0 ;
40421 char *kwnames[] = {
40422 (char *) "self",(char *) "button", NULL
40423 };
40424
40425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
40426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40427 if (SWIG_arg_fail(1)) SWIG_fail;
40428 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40429 if (SWIG_arg_fail(2)) SWIG_fail;
40430 {
40431 PyThreadState* __tstate = wxPyBeginAllowThreads();
40432 (arg1)->SetNegativeButton(arg2);
40433
40434 wxPyEndAllowThreads(__tstate);
40435 if (PyErr_Occurred()) SWIG_fail;
40436 }
40437 Py_INCREF(Py_None); resultobj = Py_None;
40438 return resultobj;
40439 fail:
40440 return NULL;
40441 }
40442
40443
40444 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
40445 PyObject *resultobj;
40446 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40447 wxButton *arg2 = (wxButton *) 0 ;
40448 PyObject * obj0 = 0 ;
40449 PyObject * obj1 = 0 ;
40450 char *kwnames[] = {
40451 (char *) "self",(char *) "button", NULL
40452 };
40453
40454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
40455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40456 if (SWIG_arg_fail(1)) SWIG_fail;
40457 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
40458 if (SWIG_arg_fail(2)) SWIG_fail;
40459 {
40460 PyThreadState* __tstate = wxPyBeginAllowThreads();
40461 (arg1)->SetCancelButton(arg2);
40462
40463 wxPyEndAllowThreads(__tstate);
40464 if (PyErr_Occurred()) SWIG_fail;
40465 }
40466 Py_INCREF(Py_None); resultobj = Py_None;
40467 return resultobj;
40468 fail:
40469 return NULL;
40470 }
40471
40472
40473 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40474 PyObject *resultobj;
40475 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40476 wxButton *result;
40477 PyObject * obj0 = 0 ;
40478 char *kwnames[] = {
40479 (char *) "self", NULL
40480 };
40481
40482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
40483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40484 if (SWIG_arg_fail(1)) SWIG_fail;
40485 {
40486 PyThreadState* __tstate = wxPyBeginAllowThreads();
40487 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
40488
40489 wxPyEndAllowThreads(__tstate);
40490 if (PyErr_Occurred()) SWIG_fail;
40491 }
40492 {
40493 resultobj = wxPyMake_wxObject(result, 0);
40494 }
40495 return resultobj;
40496 fail:
40497 return NULL;
40498 }
40499
40500
40501 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
40502 PyObject *resultobj;
40503 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40504 wxButton *result;
40505 PyObject * obj0 = 0 ;
40506 char *kwnames[] = {
40507 (char *) "self", NULL
40508 };
40509
40510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
40511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40512 if (SWIG_arg_fail(1)) SWIG_fail;
40513 {
40514 PyThreadState* __tstate = wxPyBeginAllowThreads();
40515 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
40516
40517 wxPyEndAllowThreads(__tstate);
40518 if (PyErr_Occurred()) SWIG_fail;
40519 }
40520 {
40521 resultobj = wxPyMake_wxObject(result, 0);
40522 }
40523 return resultobj;
40524 fail:
40525 return NULL;
40526 }
40527
40528
40529 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
40530 PyObject *resultobj;
40531 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40532 wxButton *result;
40533 PyObject * obj0 = 0 ;
40534 char *kwnames[] = {
40535 (char *) "self", NULL
40536 };
40537
40538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
40539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40540 if (SWIG_arg_fail(1)) SWIG_fail;
40541 {
40542 PyThreadState* __tstate = wxPyBeginAllowThreads();
40543 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
40544
40545 wxPyEndAllowThreads(__tstate);
40546 if (PyErr_Occurred()) SWIG_fail;
40547 }
40548 {
40549 resultobj = wxPyMake_wxObject(result, 0);
40550 }
40551 return resultobj;
40552 fail:
40553 return NULL;
40554 }
40555
40556
40557 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
40558 PyObject *resultobj;
40559 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40560 wxButton *result;
40561 PyObject * obj0 = 0 ;
40562 char *kwnames[] = {
40563 (char *) "self", NULL
40564 };
40565
40566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
40567 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40568 if (SWIG_arg_fail(1)) SWIG_fail;
40569 {
40570 PyThreadState* __tstate = wxPyBeginAllowThreads();
40571 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
40572
40573 wxPyEndAllowThreads(__tstate);
40574 if (PyErr_Occurred()) SWIG_fail;
40575 }
40576 {
40577 resultobj = wxPyMake_wxObject(result, 0);
40578 }
40579 return resultobj;
40580 fail:
40581 return NULL;
40582 }
40583
40584
40585 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
40586 PyObject *resultobj;
40587 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
40588 wxButton *result;
40589 PyObject * obj0 = 0 ;
40590 char *kwnames[] = {
40591 (char *) "self", NULL
40592 };
40593
40594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
40595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
40596 if (SWIG_arg_fail(1)) SWIG_fail;
40597 {
40598 PyThreadState* __tstate = wxPyBeginAllowThreads();
40599 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
40600
40601 wxPyEndAllowThreads(__tstate);
40602 if (PyErr_Occurred()) SWIG_fail;
40603 }
40604 {
40605 resultobj = wxPyMake_wxObject(result, 0);
40606 }
40607 return resultobj;
40608 fail:
40609 return NULL;
40610 }
40611
40612
40613 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
40614 PyObject *obj;
40615 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40616 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
40617 Py_INCREF(obj);
40618 return Py_BuildValue((char *)"");
40619 }
40620 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40621 PyObject *resultobj;
40622 int arg1 = (int) 0 ;
40623 int arg2 = (int) 0 ;
40624 wxGBPosition *result;
40625 PyObject * obj0 = 0 ;
40626 PyObject * obj1 = 0 ;
40627 char *kwnames[] = {
40628 (char *) "row",(char *) "col", NULL
40629 };
40630
40631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
40632 if (obj0) {
40633 {
40634 arg1 = (int)(SWIG_As_int(obj0));
40635 if (SWIG_arg_fail(1)) SWIG_fail;
40636 }
40637 }
40638 if (obj1) {
40639 {
40640 arg2 = (int)(SWIG_As_int(obj1));
40641 if (SWIG_arg_fail(2)) SWIG_fail;
40642 }
40643 }
40644 {
40645 PyThreadState* __tstate = wxPyBeginAllowThreads();
40646 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
40647
40648 wxPyEndAllowThreads(__tstate);
40649 if (PyErr_Occurred()) SWIG_fail;
40650 }
40651 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
40652 return resultobj;
40653 fail:
40654 return NULL;
40655 }
40656
40657
40658 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
40659 PyObject *resultobj;
40660 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40661 int result;
40662 PyObject * obj0 = 0 ;
40663 char *kwnames[] = {
40664 (char *) "self", NULL
40665 };
40666
40667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
40668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40669 if (SWIG_arg_fail(1)) SWIG_fail;
40670 {
40671 PyThreadState* __tstate = wxPyBeginAllowThreads();
40672 result = (int)((wxGBPosition const *)arg1)->GetRow();
40673
40674 wxPyEndAllowThreads(__tstate);
40675 if (PyErr_Occurred()) SWIG_fail;
40676 }
40677 {
40678 resultobj = SWIG_From_int((int)(result));
40679 }
40680 return resultobj;
40681 fail:
40682 return NULL;
40683 }
40684
40685
40686 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
40687 PyObject *resultobj;
40688 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40689 int result;
40690 PyObject * obj0 = 0 ;
40691 char *kwnames[] = {
40692 (char *) "self", NULL
40693 };
40694
40695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
40696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40697 if (SWIG_arg_fail(1)) SWIG_fail;
40698 {
40699 PyThreadState* __tstate = wxPyBeginAllowThreads();
40700 result = (int)((wxGBPosition const *)arg1)->GetCol();
40701
40702 wxPyEndAllowThreads(__tstate);
40703 if (PyErr_Occurred()) SWIG_fail;
40704 }
40705 {
40706 resultobj = SWIG_From_int((int)(result));
40707 }
40708 return resultobj;
40709 fail:
40710 return NULL;
40711 }
40712
40713
40714 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
40715 PyObject *resultobj;
40716 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40717 int arg2 ;
40718 PyObject * obj0 = 0 ;
40719 PyObject * obj1 = 0 ;
40720 char *kwnames[] = {
40721 (char *) "self",(char *) "row", NULL
40722 };
40723
40724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
40725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40726 if (SWIG_arg_fail(1)) SWIG_fail;
40727 {
40728 arg2 = (int)(SWIG_As_int(obj1));
40729 if (SWIG_arg_fail(2)) SWIG_fail;
40730 }
40731 {
40732 PyThreadState* __tstate = wxPyBeginAllowThreads();
40733 (arg1)->SetRow(arg2);
40734
40735 wxPyEndAllowThreads(__tstate);
40736 if (PyErr_Occurred()) SWIG_fail;
40737 }
40738 Py_INCREF(Py_None); resultobj = Py_None;
40739 return resultobj;
40740 fail:
40741 return NULL;
40742 }
40743
40744
40745 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
40746 PyObject *resultobj;
40747 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40748 int arg2 ;
40749 PyObject * obj0 = 0 ;
40750 PyObject * obj1 = 0 ;
40751 char *kwnames[] = {
40752 (char *) "self",(char *) "col", NULL
40753 };
40754
40755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
40756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40757 if (SWIG_arg_fail(1)) SWIG_fail;
40758 {
40759 arg2 = (int)(SWIG_As_int(obj1));
40760 if (SWIG_arg_fail(2)) SWIG_fail;
40761 }
40762 {
40763 PyThreadState* __tstate = wxPyBeginAllowThreads();
40764 (arg1)->SetCol(arg2);
40765
40766 wxPyEndAllowThreads(__tstate);
40767 if (PyErr_Occurred()) SWIG_fail;
40768 }
40769 Py_INCREF(Py_None); resultobj = Py_None;
40770 return resultobj;
40771 fail:
40772 return NULL;
40773 }
40774
40775
40776 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
40777 PyObject *resultobj;
40778 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40779 wxGBPosition *arg2 = 0 ;
40780 bool result;
40781 wxGBPosition temp2 ;
40782 PyObject * obj0 = 0 ;
40783 PyObject * obj1 = 0 ;
40784 char *kwnames[] = {
40785 (char *) "self",(char *) "other", NULL
40786 };
40787
40788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
40789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40790 if (SWIG_arg_fail(1)) SWIG_fail;
40791 {
40792 arg2 = &temp2;
40793 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40794 }
40795 {
40796 PyThreadState* __tstate = wxPyBeginAllowThreads();
40797 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
40798
40799 wxPyEndAllowThreads(__tstate);
40800 if (PyErr_Occurred()) SWIG_fail;
40801 }
40802 {
40803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40804 }
40805 return resultobj;
40806 fail:
40807 return NULL;
40808 }
40809
40810
40811 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
40812 PyObject *resultobj;
40813 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40814 wxGBPosition *arg2 = 0 ;
40815 bool result;
40816 wxGBPosition temp2 ;
40817 PyObject * obj0 = 0 ;
40818 PyObject * obj1 = 0 ;
40819 char *kwnames[] = {
40820 (char *) "self",(char *) "other", NULL
40821 };
40822
40823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
40824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40825 if (SWIG_arg_fail(1)) SWIG_fail;
40826 {
40827 arg2 = &temp2;
40828 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
40829 }
40830 {
40831 PyThreadState* __tstate = wxPyBeginAllowThreads();
40832 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
40833
40834 wxPyEndAllowThreads(__tstate);
40835 if (PyErr_Occurred()) SWIG_fail;
40836 }
40837 {
40838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40839 }
40840 return resultobj;
40841 fail:
40842 return NULL;
40843 }
40844
40845
40846 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
40847 PyObject *resultobj;
40848 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40849 int arg2 = (int) 0 ;
40850 int arg3 = (int) 0 ;
40851 PyObject * obj0 = 0 ;
40852 PyObject * obj1 = 0 ;
40853 PyObject * obj2 = 0 ;
40854 char *kwnames[] = {
40855 (char *) "self",(char *) "row",(char *) "col", NULL
40856 };
40857
40858 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
40859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40860 if (SWIG_arg_fail(1)) SWIG_fail;
40861 if (obj1) {
40862 {
40863 arg2 = (int)(SWIG_As_int(obj1));
40864 if (SWIG_arg_fail(2)) SWIG_fail;
40865 }
40866 }
40867 if (obj2) {
40868 {
40869 arg3 = (int)(SWIG_As_int(obj2));
40870 if (SWIG_arg_fail(3)) SWIG_fail;
40871 }
40872 }
40873 {
40874 PyThreadState* __tstate = wxPyBeginAllowThreads();
40875 wxGBPosition_Set(arg1,arg2,arg3);
40876
40877 wxPyEndAllowThreads(__tstate);
40878 if (PyErr_Occurred()) SWIG_fail;
40879 }
40880 Py_INCREF(Py_None); resultobj = Py_None;
40881 return resultobj;
40882 fail:
40883 return NULL;
40884 }
40885
40886
40887 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
40888 PyObject *resultobj;
40889 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
40890 PyObject *result;
40891 PyObject * obj0 = 0 ;
40892 char *kwnames[] = {
40893 (char *) "self", NULL
40894 };
40895
40896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
40897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
40898 if (SWIG_arg_fail(1)) SWIG_fail;
40899 {
40900 PyThreadState* __tstate = wxPyBeginAllowThreads();
40901 result = (PyObject *)wxGBPosition_Get(arg1);
40902
40903 wxPyEndAllowThreads(__tstate);
40904 if (PyErr_Occurred()) SWIG_fail;
40905 }
40906 resultobj = result;
40907 return resultobj;
40908 fail:
40909 return NULL;
40910 }
40911
40912
40913 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
40914 PyObject *obj;
40915 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40916 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
40917 Py_INCREF(obj);
40918 return Py_BuildValue((char *)"");
40919 }
40920 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
40921 PyObject *resultobj;
40922 int arg1 = (int) 1 ;
40923 int arg2 = (int) 1 ;
40924 wxGBSpan *result;
40925 PyObject * obj0 = 0 ;
40926 PyObject * obj1 = 0 ;
40927 char *kwnames[] = {
40928 (char *) "rowspan",(char *) "colspan", NULL
40929 };
40930
40931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
40932 if (obj0) {
40933 {
40934 arg1 = (int)(SWIG_As_int(obj0));
40935 if (SWIG_arg_fail(1)) SWIG_fail;
40936 }
40937 }
40938 if (obj1) {
40939 {
40940 arg2 = (int)(SWIG_As_int(obj1));
40941 if (SWIG_arg_fail(2)) SWIG_fail;
40942 }
40943 }
40944 {
40945 PyThreadState* __tstate = wxPyBeginAllowThreads();
40946 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
40947
40948 wxPyEndAllowThreads(__tstate);
40949 if (PyErr_Occurred()) SWIG_fail;
40950 }
40951 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
40952 return resultobj;
40953 fail:
40954 return NULL;
40955 }
40956
40957
40958 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
40959 PyObject *resultobj;
40960 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40961 int result;
40962 PyObject * obj0 = 0 ;
40963 char *kwnames[] = {
40964 (char *) "self", NULL
40965 };
40966
40967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
40968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40969 if (SWIG_arg_fail(1)) SWIG_fail;
40970 {
40971 PyThreadState* __tstate = wxPyBeginAllowThreads();
40972 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
40973
40974 wxPyEndAllowThreads(__tstate);
40975 if (PyErr_Occurred()) SWIG_fail;
40976 }
40977 {
40978 resultobj = SWIG_From_int((int)(result));
40979 }
40980 return resultobj;
40981 fail:
40982 return NULL;
40983 }
40984
40985
40986 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
40987 PyObject *resultobj;
40988 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
40989 int result;
40990 PyObject * obj0 = 0 ;
40991 char *kwnames[] = {
40992 (char *) "self", NULL
40993 };
40994
40995 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
40996 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
40997 if (SWIG_arg_fail(1)) SWIG_fail;
40998 {
40999 PyThreadState* __tstate = wxPyBeginAllowThreads();
41000 result = (int)((wxGBSpan const *)arg1)->GetColspan();
41001
41002 wxPyEndAllowThreads(__tstate);
41003 if (PyErr_Occurred()) SWIG_fail;
41004 }
41005 {
41006 resultobj = SWIG_From_int((int)(result));
41007 }
41008 return resultobj;
41009 fail:
41010 return NULL;
41011 }
41012
41013
41014 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
41015 PyObject *resultobj;
41016 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41017 int arg2 ;
41018 PyObject * obj0 = 0 ;
41019 PyObject * obj1 = 0 ;
41020 char *kwnames[] = {
41021 (char *) "self",(char *) "rowspan", NULL
41022 };
41023
41024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
41025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41026 if (SWIG_arg_fail(1)) SWIG_fail;
41027 {
41028 arg2 = (int)(SWIG_As_int(obj1));
41029 if (SWIG_arg_fail(2)) SWIG_fail;
41030 }
41031 {
41032 PyThreadState* __tstate = wxPyBeginAllowThreads();
41033 (arg1)->SetRowspan(arg2);
41034
41035 wxPyEndAllowThreads(__tstate);
41036 if (PyErr_Occurred()) SWIG_fail;
41037 }
41038 Py_INCREF(Py_None); resultobj = Py_None;
41039 return resultobj;
41040 fail:
41041 return NULL;
41042 }
41043
41044
41045 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
41046 PyObject *resultobj;
41047 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41048 int arg2 ;
41049 PyObject * obj0 = 0 ;
41050 PyObject * obj1 = 0 ;
41051 char *kwnames[] = {
41052 (char *) "self",(char *) "colspan", NULL
41053 };
41054
41055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
41056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41057 if (SWIG_arg_fail(1)) SWIG_fail;
41058 {
41059 arg2 = (int)(SWIG_As_int(obj1));
41060 if (SWIG_arg_fail(2)) SWIG_fail;
41061 }
41062 {
41063 PyThreadState* __tstate = wxPyBeginAllowThreads();
41064 (arg1)->SetColspan(arg2);
41065
41066 wxPyEndAllowThreads(__tstate);
41067 if (PyErr_Occurred()) SWIG_fail;
41068 }
41069 Py_INCREF(Py_None); resultobj = Py_None;
41070 return resultobj;
41071 fail:
41072 return NULL;
41073 }
41074
41075
41076 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41077 PyObject *resultobj;
41078 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41079 wxGBSpan *arg2 = 0 ;
41080 bool result;
41081 wxGBSpan temp2 ;
41082 PyObject * obj0 = 0 ;
41083 PyObject * obj1 = 0 ;
41084 char *kwnames[] = {
41085 (char *) "self",(char *) "other", NULL
41086 };
41087
41088 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
41089 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41090 if (SWIG_arg_fail(1)) SWIG_fail;
41091 {
41092 arg2 = &temp2;
41093 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41094 }
41095 {
41096 PyThreadState* __tstate = wxPyBeginAllowThreads();
41097 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
41098
41099 wxPyEndAllowThreads(__tstate);
41100 if (PyErr_Occurred()) SWIG_fail;
41101 }
41102 {
41103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41104 }
41105 return resultobj;
41106 fail:
41107 return NULL;
41108 }
41109
41110
41111 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41112 PyObject *resultobj;
41113 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41114 wxGBSpan *arg2 = 0 ;
41115 bool result;
41116 wxGBSpan temp2 ;
41117 PyObject * obj0 = 0 ;
41118 PyObject * obj1 = 0 ;
41119 char *kwnames[] = {
41120 (char *) "self",(char *) "other", NULL
41121 };
41122
41123 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
41124 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41125 if (SWIG_arg_fail(1)) SWIG_fail;
41126 {
41127 arg2 = &temp2;
41128 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41129 }
41130 {
41131 PyThreadState* __tstate = wxPyBeginAllowThreads();
41132 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
41133
41134 wxPyEndAllowThreads(__tstate);
41135 if (PyErr_Occurred()) SWIG_fail;
41136 }
41137 {
41138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41139 }
41140 return resultobj;
41141 fail:
41142 return NULL;
41143 }
41144
41145
41146 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41147 PyObject *resultobj;
41148 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41149 int arg2 = (int) 1 ;
41150 int arg3 = (int) 1 ;
41151 PyObject * obj0 = 0 ;
41152 PyObject * obj1 = 0 ;
41153 PyObject * obj2 = 0 ;
41154 char *kwnames[] = {
41155 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
41156 };
41157
41158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41160 if (SWIG_arg_fail(1)) SWIG_fail;
41161 if (obj1) {
41162 {
41163 arg2 = (int)(SWIG_As_int(obj1));
41164 if (SWIG_arg_fail(2)) SWIG_fail;
41165 }
41166 }
41167 if (obj2) {
41168 {
41169 arg3 = (int)(SWIG_As_int(obj2));
41170 if (SWIG_arg_fail(3)) SWIG_fail;
41171 }
41172 }
41173 {
41174 PyThreadState* __tstate = wxPyBeginAllowThreads();
41175 wxGBSpan_Set(arg1,arg2,arg3);
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_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41188 PyObject *resultobj;
41189 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
41190 PyObject *result;
41191 PyObject * obj0 = 0 ;
41192 char *kwnames[] = {
41193 (char *) "self", NULL
41194 };
41195
41196 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
41197 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
41198 if (SWIG_arg_fail(1)) SWIG_fail;
41199 {
41200 PyThreadState* __tstate = wxPyBeginAllowThreads();
41201 result = (PyObject *)wxGBSpan_Get(arg1);
41202
41203 wxPyEndAllowThreads(__tstate);
41204 if (PyErr_Occurred()) SWIG_fail;
41205 }
41206 resultobj = result;
41207 return resultobj;
41208 fail:
41209 return NULL;
41210 }
41211
41212
41213 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
41214 PyObject *obj;
41215 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41216 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
41217 Py_INCREF(obj);
41218 return Py_BuildValue((char *)"");
41219 }
41220 static int _wrap_DefaultSpan_set(PyObject *) {
41221 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
41222 return 1;
41223 }
41224
41225
41226 static PyObject *_wrap_DefaultSpan_get(void) {
41227 PyObject *pyobj;
41228
41229 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
41230 return pyobj;
41231 }
41232
41233
41234 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
41235 PyObject *resultobj;
41236 wxGBSizerItem *result;
41237 char *kwnames[] = {
41238 NULL
41239 };
41240
41241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
41242 {
41243 PyThreadState* __tstate = wxPyBeginAllowThreads();
41244 result = (wxGBSizerItem *)new wxGBSizerItem();
41245
41246 wxPyEndAllowThreads(__tstate);
41247 if (PyErr_Occurred()) SWIG_fail;
41248 }
41249 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41250 return resultobj;
41251 fail:
41252 return NULL;
41253 }
41254
41255
41256 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
41257 PyObject *resultobj;
41258 wxWindow *arg1 = (wxWindow *) 0 ;
41259 wxGBPosition *arg2 = 0 ;
41260 wxGBSpan *arg3 = 0 ;
41261 int arg4 ;
41262 int arg5 ;
41263 PyObject *arg6 = (PyObject *) NULL ;
41264 wxGBSizerItem *result;
41265 wxGBPosition temp2 ;
41266 wxGBSpan temp3 ;
41267 PyObject * obj0 = 0 ;
41268 PyObject * obj1 = 0 ;
41269 PyObject * obj2 = 0 ;
41270 PyObject * obj3 = 0 ;
41271 PyObject * obj4 = 0 ;
41272 PyObject * obj5 = 0 ;
41273 char *kwnames[] = {
41274 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41275 };
41276
41277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41279 if (SWIG_arg_fail(1)) SWIG_fail;
41280 {
41281 arg2 = &temp2;
41282 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41283 }
41284 {
41285 arg3 = &temp3;
41286 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41287 }
41288 {
41289 arg4 = (int)(SWIG_As_int(obj3));
41290 if (SWIG_arg_fail(4)) SWIG_fail;
41291 }
41292 {
41293 arg5 = (int)(SWIG_As_int(obj4));
41294 if (SWIG_arg_fail(5)) SWIG_fail;
41295 }
41296 if (obj5) {
41297 arg6 = obj5;
41298 }
41299 {
41300 PyThreadState* __tstate = wxPyBeginAllowThreads();
41301 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41302
41303 wxPyEndAllowThreads(__tstate);
41304 if (PyErr_Occurred()) SWIG_fail;
41305 }
41306 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41307 return resultobj;
41308 fail:
41309 return NULL;
41310 }
41311
41312
41313 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41314 PyObject *resultobj;
41315 wxSizer *arg1 = (wxSizer *) 0 ;
41316 wxGBPosition *arg2 = 0 ;
41317 wxGBSpan *arg3 = 0 ;
41318 int arg4 ;
41319 int arg5 ;
41320 PyObject *arg6 = (PyObject *) NULL ;
41321 wxGBSizerItem *result;
41322 wxGBPosition temp2 ;
41323 wxGBSpan temp3 ;
41324 PyObject * obj0 = 0 ;
41325 PyObject * obj1 = 0 ;
41326 PyObject * obj2 = 0 ;
41327 PyObject * obj3 = 0 ;
41328 PyObject * obj4 = 0 ;
41329 PyObject * obj5 = 0 ;
41330 char *kwnames[] = {
41331 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41332 };
41333
41334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
41335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41336 if (SWIG_arg_fail(1)) SWIG_fail;
41337 {
41338 arg2 = &temp2;
41339 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41340 }
41341 {
41342 arg3 = &temp3;
41343 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41344 }
41345 {
41346 arg4 = (int)(SWIG_As_int(obj3));
41347 if (SWIG_arg_fail(4)) SWIG_fail;
41348 }
41349 {
41350 arg5 = (int)(SWIG_As_int(obj4));
41351 if (SWIG_arg_fail(5)) SWIG_fail;
41352 }
41353 if (obj5) {
41354 arg6 = obj5;
41355 }
41356 {
41357 PyThreadState* __tstate = wxPyBeginAllowThreads();
41358 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
41359
41360 wxPyEndAllowThreads(__tstate);
41361 if (PyErr_Occurred()) SWIG_fail;
41362 }
41363 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41364 return resultobj;
41365 fail:
41366 return NULL;
41367 }
41368
41369
41370 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
41371 PyObject *resultobj;
41372 int arg1 ;
41373 int arg2 ;
41374 wxGBPosition *arg3 = 0 ;
41375 wxGBSpan *arg4 = 0 ;
41376 int arg5 ;
41377 int arg6 ;
41378 PyObject *arg7 = (PyObject *) NULL ;
41379 wxGBSizerItem *result;
41380 wxGBPosition temp3 ;
41381 wxGBSpan temp4 ;
41382 PyObject * obj0 = 0 ;
41383 PyObject * obj1 = 0 ;
41384 PyObject * obj2 = 0 ;
41385 PyObject * obj3 = 0 ;
41386 PyObject * obj4 = 0 ;
41387 PyObject * obj5 = 0 ;
41388 PyObject * obj6 = 0 ;
41389 char *kwnames[] = {
41390 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41391 };
41392
41393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41394 {
41395 arg1 = (int)(SWIG_As_int(obj0));
41396 if (SWIG_arg_fail(1)) SWIG_fail;
41397 }
41398 {
41399 arg2 = (int)(SWIG_As_int(obj1));
41400 if (SWIG_arg_fail(2)) SWIG_fail;
41401 }
41402 {
41403 arg3 = &temp3;
41404 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41405 }
41406 {
41407 arg4 = &temp4;
41408 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
41409 }
41410 {
41411 arg5 = (int)(SWIG_As_int(obj4));
41412 if (SWIG_arg_fail(5)) SWIG_fail;
41413 }
41414 {
41415 arg6 = (int)(SWIG_As_int(obj5));
41416 if (SWIG_arg_fail(6)) SWIG_fail;
41417 }
41418 if (obj6) {
41419 arg7 = obj6;
41420 }
41421 {
41422 PyThreadState* __tstate = wxPyBeginAllowThreads();
41423 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
41424
41425 wxPyEndAllowThreads(__tstate);
41426 if (PyErr_Occurred()) SWIG_fail;
41427 }
41428 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
41429 return resultobj;
41430 fail:
41431 return NULL;
41432 }
41433
41434
41435 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
41436 PyObject *resultobj;
41437 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41438 wxGBPosition result;
41439 PyObject * obj0 = 0 ;
41440 char *kwnames[] = {
41441 (char *) "self", NULL
41442 };
41443
41444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
41445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41446 if (SWIG_arg_fail(1)) SWIG_fail;
41447 {
41448 PyThreadState* __tstate = wxPyBeginAllowThreads();
41449 result = ((wxGBSizerItem const *)arg1)->GetPos();
41450
41451 wxPyEndAllowThreads(__tstate);
41452 if (PyErr_Occurred()) SWIG_fail;
41453 }
41454 {
41455 wxGBPosition * resultptr;
41456 resultptr = new wxGBPosition((wxGBPosition &)(result));
41457 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41458 }
41459 return resultobj;
41460 fail:
41461 return NULL;
41462 }
41463
41464
41465 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41466 PyObject *resultobj;
41467 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41468 wxGBSpan result;
41469 PyObject * obj0 = 0 ;
41470 char *kwnames[] = {
41471 (char *) "self", NULL
41472 };
41473
41474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
41475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41476 if (SWIG_arg_fail(1)) SWIG_fail;
41477 {
41478 PyThreadState* __tstate = wxPyBeginAllowThreads();
41479 result = ((wxGBSizerItem const *)arg1)->GetSpan();
41480
41481 wxPyEndAllowThreads(__tstate);
41482 if (PyErr_Occurred()) SWIG_fail;
41483 }
41484 {
41485 wxGBSpan * resultptr;
41486 resultptr = new wxGBSpan((wxGBSpan &)(result));
41487 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
41488 }
41489 return resultobj;
41490 fail:
41491 return NULL;
41492 }
41493
41494
41495 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
41496 PyObject *resultobj;
41497 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41498 wxGBPosition *arg2 = 0 ;
41499 bool result;
41500 wxGBPosition temp2 ;
41501 PyObject * obj0 = 0 ;
41502 PyObject * obj1 = 0 ;
41503 char *kwnames[] = {
41504 (char *) "self",(char *) "pos", NULL
41505 };
41506
41507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
41508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41509 if (SWIG_arg_fail(1)) SWIG_fail;
41510 {
41511 arg2 = &temp2;
41512 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41513 }
41514 {
41515 PyThreadState* __tstate = wxPyBeginAllowThreads();
41516 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
41517
41518 wxPyEndAllowThreads(__tstate);
41519 if (PyErr_Occurred()) SWIG_fail;
41520 }
41521 {
41522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41523 }
41524 return resultobj;
41525 fail:
41526 return NULL;
41527 }
41528
41529
41530 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
41531 PyObject *resultobj;
41532 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41533 wxGBSpan *arg2 = 0 ;
41534 bool result;
41535 wxGBSpan temp2 ;
41536 PyObject * obj0 = 0 ;
41537 PyObject * obj1 = 0 ;
41538 char *kwnames[] = {
41539 (char *) "self",(char *) "span", NULL
41540 };
41541
41542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
41543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41544 if (SWIG_arg_fail(1)) SWIG_fail;
41545 {
41546 arg2 = &temp2;
41547 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
41548 }
41549 {
41550 PyThreadState* __tstate = wxPyBeginAllowThreads();
41551 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
41552
41553 wxPyEndAllowThreads(__tstate);
41554 if (PyErr_Occurred()) SWIG_fail;
41555 }
41556 {
41557 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41558 }
41559 return resultobj;
41560 fail:
41561 return NULL;
41562 }
41563
41564
41565 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
41566 PyObject *resultobj;
41567 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41568 wxGBSizerItem *arg2 = 0 ;
41569 bool result;
41570 PyObject * obj0 = 0 ;
41571 PyObject * obj1 = 0 ;
41572 char *kwnames[] = {
41573 (char *) "self",(char *) "other", NULL
41574 };
41575
41576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
41577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41578 if (SWIG_arg_fail(1)) SWIG_fail;
41579 {
41580 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41581 if (SWIG_arg_fail(2)) SWIG_fail;
41582 if (arg2 == NULL) {
41583 SWIG_null_ref("wxGBSizerItem");
41584 }
41585 if (SWIG_arg_fail(2)) SWIG_fail;
41586 }
41587 {
41588 PyThreadState* __tstate = wxPyBeginAllowThreads();
41589 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
41590
41591 wxPyEndAllowThreads(__tstate);
41592 if (PyErr_Occurred()) SWIG_fail;
41593 }
41594 {
41595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41596 }
41597 return resultobj;
41598 fail:
41599 return NULL;
41600 }
41601
41602
41603 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
41604 PyObject *resultobj;
41605 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41606 wxGBPosition *arg2 = 0 ;
41607 wxGBSpan *arg3 = 0 ;
41608 bool result;
41609 wxGBPosition temp2 ;
41610 wxGBSpan temp3 ;
41611 PyObject * obj0 = 0 ;
41612 PyObject * obj1 = 0 ;
41613 PyObject * obj2 = 0 ;
41614 char *kwnames[] = {
41615 (char *) "self",(char *) "pos",(char *) "span", NULL
41616 };
41617
41618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
41619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41620 if (SWIG_arg_fail(1)) SWIG_fail;
41621 {
41622 arg2 = &temp2;
41623 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41624 }
41625 {
41626 arg3 = &temp3;
41627 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
41628 }
41629 {
41630 PyThreadState* __tstate = wxPyBeginAllowThreads();
41631 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
41632
41633 wxPyEndAllowThreads(__tstate);
41634 if (PyErr_Occurred()) SWIG_fail;
41635 }
41636 {
41637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41638 }
41639 return resultobj;
41640 fail:
41641 return NULL;
41642 }
41643
41644
41645 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
41646 PyObject *resultobj;
41647 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41648 wxGBPosition result;
41649 PyObject * obj0 = 0 ;
41650 char *kwnames[] = {
41651 (char *) "self", NULL
41652 };
41653
41654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
41655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41656 if (SWIG_arg_fail(1)) SWIG_fail;
41657 {
41658 PyThreadState* __tstate = wxPyBeginAllowThreads();
41659 result = wxGBSizerItem_GetEndPos(arg1);
41660
41661 wxPyEndAllowThreads(__tstate);
41662 if (PyErr_Occurred()) SWIG_fail;
41663 }
41664 {
41665 wxGBPosition * resultptr;
41666 resultptr = new wxGBPosition((wxGBPosition &)(result));
41667 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
41668 }
41669 return resultobj;
41670 fail:
41671 return NULL;
41672 }
41673
41674
41675 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41676 PyObject *resultobj;
41677 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41678 wxGridBagSizer *result;
41679 PyObject * obj0 = 0 ;
41680 char *kwnames[] = {
41681 (char *) "self", NULL
41682 };
41683
41684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
41685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41686 if (SWIG_arg_fail(1)) SWIG_fail;
41687 {
41688 PyThreadState* __tstate = wxPyBeginAllowThreads();
41689 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
41690
41691 wxPyEndAllowThreads(__tstate);
41692 if (PyErr_Occurred()) SWIG_fail;
41693 }
41694 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
41695 return resultobj;
41696 fail:
41697 return NULL;
41698 }
41699
41700
41701 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41702 PyObject *resultobj;
41703 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
41704 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
41705 PyObject * obj0 = 0 ;
41706 PyObject * obj1 = 0 ;
41707 char *kwnames[] = {
41708 (char *) "self",(char *) "sizer", NULL
41709 };
41710
41711 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
41712 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41713 if (SWIG_arg_fail(1)) SWIG_fail;
41714 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41715 if (SWIG_arg_fail(2)) SWIG_fail;
41716 {
41717 PyThreadState* __tstate = wxPyBeginAllowThreads();
41718 (arg1)->SetGBSizer(arg2);
41719
41720 wxPyEndAllowThreads(__tstate);
41721 if (PyErr_Occurred()) SWIG_fail;
41722 }
41723 Py_INCREF(Py_None); resultobj = Py_None;
41724 return resultobj;
41725 fail:
41726 return NULL;
41727 }
41728
41729
41730 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
41731 PyObject *obj;
41732 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41733 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
41734 Py_INCREF(obj);
41735 return Py_BuildValue((char *)"");
41736 }
41737 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41738 PyObject *resultobj;
41739 int arg1 = (int) 0 ;
41740 int arg2 = (int) 0 ;
41741 wxGridBagSizer *result;
41742 PyObject * obj0 = 0 ;
41743 PyObject * obj1 = 0 ;
41744 char *kwnames[] = {
41745 (char *) "vgap",(char *) "hgap", NULL
41746 };
41747
41748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
41749 if (obj0) {
41750 {
41751 arg1 = (int)(SWIG_As_int(obj0));
41752 if (SWIG_arg_fail(1)) SWIG_fail;
41753 }
41754 }
41755 if (obj1) {
41756 {
41757 arg2 = (int)(SWIG_As_int(obj1));
41758 if (SWIG_arg_fail(2)) SWIG_fail;
41759 }
41760 }
41761 {
41762 PyThreadState* __tstate = wxPyBeginAllowThreads();
41763 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
41764
41765 wxPyEndAllowThreads(__tstate);
41766 if (PyErr_Occurred()) SWIG_fail;
41767 }
41768 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
41769 return resultobj;
41770 fail:
41771 return NULL;
41772 }
41773
41774
41775 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
41776 PyObject *resultobj;
41777 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41778 PyObject *arg2 = (PyObject *) 0 ;
41779 wxGBPosition *arg3 = 0 ;
41780 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
41781 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
41782 int arg5 = (int) 0 ;
41783 int arg6 = (int) 0 ;
41784 PyObject *arg7 = (PyObject *) NULL ;
41785 wxGBSizerItem *result;
41786 wxGBPosition temp3 ;
41787 wxGBSpan temp4 ;
41788 PyObject * obj0 = 0 ;
41789 PyObject * obj1 = 0 ;
41790 PyObject * obj2 = 0 ;
41791 PyObject * obj3 = 0 ;
41792 PyObject * obj4 = 0 ;
41793 PyObject * obj5 = 0 ;
41794 PyObject * obj6 = 0 ;
41795 char *kwnames[] = {
41796 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
41797 };
41798
41799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
41800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41801 if (SWIG_arg_fail(1)) SWIG_fail;
41802 arg2 = obj1;
41803 {
41804 arg3 = &temp3;
41805 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
41806 }
41807 if (obj3) {
41808 {
41809 arg4 = &temp4;
41810 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
41811 }
41812 }
41813 if (obj4) {
41814 {
41815 arg5 = (int)(SWIG_As_int(obj4));
41816 if (SWIG_arg_fail(5)) SWIG_fail;
41817 }
41818 }
41819 if (obj5) {
41820 {
41821 arg6 = (int)(SWIG_As_int(obj5));
41822 if (SWIG_arg_fail(6)) SWIG_fail;
41823 }
41824 }
41825 if (obj6) {
41826 arg7 = obj6;
41827 }
41828 {
41829 PyThreadState* __tstate = wxPyBeginAllowThreads();
41830 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
41831
41832 wxPyEndAllowThreads(__tstate);
41833 if (PyErr_Occurred()) SWIG_fail;
41834 }
41835 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
41836 return resultobj;
41837 fail:
41838 return NULL;
41839 }
41840
41841
41842 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
41843 PyObject *resultobj;
41844 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41845 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
41846 wxGBSizerItem *result;
41847 PyObject * obj0 = 0 ;
41848 PyObject * obj1 = 0 ;
41849 char *kwnames[] = {
41850 (char *) "self",(char *) "item", NULL
41851 };
41852
41853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
41854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41855 if (SWIG_arg_fail(1)) SWIG_fail;
41856 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
41857 if (SWIG_arg_fail(2)) SWIG_fail;
41858 {
41859 PyThreadState* __tstate = wxPyBeginAllowThreads();
41860 result = (wxGBSizerItem *)(arg1)->Add(arg2);
41861
41862 wxPyEndAllowThreads(__tstate);
41863 if (PyErr_Occurred()) SWIG_fail;
41864 }
41865 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
41866 return resultobj;
41867 fail:
41868 return NULL;
41869 }
41870
41871
41872 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41873 PyObject *resultobj;
41874 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41875 int arg2 ;
41876 int arg3 ;
41877 wxSize result;
41878 PyObject * obj0 = 0 ;
41879 PyObject * obj1 = 0 ;
41880 PyObject * obj2 = 0 ;
41881 char *kwnames[] = {
41882 (char *) "self",(char *) "row",(char *) "col", NULL
41883 };
41884
41885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
41886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41887 if (SWIG_arg_fail(1)) SWIG_fail;
41888 {
41889 arg2 = (int)(SWIG_As_int(obj1));
41890 if (SWIG_arg_fail(2)) SWIG_fail;
41891 }
41892 {
41893 arg3 = (int)(SWIG_As_int(obj2));
41894 if (SWIG_arg_fail(3)) SWIG_fail;
41895 }
41896 {
41897 PyThreadState* __tstate = wxPyBeginAllowThreads();
41898 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
41899
41900 wxPyEndAllowThreads(__tstate);
41901 if (PyErr_Occurred()) SWIG_fail;
41902 }
41903 {
41904 wxSize * resultptr;
41905 resultptr = new wxSize((wxSize &)(result));
41906 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41907 }
41908 return resultobj;
41909 fail:
41910 return NULL;
41911 }
41912
41913
41914 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41915 PyObject *resultobj;
41916 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41917 wxSize result;
41918 PyObject * obj0 = 0 ;
41919 char *kwnames[] = {
41920 (char *) "self", NULL
41921 };
41922
41923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
41924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41925 if (SWIG_arg_fail(1)) SWIG_fail;
41926 {
41927 PyThreadState* __tstate = wxPyBeginAllowThreads();
41928 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
41929
41930 wxPyEndAllowThreads(__tstate);
41931 if (PyErr_Occurred()) SWIG_fail;
41932 }
41933 {
41934 wxSize * resultptr;
41935 resultptr = new wxSize((wxSize &)(result));
41936 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
41937 }
41938 return resultobj;
41939 fail:
41940 return NULL;
41941 }
41942
41943
41944 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
41945 PyObject *resultobj;
41946 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41947 wxSize *arg2 = 0 ;
41948 wxSize temp2 ;
41949 PyObject * obj0 = 0 ;
41950 PyObject * obj1 = 0 ;
41951 char *kwnames[] = {
41952 (char *) "self",(char *) "sz", NULL
41953 };
41954
41955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
41956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41957 if (SWIG_arg_fail(1)) SWIG_fail;
41958 {
41959 arg2 = &temp2;
41960 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
41961 }
41962 {
41963 PyThreadState* __tstate = wxPyBeginAllowThreads();
41964 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
41965
41966 wxPyEndAllowThreads(__tstate);
41967 if (PyErr_Occurred()) SWIG_fail;
41968 }
41969 Py_INCREF(Py_None); resultobj = Py_None;
41970 return resultobj;
41971 fail:
41972 return NULL;
41973 }
41974
41975
41976 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
41977 PyObject *resultobj;
41978 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
41979 wxWindow *arg2 = (wxWindow *) 0 ;
41980 wxGBPosition result;
41981 PyObject * obj0 = 0 ;
41982 PyObject * obj1 = 0 ;
41983
41984 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
41985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
41986 if (SWIG_arg_fail(1)) SWIG_fail;
41987 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
41988 if (SWIG_arg_fail(2)) SWIG_fail;
41989 {
41990 PyThreadState* __tstate = wxPyBeginAllowThreads();
41991 result = (arg1)->GetItemPosition(arg2);
41992
41993 wxPyEndAllowThreads(__tstate);
41994 if (PyErr_Occurred()) SWIG_fail;
41995 }
41996 {
41997 wxGBPosition * resultptr;
41998 resultptr = new wxGBPosition((wxGBPosition &)(result));
41999 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42000 }
42001 return resultobj;
42002 fail:
42003 return NULL;
42004 }
42005
42006
42007 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42008 PyObject *resultobj;
42009 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42010 wxSizer *arg2 = (wxSizer *) 0 ;
42011 wxGBPosition result;
42012 PyObject * obj0 = 0 ;
42013 PyObject * obj1 = 0 ;
42014
42015 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42016 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42017 if (SWIG_arg_fail(1)) SWIG_fail;
42018 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42019 if (SWIG_arg_fail(2)) SWIG_fail;
42020 {
42021 PyThreadState* __tstate = wxPyBeginAllowThreads();
42022 result = (arg1)->GetItemPosition(arg2);
42023
42024 wxPyEndAllowThreads(__tstate);
42025 if (PyErr_Occurred()) SWIG_fail;
42026 }
42027 {
42028 wxGBPosition * resultptr;
42029 resultptr = new wxGBPosition((wxGBPosition &)(result));
42030 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42031 }
42032 return resultobj;
42033 fail:
42034 return NULL;
42035 }
42036
42037
42038 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42039 PyObject *resultobj;
42040 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42041 size_t arg2 ;
42042 wxGBPosition result;
42043 PyObject * obj0 = 0 ;
42044 PyObject * obj1 = 0 ;
42045
42046 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
42047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42048 if (SWIG_arg_fail(1)) SWIG_fail;
42049 {
42050 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42051 if (SWIG_arg_fail(2)) SWIG_fail;
42052 }
42053 {
42054 PyThreadState* __tstate = wxPyBeginAllowThreads();
42055 result = (arg1)->GetItemPosition(arg2);
42056
42057 wxPyEndAllowThreads(__tstate);
42058 if (PyErr_Occurred()) SWIG_fail;
42059 }
42060 {
42061 wxGBPosition * resultptr;
42062 resultptr = new wxGBPosition((wxGBPosition &)(result));
42063 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42064 }
42065 return resultobj;
42066 fail:
42067 return NULL;
42068 }
42069
42070
42071 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
42072 int argc;
42073 PyObject *argv[3];
42074 int ii;
42075
42076 argc = PyObject_Length(args);
42077 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42078 argv[ii] = PyTuple_GetItem(args,ii);
42079 }
42080 if (argc == 2) {
42081 int _v;
42082 {
42083 void *ptr;
42084 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42085 _v = 0;
42086 PyErr_Clear();
42087 } else {
42088 _v = 1;
42089 }
42090 }
42091 if (_v) {
42092 {
42093 void *ptr;
42094 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42095 _v = 0;
42096 PyErr_Clear();
42097 } else {
42098 _v = 1;
42099 }
42100 }
42101 if (_v) {
42102 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
42103 }
42104 }
42105 }
42106 if (argc == 2) {
42107 int _v;
42108 {
42109 void *ptr;
42110 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42111 _v = 0;
42112 PyErr_Clear();
42113 } else {
42114 _v = 1;
42115 }
42116 }
42117 if (_v) {
42118 {
42119 void *ptr;
42120 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42121 _v = 0;
42122 PyErr_Clear();
42123 } else {
42124 _v = 1;
42125 }
42126 }
42127 if (_v) {
42128 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
42129 }
42130 }
42131 }
42132 if (argc == 2) {
42133 int _v;
42134 {
42135 void *ptr;
42136 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42137 _v = 0;
42138 PyErr_Clear();
42139 } else {
42140 _v = 1;
42141 }
42142 }
42143 if (_v) {
42144 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42145 if (_v) {
42146 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
42147 }
42148 }
42149 }
42150
42151 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
42152 return NULL;
42153 }
42154
42155
42156 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
42157 PyObject *resultobj;
42158 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42159 wxWindow *arg2 = (wxWindow *) 0 ;
42160 wxGBPosition *arg3 = 0 ;
42161 bool result;
42162 wxGBPosition temp3 ;
42163 PyObject * obj0 = 0 ;
42164 PyObject * obj1 = 0 ;
42165 PyObject * obj2 = 0 ;
42166
42167 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42169 if (SWIG_arg_fail(1)) SWIG_fail;
42170 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42171 if (SWIG_arg_fail(2)) SWIG_fail;
42172 {
42173 arg3 = &temp3;
42174 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42175 }
42176 {
42177 PyThreadState* __tstate = wxPyBeginAllowThreads();
42178 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42179
42180 wxPyEndAllowThreads(__tstate);
42181 if (PyErr_Occurred()) SWIG_fail;
42182 }
42183 {
42184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42185 }
42186 return resultobj;
42187 fail:
42188 return NULL;
42189 }
42190
42191
42192 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
42193 PyObject *resultobj;
42194 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42195 wxSizer *arg2 = (wxSizer *) 0 ;
42196 wxGBPosition *arg3 = 0 ;
42197 bool result;
42198 wxGBPosition temp3 ;
42199 PyObject * obj0 = 0 ;
42200 PyObject * obj1 = 0 ;
42201 PyObject * obj2 = 0 ;
42202
42203 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42205 if (SWIG_arg_fail(1)) SWIG_fail;
42206 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42207 if (SWIG_arg_fail(2)) SWIG_fail;
42208 {
42209 arg3 = &temp3;
42210 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42211 }
42212 {
42213 PyThreadState* __tstate = wxPyBeginAllowThreads();
42214 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42215
42216 wxPyEndAllowThreads(__tstate);
42217 if (PyErr_Occurred()) SWIG_fail;
42218 }
42219 {
42220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42221 }
42222 return resultobj;
42223 fail:
42224 return NULL;
42225 }
42226
42227
42228 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
42229 PyObject *resultobj;
42230 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42231 size_t arg2 ;
42232 wxGBPosition *arg3 = 0 ;
42233 bool result;
42234 wxGBPosition temp3 ;
42235 PyObject * obj0 = 0 ;
42236 PyObject * obj1 = 0 ;
42237 PyObject * obj2 = 0 ;
42238
42239 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
42240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42241 if (SWIG_arg_fail(1)) SWIG_fail;
42242 {
42243 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42244 if (SWIG_arg_fail(2)) SWIG_fail;
42245 }
42246 {
42247 arg3 = &temp3;
42248 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42249 }
42250 {
42251 PyThreadState* __tstate = wxPyBeginAllowThreads();
42252 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
42253
42254 wxPyEndAllowThreads(__tstate);
42255 if (PyErr_Occurred()) SWIG_fail;
42256 }
42257 {
42258 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42259 }
42260 return resultobj;
42261 fail:
42262 return NULL;
42263 }
42264
42265
42266 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
42267 int argc;
42268 PyObject *argv[4];
42269 int ii;
42270
42271 argc = PyObject_Length(args);
42272 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42273 argv[ii] = PyTuple_GetItem(args,ii);
42274 }
42275 if (argc == 3) {
42276 int _v;
42277 {
42278 void *ptr;
42279 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42280 _v = 0;
42281 PyErr_Clear();
42282 } else {
42283 _v = 1;
42284 }
42285 }
42286 if (_v) {
42287 {
42288 void *ptr;
42289 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42290 _v = 0;
42291 PyErr_Clear();
42292 } else {
42293 _v = 1;
42294 }
42295 }
42296 if (_v) {
42297 {
42298 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42299 }
42300 if (_v) {
42301 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
42302 }
42303 }
42304 }
42305 }
42306 if (argc == 3) {
42307 int _v;
42308 {
42309 void *ptr;
42310 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42311 _v = 0;
42312 PyErr_Clear();
42313 } else {
42314 _v = 1;
42315 }
42316 }
42317 if (_v) {
42318 {
42319 void *ptr;
42320 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42321 _v = 0;
42322 PyErr_Clear();
42323 } else {
42324 _v = 1;
42325 }
42326 }
42327 if (_v) {
42328 {
42329 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42330 }
42331 if (_v) {
42332 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
42333 }
42334 }
42335 }
42336 }
42337 if (argc == 3) {
42338 int _v;
42339 {
42340 void *ptr;
42341 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42342 _v = 0;
42343 PyErr_Clear();
42344 } else {
42345 _v = 1;
42346 }
42347 }
42348 if (_v) {
42349 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42350 if (_v) {
42351 {
42352 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
42353 }
42354 if (_v) {
42355 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
42356 }
42357 }
42358 }
42359 }
42360
42361 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
42362 return NULL;
42363 }
42364
42365
42366 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42367 PyObject *resultobj;
42368 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42369 wxWindow *arg2 = (wxWindow *) 0 ;
42370 wxGBSpan result;
42371 PyObject * obj0 = 0 ;
42372 PyObject * obj1 = 0 ;
42373
42374 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42375 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42376 if (SWIG_arg_fail(1)) SWIG_fail;
42377 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42378 if (SWIG_arg_fail(2)) SWIG_fail;
42379 {
42380 PyThreadState* __tstate = wxPyBeginAllowThreads();
42381 result = (arg1)->GetItemSpan(arg2);
42382
42383 wxPyEndAllowThreads(__tstate);
42384 if (PyErr_Occurred()) SWIG_fail;
42385 }
42386 {
42387 wxGBSpan * resultptr;
42388 resultptr = new wxGBSpan((wxGBSpan &)(result));
42389 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42390 }
42391 return resultobj;
42392 fail:
42393 return NULL;
42394 }
42395
42396
42397 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42398 PyObject *resultobj;
42399 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42400 wxSizer *arg2 = (wxSizer *) 0 ;
42401 wxGBSpan result;
42402 PyObject * obj0 = 0 ;
42403 PyObject * obj1 = 0 ;
42404
42405 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42407 if (SWIG_arg_fail(1)) SWIG_fail;
42408 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42409 if (SWIG_arg_fail(2)) SWIG_fail;
42410 {
42411 PyThreadState* __tstate = wxPyBeginAllowThreads();
42412 result = (arg1)->GetItemSpan(arg2);
42413
42414 wxPyEndAllowThreads(__tstate);
42415 if (PyErr_Occurred()) SWIG_fail;
42416 }
42417 {
42418 wxGBSpan * resultptr;
42419 resultptr = new wxGBSpan((wxGBSpan &)(result));
42420 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42421 }
42422 return resultobj;
42423 fail:
42424 return NULL;
42425 }
42426
42427
42428 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42429 PyObject *resultobj;
42430 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42431 size_t arg2 ;
42432 wxGBSpan result;
42433 PyObject * obj0 = 0 ;
42434 PyObject * obj1 = 0 ;
42435
42436 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
42437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42438 if (SWIG_arg_fail(1)) SWIG_fail;
42439 {
42440 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42441 if (SWIG_arg_fail(2)) SWIG_fail;
42442 }
42443 {
42444 PyThreadState* __tstate = wxPyBeginAllowThreads();
42445 result = (arg1)->GetItemSpan(arg2);
42446
42447 wxPyEndAllowThreads(__tstate);
42448 if (PyErr_Occurred()) SWIG_fail;
42449 }
42450 {
42451 wxGBSpan * resultptr;
42452 resultptr = new wxGBSpan((wxGBSpan &)(result));
42453 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42454 }
42455 return resultobj;
42456 fail:
42457 return NULL;
42458 }
42459
42460
42461 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
42462 int argc;
42463 PyObject *argv[3];
42464 int ii;
42465
42466 argc = PyObject_Length(args);
42467 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42468 argv[ii] = PyTuple_GetItem(args,ii);
42469 }
42470 if (argc == 2) {
42471 int _v;
42472 {
42473 void *ptr;
42474 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42475 _v = 0;
42476 PyErr_Clear();
42477 } else {
42478 _v = 1;
42479 }
42480 }
42481 if (_v) {
42482 {
42483 void *ptr;
42484 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42485 _v = 0;
42486 PyErr_Clear();
42487 } else {
42488 _v = 1;
42489 }
42490 }
42491 if (_v) {
42492 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
42493 }
42494 }
42495 }
42496 if (argc == 2) {
42497 int _v;
42498 {
42499 void *ptr;
42500 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42501 _v = 0;
42502 PyErr_Clear();
42503 } else {
42504 _v = 1;
42505 }
42506 }
42507 if (_v) {
42508 {
42509 void *ptr;
42510 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42511 _v = 0;
42512 PyErr_Clear();
42513 } else {
42514 _v = 1;
42515 }
42516 }
42517 if (_v) {
42518 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
42519 }
42520 }
42521 }
42522 if (argc == 2) {
42523 int _v;
42524 {
42525 void *ptr;
42526 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42527 _v = 0;
42528 PyErr_Clear();
42529 } else {
42530 _v = 1;
42531 }
42532 }
42533 if (_v) {
42534 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42535 if (_v) {
42536 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
42537 }
42538 }
42539 }
42540
42541 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
42542 return NULL;
42543 }
42544
42545
42546 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
42547 PyObject *resultobj;
42548 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42549 wxWindow *arg2 = (wxWindow *) 0 ;
42550 wxGBSpan *arg3 = 0 ;
42551 bool result;
42552 wxGBSpan temp3 ;
42553 PyObject * obj0 = 0 ;
42554 PyObject * obj1 = 0 ;
42555 PyObject * obj2 = 0 ;
42556
42557 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42559 if (SWIG_arg_fail(1)) SWIG_fail;
42560 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42561 if (SWIG_arg_fail(2)) SWIG_fail;
42562 {
42563 arg3 = &temp3;
42564 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42565 }
42566 {
42567 PyThreadState* __tstate = wxPyBeginAllowThreads();
42568 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42569
42570 wxPyEndAllowThreads(__tstate);
42571 if (PyErr_Occurred()) SWIG_fail;
42572 }
42573 {
42574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42575 }
42576 return resultobj;
42577 fail:
42578 return NULL;
42579 }
42580
42581
42582 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
42583 PyObject *resultobj;
42584 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42585 wxSizer *arg2 = (wxSizer *) 0 ;
42586 wxGBSpan *arg3 = 0 ;
42587 bool result;
42588 wxGBSpan temp3 ;
42589 PyObject * obj0 = 0 ;
42590 PyObject * obj1 = 0 ;
42591 PyObject * obj2 = 0 ;
42592
42593 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42595 if (SWIG_arg_fail(1)) SWIG_fail;
42596 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42597 if (SWIG_arg_fail(2)) SWIG_fail;
42598 {
42599 arg3 = &temp3;
42600 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42601 }
42602 {
42603 PyThreadState* __tstate = wxPyBeginAllowThreads();
42604 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42605
42606 wxPyEndAllowThreads(__tstate);
42607 if (PyErr_Occurred()) SWIG_fail;
42608 }
42609 {
42610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42611 }
42612 return resultobj;
42613 fail:
42614 return NULL;
42615 }
42616
42617
42618 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
42619 PyObject *resultobj;
42620 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42621 size_t arg2 ;
42622 wxGBSpan *arg3 = 0 ;
42623 bool result;
42624 wxGBSpan temp3 ;
42625 PyObject * obj0 = 0 ;
42626 PyObject * obj1 = 0 ;
42627 PyObject * obj2 = 0 ;
42628
42629 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
42630 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42631 if (SWIG_arg_fail(1)) SWIG_fail;
42632 {
42633 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
42634 if (SWIG_arg_fail(2)) SWIG_fail;
42635 }
42636 {
42637 arg3 = &temp3;
42638 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42639 }
42640 {
42641 PyThreadState* __tstate = wxPyBeginAllowThreads();
42642 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
42643
42644 wxPyEndAllowThreads(__tstate);
42645 if (PyErr_Occurred()) SWIG_fail;
42646 }
42647 {
42648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42649 }
42650 return resultobj;
42651 fail:
42652 return NULL;
42653 }
42654
42655
42656 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
42657 int argc;
42658 PyObject *argv[4];
42659 int ii;
42660
42661 argc = PyObject_Length(args);
42662 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
42663 argv[ii] = PyTuple_GetItem(args,ii);
42664 }
42665 if (argc == 3) {
42666 int _v;
42667 {
42668 void *ptr;
42669 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42670 _v = 0;
42671 PyErr_Clear();
42672 } else {
42673 _v = 1;
42674 }
42675 }
42676 if (_v) {
42677 {
42678 void *ptr;
42679 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42680 _v = 0;
42681 PyErr_Clear();
42682 } else {
42683 _v = 1;
42684 }
42685 }
42686 if (_v) {
42687 {
42688 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42689 }
42690 if (_v) {
42691 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
42692 }
42693 }
42694 }
42695 }
42696 if (argc == 3) {
42697 int _v;
42698 {
42699 void *ptr;
42700 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42701 _v = 0;
42702 PyErr_Clear();
42703 } else {
42704 _v = 1;
42705 }
42706 }
42707 if (_v) {
42708 {
42709 void *ptr;
42710 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42711 _v = 0;
42712 PyErr_Clear();
42713 } else {
42714 _v = 1;
42715 }
42716 }
42717 if (_v) {
42718 {
42719 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42720 }
42721 if (_v) {
42722 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
42723 }
42724 }
42725 }
42726 }
42727 if (argc == 3) {
42728 int _v;
42729 {
42730 void *ptr;
42731 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42732 _v = 0;
42733 PyErr_Clear();
42734 } else {
42735 _v = 1;
42736 }
42737 }
42738 if (_v) {
42739 _v = SWIG_Check_unsigned_SS_long(argv[1]);
42740 if (_v) {
42741 {
42742 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
42743 }
42744 if (_v) {
42745 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
42746 }
42747 }
42748 }
42749 }
42750
42751 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
42752 return NULL;
42753 }
42754
42755
42756 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
42757 PyObject *resultobj;
42758 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42759 wxWindow *arg2 = (wxWindow *) 0 ;
42760 wxGBSizerItem *result;
42761 PyObject * obj0 = 0 ;
42762 PyObject * obj1 = 0 ;
42763
42764 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
42765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42766 if (SWIG_arg_fail(1)) SWIG_fail;
42767 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42768 if (SWIG_arg_fail(2)) SWIG_fail;
42769 {
42770 PyThreadState* __tstate = wxPyBeginAllowThreads();
42771 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
42772
42773 wxPyEndAllowThreads(__tstate);
42774 if (PyErr_Occurred()) SWIG_fail;
42775 }
42776 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42777 return resultobj;
42778 fail:
42779 return NULL;
42780 }
42781
42782
42783 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
42784 PyObject *resultobj;
42785 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42786 wxSizer *arg2 = (wxSizer *) 0 ;
42787 wxGBSizerItem *result;
42788 PyObject * obj0 = 0 ;
42789 PyObject * obj1 = 0 ;
42790
42791 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
42792 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42793 if (SWIG_arg_fail(1)) SWIG_fail;
42794 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42795 if (SWIG_arg_fail(2)) SWIG_fail;
42796 {
42797 PyThreadState* __tstate = wxPyBeginAllowThreads();
42798 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
42799
42800 wxPyEndAllowThreads(__tstate);
42801 if (PyErr_Occurred()) SWIG_fail;
42802 }
42803 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42804 return resultobj;
42805 fail:
42806 return NULL;
42807 }
42808
42809
42810 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
42811 int argc;
42812 PyObject *argv[3];
42813 int ii;
42814
42815 argc = PyObject_Length(args);
42816 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
42817 argv[ii] = PyTuple_GetItem(args,ii);
42818 }
42819 if (argc == 2) {
42820 int _v;
42821 {
42822 void *ptr;
42823 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42824 _v = 0;
42825 PyErr_Clear();
42826 } else {
42827 _v = 1;
42828 }
42829 }
42830 if (_v) {
42831 {
42832 void *ptr;
42833 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
42834 _v = 0;
42835 PyErr_Clear();
42836 } else {
42837 _v = 1;
42838 }
42839 }
42840 if (_v) {
42841 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
42842 }
42843 }
42844 }
42845 if (argc == 2) {
42846 int _v;
42847 {
42848 void *ptr;
42849 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
42850 _v = 0;
42851 PyErr_Clear();
42852 } else {
42853 _v = 1;
42854 }
42855 }
42856 if (_v) {
42857 {
42858 void *ptr;
42859 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
42860 _v = 0;
42861 PyErr_Clear();
42862 } else {
42863 _v = 1;
42864 }
42865 }
42866 if (_v) {
42867 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
42868 }
42869 }
42870 }
42871
42872 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
42873 return NULL;
42874 }
42875
42876
42877 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42878 PyObject *resultobj;
42879 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42880 wxGBPosition *arg2 = 0 ;
42881 wxGBSizerItem *result;
42882 wxGBPosition temp2 ;
42883 PyObject * obj0 = 0 ;
42884 PyObject * obj1 = 0 ;
42885 char *kwnames[] = {
42886 (char *) "self",(char *) "pos", NULL
42887 };
42888
42889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
42890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42891 if (SWIG_arg_fail(1)) SWIG_fail;
42892 {
42893 arg2 = &temp2;
42894 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42895 }
42896 {
42897 PyThreadState* __tstate = wxPyBeginAllowThreads();
42898 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
42899
42900 wxPyEndAllowThreads(__tstate);
42901 if (PyErr_Occurred()) SWIG_fail;
42902 }
42903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42904 return resultobj;
42905 fail:
42906 return NULL;
42907 }
42908
42909
42910 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
42911 PyObject *resultobj;
42912 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42913 wxPoint *arg2 = 0 ;
42914 wxGBSizerItem *result;
42915 wxPoint temp2 ;
42916 PyObject * obj0 = 0 ;
42917 PyObject * obj1 = 0 ;
42918 char *kwnames[] = {
42919 (char *) "self",(char *) "pt", NULL
42920 };
42921
42922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
42923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42924 if (SWIG_arg_fail(1)) SWIG_fail;
42925 {
42926 arg2 = &temp2;
42927 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
42928 }
42929 {
42930 PyThreadState* __tstate = wxPyBeginAllowThreads();
42931 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
42932
42933 wxPyEndAllowThreads(__tstate);
42934 if (PyErr_Occurred()) SWIG_fail;
42935 }
42936 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42937 return resultobj;
42938 fail:
42939 return NULL;
42940 }
42941
42942
42943 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
42944 PyObject *resultobj;
42945 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42946 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42947 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
42948 bool result;
42949 PyObject * obj0 = 0 ;
42950 PyObject * obj1 = 0 ;
42951 PyObject * obj2 = 0 ;
42952 char *kwnames[] = {
42953 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
42954 };
42955
42956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
42957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42958 if (SWIG_arg_fail(1)) SWIG_fail;
42959 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42960 if (SWIG_arg_fail(2)) SWIG_fail;
42961 if (obj2) {
42962 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42963 if (SWIG_arg_fail(3)) SWIG_fail;
42964 }
42965 {
42966 PyThreadState* __tstate = wxPyBeginAllowThreads();
42967 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
42968
42969 wxPyEndAllowThreads(__tstate);
42970 if (PyErr_Occurred()) SWIG_fail;
42971 }
42972 {
42973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42974 }
42975 return resultobj;
42976 fail:
42977 return NULL;
42978 }
42979
42980
42981 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
42982 PyObject *resultobj;
42983 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42984 wxGBPosition *arg2 = 0 ;
42985 wxGBSpan *arg3 = 0 ;
42986 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
42987 bool result;
42988 wxGBPosition temp2 ;
42989 wxGBSpan temp3 ;
42990 PyObject * obj0 = 0 ;
42991 PyObject * obj1 = 0 ;
42992 PyObject * obj2 = 0 ;
42993 PyObject * obj3 = 0 ;
42994 char *kwnames[] = {
42995 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
42996 };
42997
42998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
42999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43000 if (SWIG_arg_fail(1)) SWIG_fail;
43001 {
43002 arg2 = &temp2;
43003 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43004 }
43005 {
43006 arg3 = &temp3;
43007 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43008 }
43009 if (obj3) {
43010 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43011 if (SWIG_arg_fail(4)) SWIG_fail;
43012 }
43013 {
43014 PyThreadState* __tstate = wxPyBeginAllowThreads();
43015 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
43016
43017 wxPyEndAllowThreads(__tstate);
43018 if (PyErr_Occurred()) SWIG_fail;
43019 }
43020 {
43021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43022 }
43023 return resultobj;
43024 fail:
43025 return NULL;
43026 }
43027
43028
43029 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
43030 PyObject *obj;
43031 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43032 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
43033 Py_INCREF(obj);
43034 return Py_BuildValue((char *)"");
43035 }
43036 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
43037 PyObject *resultobj;
43038 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43039 wxRelationship arg2 ;
43040 wxWindow *arg3 = (wxWindow *) 0 ;
43041 wxEdge arg4 ;
43042 int arg5 = (int) 0 ;
43043 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
43044 PyObject * obj0 = 0 ;
43045 PyObject * obj1 = 0 ;
43046 PyObject * obj2 = 0 ;
43047 PyObject * obj3 = 0 ;
43048 PyObject * obj4 = 0 ;
43049 PyObject * obj5 = 0 ;
43050 char *kwnames[] = {
43051 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
43052 };
43053
43054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43056 if (SWIG_arg_fail(1)) SWIG_fail;
43057 {
43058 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43059 if (SWIG_arg_fail(2)) SWIG_fail;
43060 }
43061 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43062 if (SWIG_arg_fail(3)) SWIG_fail;
43063 {
43064 arg4 = (wxEdge)(SWIG_As_int(obj3));
43065 if (SWIG_arg_fail(4)) SWIG_fail;
43066 }
43067 if (obj4) {
43068 {
43069 arg5 = (int)(SWIG_As_int(obj4));
43070 if (SWIG_arg_fail(5)) SWIG_fail;
43071 }
43072 }
43073 if (obj5) {
43074 {
43075 arg6 = (int)(SWIG_As_int(obj5));
43076 if (SWIG_arg_fail(6)) SWIG_fail;
43077 }
43078 }
43079 {
43080 PyThreadState* __tstate = wxPyBeginAllowThreads();
43081 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
43082
43083 wxPyEndAllowThreads(__tstate);
43084 if (PyErr_Occurred()) SWIG_fail;
43085 }
43086 Py_INCREF(Py_None); resultobj = Py_None;
43087 return resultobj;
43088 fail:
43089 return NULL;
43090 }
43091
43092
43093 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
43094 PyObject *resultobj;
43095 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43096 wxWindow *arg2 = (wxWindow *) 0 ;
43097 int arg3 = (int) 0 ;
43098 PyObject * obj0 = 0 ;
43099 PyObject * obj1 = 0 ;
43100 PyObject * obj2 = 0 ;
43101 char *kwnames[] = {
43102 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43103 };
43104
43105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43107 if (SWIG_arg_fail(1)) SWIG_fail;
43108 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43109 if (SWIG_arg_fail(2)) SWIG_fail;
43110 if (obj2) {
43111 {
43112 arg3 = (int)(SWIG_As_int(obj2));
43113 if (SWIG_arg_fail(3)) SWIG_fail;
43114 }
43115 }
43116 {
43117 PyThreadState* __tstate = wxPyBeginAllowThreads();
43118 (arg1)->LeftOf(arg2,arg3);
43119
43120 wxPyEndAllowThreads(__tstate);
43121 if (PyErr_Occurred()) SWIG_fail;
43122 }
43123 Py_INCREF(Py_None); resultobj = Py_None;
43124 return resultobj;
43125 fail:
43126 return NULL;
43127 }
43128
43129
43130 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
43131 PyObject *resultobj;
43132 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43133 wxWindow *arg2 = (wxWindow *) 0 ;
43134 int arg3 = (int) 0 ;
43135 PyObject * obj0 = 0 ;
43136 PyObject * obj1 = 0 ;
43137 PyObject * obj2 = 0 ;
43138 char *kwnames[] = {
43139 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43140 };
43141
43142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
43143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43144 if (SWIG_arg_fail(1)) SWIG_fail;
43145 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43146 if (SWIG_arg_fail(2)) SWIG_fail;
43147 if (obj2) {
43148 {
43149 arg3 = (int)(SWIG_As_int(obj2));
43150 if (SWIG_arg_fail(3)) SWIG_fail;
43151 }
43152 }
43153 {
43154 PyThreadState* __tstate = wxPyBeginAllowThreads();
43155 (arg1)->RightOf(arg2,arg3);
43156
43157 wxPyEndAllowThreads(__tstate);
43158 if (PyErr_Occurred()) SWIG_fail;
43159 }
43160 Py_INCREF(Py_None); resultobj = Py_None;
43161 return resultobj;
43162 fail:
43163 return NULL;
43164 }
43165
43166
43167 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
43168 PyObject *resultobj;
43169 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43170 wxWindow *arg2 = (wxWindow *) 0 ;
43171 int arg3 = (int) 0 ;
43172 PyObject * obj0 = 0 ;
43173 PyObject * obj1 = 0 ;
43174 PyObject * obj2 = 0 ;
43175 char *kwnames[] = {
43176 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43177 };
43178
43179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
43180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43181 if (SWIG_arg_fail(1)) SWIG_fail;
43182 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43183 if (SWIG_arg_fail(2)) SWIG_fail;
43184 if (obj2) {
43185 {
43186 arg3 = (int)(SWIG_As_int(obj2));
43187 if (SWIG_arg_fail(3)) SWIG_fail;
43188 }
43189 }
43190 {
43191 PyThreadState* __tstate = wxPyBeginAllowThreads();
43192 (arg1)->Above(arg2,arg3);
43193
43194 wxPyEndAllowThreads(__tstate);
43195 if (PyErr_Occurred()) SWIG_fail;
43196 }
43197 Py_INCREF(Py_None); resultobj = Py_None;
43198 return resultobj;
43199 fail:
43200 return NULL;
43201 }
43202
43203
43204 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
43205 PyObject *resultobj;
43206 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43207 wxWindow *arg2 = (wxWindow *) 0 ;
43208 int arg3 = (int) 0 ;
43209 PyObject * obj0 = 0 ;
43210 PyObject * obj1 = 0 ;
43211 PyObject * obj2 = 0 ;
43212 char *kwnames[] = {
43213 (char *) "self",(char *) "sibling",(char *) "marg", NULL
43214 };
43215
43216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
43217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43218 if (SWIG_arg_fail(1)) SWIG_fail;
43219 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43220 if (SWIG_arg_fail(2)) SWIG_fail;
43221 if (obj2) {
43222 {
43223 arg3 = (int)(SWIG_As_int(obj2));
43224 if (SWIG_arg_fail(3)) SWIG_fail;
43225 }
43226 }
43227 {
43228 PyThreadState* __tstate = wxPyBeginAllowThreads();
43229 (arg1)->Below(arg2,arg3);
43230
43231 wxPyEndAllowThreads(__tstate);
43232 if (PyErr_Occurred()) SWIG_fail;
43233 }
43234 Py_INCREF(Py_None); resultobj = Py_None;
43235 return resultobj;
43236 fail:
43237 return NULL;
43238 }
43239
43240
43241 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
43242 PyObject *resultobj;
43243 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43244 wxWindow *arg2 = (wxWindow *) 0 ;
43245 wxEdge arg3 ;
43246 int arg4 = (int) 0 ;
43247 PyObject * obj0 = 0 ;
43248 PyObject * obj1 = 0 ;
43249 PyObject * obj2 = 0 ;
43250 PyObject * obj3 = 0 ;
43251 char *kwnames[] = {
43252 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
43253 };
43254
43255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43257 if (SWIG_arg_fail(1)) SWIG_fail;
43258 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43259 if (SWIG_arg_fail(2)) SWIG_fail;
43260 {
43261 arg3 = (wxEdge)(SWIG_As_int(obj2));
43262 if (SWIG_arg_fail(3)) SWIG_fail;
43263 }
43264 if (obj3) {
43265 {
43266 arg4 = (int)(SWIG_As_int(obj3));
43267 if (SWIG_arg_fail(4)) SWIG_fail;
43268 }
43269 }
43270 {
43271 PyThreadState* __tstate = wxPyBeginAllowThreads();
43272 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
43273
43274 wxPyEndAllowThreads(__tstate);
43275 if (PyErr_Occurred()) SWIG_fail;
43276 }
43277 Py_INCREF(Py_None); resultobj = Py_None;
43278 return resultobj;
43279 fail:
43280 return NULL;
43281 }
43282
43283
43284 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
43285 PyObject *resultobj;
43286 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43287 wxWindow *arg2 = (wxWindow *) 0 ;
43288 wxEdge arg3 ;
43289 int arg4 ;
43290 PyObject * obj0 = 0 ;
43291 PyObject * obj1 = 0 ;
43292 PyObject * obj2 = 0 ;
43293 PyObject * obj3 = 0 ;
43294 char *kwnames[] = {
43295 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
43296 };
43297
43298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43300 if (SWIG_arg_fail(1)) SWIG_fail;
43301 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43302 if (SWIG_arg_fail(2)) SWIG_fail;
43303 {
43304 arg3 = (wxEdge)(SWIG_As_int(obj2));
43305 if (SWIG_arg_fail(3)) SWIG_fail;
43306 }
43307 {
43308 arg4 = (int)(SWIG_As_int(obj3));
43309 if (SWIG_arg_fail(4)) SWIG_fail;
43310 }
43311 {
43312 PyThreadState* __tstate = wxPyBeginAllowThreads();
43313 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
43314
43315 wxPyEndAllowThreads(__tstate);
43316 if (PyErr_Occurred()) SWIG_fail;
43317 }
43318 Py_INCREF(Py_None); resultobj = Py_None;
43319 return resultobj;
43320 fail:
43321 return NULL;
43322 }
43323
43324
43325 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
43326 PyObject *resultobj;
43327 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43328 int arg2 ;
43329 PyObject * obj0 = 0 ;
43330 PyObject * obj1 = 0 ;
43331 char *kwnames[] = {
43332 (char *) "self",(char *) "val", NULL
43333 };
43334
43335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
43336 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43337 if (SWIG_arg_fail(1)) SWIG_fail;
43338 {
43339 arg2 = (int)(SWIG_As_int(obj1));
43340 if (SWIG_arg_fail(2)) SWIG_fail;
43341 }
43342 {
43343 PyThreadState* __tstate = wxPyBeginAllowThreads();
43344 (arg1)->Absolute(arg2);
43345
43346 wxPyEndAllowThreads(__tstate);
43347 if (PyErr_Occurred()) SWIG_fail;
43348 }
43349 Py_INCREF(Py_None); resultobj = Py_None;
43350 return resultobj;
43351 fail:
43352 return NULL;
43353 }
43354
43355
43356 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
43357 PyObject *resultobj;
43358 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43359 PyObject * obj0 = 0 ;
43360 char *kwnames[] = {
43361 (char *) "self", NULL
43362 };
43363
43364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
43365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43366 if (SWIG_arg_fail(1)) SWIG_fail;
43367 {
43368 PyThreadState* __tstate = wxPyBeginAllowThreads();
43369 (arg1)->Unconstrained();
43370
43371 wxPyEndAllowThreads(__tstate);
43372 if (PyErr_Occurred()) SWIG_fail;
43373 }
43374 Py_INCREF(Py_None); resultobj = Py_None;
43375 return resultobj;
43376 fail:
43377 return NULL;
43378 }
43379
43380
43381 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
43382 PyObject *resultobj;
43383 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43384 PyObject * obj0 = 0 ;
43385 char *kwnames[] = {
43386 (char *) "self", NULL
43387 };
43388
43389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
43390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43391 if (SWIG_arg_fail(1)) SWIG_fail;
43392 {
43393 PyThreadState* __tstate = wxPyBeginAllowThreads();
43394 (arg1)->AsIs();
43395
43396 wxPyEndAllowThreads(__tstate);
43397 if (PyErr_Occurred()) SWIG_fail;
43398 }
43399 Py_INCREF(Py_None); resultobj = Py_None;
43400 return resultobj;
43401 fail:
43402 return NULL;
43403 }
43404
43405
43406 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
43407 PyObject *resultobj;
43408 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43409 wxWindow *result;
43410 PyObject * obj0 = 0 ;
43411 char *kwnames[] = {
43412 (char *) "self", NULL
43413 };
43414
43415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
43416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43417 if (SWIG_arg_fail(1)) SWIG_fail;
43418 {
43419 PyThreadState* __tstate = wxPyBeginAllowThreads();
43420 result = (wxWindow *)(arg1)->GetOtherWindow();
43421
43422 wxPyEndAllowThreads(__tstate);
43423 if (PyErr_Occurred()) SWIG_fail;
43424 }
43425 {
43426 resultobj = wxPyMake_wxObject(result, 0);
43427 }
43428 return resultobj;
43429 fail:
43430 return NULL;
43431 }
43432
43433
43434 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43435 PyObject *resultobj;
43436 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43437 wxEdge result;
43438 PyObject * obj0 = 0 ;
43439 char *kwnames[] = {
43440 (char *) "self", NULL
43441 };
43442
43443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
43444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43445 if (SWIG_arg_fail(1)) SWIG_fail;
43446 {
43447 PyThreadState* __tstate = wxPyBeginAllowThreads();
43448 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
43449
43450 wxPyEndAllowThreads(__tstate);
43451 if (PyErr_Occurred()) SWIG_fail;
43452 }
43453 resultobj = SWIG_From_int((result));
43454 return resultobj;
43455 fail:
43456 return NULL;
43457 }
43458
43459
43460 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43461 PyObject *resultobj;
43462 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43463 wxEdge arg2 ;
43464 PyObject * obj0 = 0 ;
43465 PyObject * obj1 = 0 ;
43466 char *kwnames[] = {
43467 (char *) "self",(char *) "which", NULL
43468 };
43469
43470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
43471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43472 if (SWIG_arg_fail(1)) SWIG_fail;
43473 {
43474 arg2 = (wxEdge)(SWIG_As_int(obj1));
43475 if (SWIG_arg_fail(2)) SWIG_fail;
43476 }
43477 {
43478 PyThreadState* __tstate = wxPyBeginAllowThreads();
43479 (arg1)->SetEdge((wxEdge )arg2);
43480
43481 wxPyEndAllowThreads(__tstate);
43482 if (PyErr_Occurred()) SWIG_fail;
43483 }
43484 Py_INCREF(Py_None); resultobj = Py_None;
43485 return resultobj;
43486 fail:
43487 return NULL;
43488 }
43489
43490
43491 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
43492 PyObject *resultobj;
43493 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43494 int arg2 ;
43495 PyObject * obj0 = 0 ;
43496 PyObject * obj1 = 0 ;
43497 char *kwnames[] = {
43498 (char *) "self",(char *) "v", NULL
43499 };
43500
43501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
43502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43503 if (SWIG_arg_fail(1)) SWIG_fail;
43504 {
43505 arg2 = (int)(SWIG_As_int(obj1));
43506 if (SWIG_arg_fail(2)) SWIG_fail;
43507 }
43508 {
43509 PyThreadState* __tstate = wxPyBeginAllowThreads();
43510 (arg1)->SetValue(arg2);
43511
43512 wxPyEndAllowThreads(__tstate);
43513 if (PyErr_Occurred()) SWIG_fail;
43514 }
43515 Py_INCREF(Py_None); resultobj = Py_None;
43516 return resultobj;
43517 fail:
43518 return NULL;
43519 }
43520
43521
43522 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
43523 PyObject *resultobj;
43524 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43525 int result;
43526 PyObject * obj0 = 0 ;
43527 char *kwnames[] = {
43528 (char *) "self", NULL
43529 };
43530
43531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
43532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43533 if (SWIG_arg_fail(1)) SWIG_fail;
43534 {
43535 PyThreadState* __tstate = wxPyBeginAllowThreads();
43536 result = (int)(arg1)->GetMargin();
43537
43538 wxPyEndAllowThreads(__tstate);
43539 if (PyErr_Occurred()) SWIG_fail;
43540 }
43541 {
43542 resultobj = SWIG_From_int((int)(result));
43543 }
43544 return resultobj;
43545 fail:
43546 return NULL;
43547 }
43548
43549
43550 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
43551 PyObject *resultobj;
43552 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43553 int arg2 ;
43554 PyObject * obj0 = 0 ;
43555 PyObject * obj1 = 0 ;
43556 char *kwnames[] = {
43557 (char *) "self",(char *) "m", NULL
43558 };
43559
43560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
43561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43562 if (SWIG_arg_fail(1)) SWIG_fail;
43563 {
43564 arg2 = (int)(SWIG_As_int(obj1));
43565 if (SWIG_arg_fail(2)) SWIG_fail;
43566 }
43567 {
43568 PyThreadState* __tstate = wxPyBeginAllowThreads();
43569 (arg1)->SetMargin(arg2);
43570
43571 wxPyEndAllowThreads(__tstate);
43572 if (PyErr_Occurred()) SWIG_fail;
43573 }
43574 Py_INCREF(Py_None); resultobj = Py_None;
43575 return resultobj;
43576 fail:
43577 return NULL;
43578 }
43579
43580
43581 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
43582 PyObject *resultobj;
43583 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43584 int result;
43585 PyObject * obj0 = 0 ;
43586 char *kwnames[] = {
43587 (char *) "self", NULL
43588 };
43589
43590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
43591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43592 if (SWIG_arg_fail(1)) SWIG_fail;
43593 {
43594 PyThreadState* __tstate = wxPyBeginAllowThreads();
43595 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
43596
43597 wxPyEndAllowThreads(__tstate);
43598 if (PyErr_Occurred()) SWIG_fail;
43599 }
43600 {
43601 resultobj = SWIG_From_int((int)(result));
43602 }
43603 return resultobj;
43604 fail:
43605 return NULL;
43606 }
43607
43608
43609 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
43610 PyObject *resultobj;
43611 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43612 int result;
43613 PyObject * obj0 = 0 ;
43614 char *kwnames[] = {
43615 (char *) "self", NULL
43616 };
43617
43618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
43619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43620 if (SWIG_arg_fail(1)) SWIG_fail;
43621 {
43622 PyThreadState* __tstate = wxPyBeginAllowThreads();
43623 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
43624
43625 wxPyEndAllowThreads(__tstate);
43626 if (PyErr_Occurred()) SWIG_fail;
43627 }
43628 {
43629 resultobj = SWIG_From_int((int)(result));
43630 }
43631 return resultobj;
43632 fail:
43633 return NULL;
43634 }
43635
43636
43637 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43638 PyObject *resultobj;
43639 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43640 int result;
43641 PyObject * obj0 = 0 ;
43642 char *kwnames[] = {
43643 (char *) "self", NULL
43644 };
43645
43646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
43647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43648 if (SWIG_arg_fail(1)) SWIG_fail;
43649 {
43650 PyThreadState* __tstate = wxPyBeginAllowThreads();
43651 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
43652
43653 wxPyEndAllowThreads(__tstate);
43654 if (PyErr_Occurred()) SWIG_fail;
43655 }
43656 {
43657 resultobj = SWIG_From_int((int)(result));
43658 }
43659 return resultobj;
43660 fail:
43661 return NULL;
43662 }
43663
43664
43665 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
43666 PyObject *resultobj;
43667 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43668 bool result;
43669 PyObject * obj0 = 0 ;
43670 char *kwnames[] = {
43671 (char *) "self", NULL
43672 };
43673
43674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
43675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43676 if (SWIG_arg_fail(1)) SWIG_fail;
43677 {
43678 PyThreadState* __tstate = wxPyBeginAllowThreads();
43679 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
43680
43681 wxPyEndAllowThreads(__tstate);
43682 if (PyErr_Occurred()) SWIG_fail;
43683 }
43684 {
43685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43686 }
43687 return resultobj;
43688 fail:
43689 return NULL;
43690 }
43691
43692
43693 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
43694 PyObject *resultobj;
43695 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43696 bool arg2 ;
43697 PyObject * obj0 = 0 ;
43698 PyObject * obj1 = 0 ;
43699 char *kwnames[] = {
43700 (char *) "self",(char *) "d", NULL
43701 };
43702
43703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
43704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43705 if (SWIG_arg_fail(1)) SWIG_fail;
43706 {
43707 arg2 = (bool)(SWIG_As_bool(obj1));
43708 if (SWIG_arg_fail(2)) SWIG_fail;
43709 }
43710 {
43711 PyThreadState* __tstate = wxPyBeginAllowThreads();
43712 (arg1)->SetDone(arg2);
43713
43714 wxPyEndAllowThreads(__tstate);
43715 if (PyErr_Occurred()) SWIG_fail;
43716 }
43717 Py_INCREF(Py_None); resultobj = Py_None;
43718 return resultobj;
43719 fail:
43720 return NULL;
43721 }
43722
43723
43724 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
43725 PyObject *resultobj;
43726 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43727 wxRelationship result;
43728 PyObject * obj0 = 0 ;
43729 char *kwnames[] = {
43730 (char *) "self", NULL
43731 };
43732
43733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
43734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43735 if (SWIG_arg_fail(1)) SWIG_fail;
43736 {
43737 PyThreadState* __tstate = wxPyBeginAllowThreads();
43738 result = (wxRelationship)(arg1)->GetRelationship();
43739
43740 wxPyEndAllowThreads(__tstate);
43741 if (PyErr_Occurred()) SWIG_fail;
43742 }
43743 resultobj = SWIG_From_int((result));
43744 return resultobj;
43745 fail:
43746 return NULL;
43747 }
43748
43749
43750 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
43751 PyObject *resultobj;
43752 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43753 wxRelationship arg2 ;
43754 PyObject * obj0 = 0 ;
43755 PyObject * obj1 = 0 ;
43756 char *kwnames[] = {
43757 (char *) "self",(char *) "r", NULL
43758 };
43759
43760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
43761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43762 if (SWIG_arg_fail(1)) SWIG_fail;
43763 {
43764 arg2 = (wxRelationship)(SWIG_As_int(obj1));
43765 if (SWIG_arg_fail(2)) SWIG_fail;
43766 }
43767 {
43768 PyThreadState* __tstate = wxPyBeginAllowThreads();
43769 (arg1)->SetRelationship((wxRelationship )arg2);
43770
43771 wxPyEndAllowThreads(__tstate);
43772 if (PyErr_Occurred()) SWIG_fail;
43773 }
43774 Py_INCREF(Py_None); resultobj = Py_None;
43775 return resultobj;
43776 fail:
43777 return NULL;
43778 }
43779
43780
43781 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
43782 PyObject *resultobj;
43783 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43784 wxWindow *arg2 = (wxWindow *) 0 ;
43785 bool result;
43786 PyObject * obj0 = 0 ;
43787 PyObject * obj1 = 0 ;
43788 char *kwnames[] = {
43789 (char *) "self",(char *) "otherW", NULL
43790 };
43791
43792 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
43793 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43794 if (SWIG_arg_fail(1)) SWIG_fail;
43795 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43796 if (SWIG_arg_fail(2)) SWIG_fail;
43797 {
43798 PyThreadState* __tstate = wxPyBeginAllowThreads();
43799 result = (bool)(arg1)->ResetIfWin(arg2);
43800
43801 wxPyEndAllowThreads(__tstate);
43802 if (PyErr_Occurred()) SWIG_fail;
43803 }
43804 {
43805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43806 }
43807 return resultobj;
43808 fail:
43809 return NULL;
43810 }
43811
43812
43813 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
43814 PyObject *resultobj;
43815 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43816 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
43817 wxWindow *arg3 = (wxWindow *) 0 ;
43818 bool result;
43819 PyObject * obj0 = 0 ;
43820 PyObject * obj1 = 0 ;
43821 PyObject * obj2 = 0 ;
43822 char *kwnames[] = {
43823 (char *) "self",(char *) "constraints",(char *) "win", NULL
43824 };
43825
43826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
43827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43828 if (SWIG_arg_fail(1)) SWIG_fail;
43829 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43830 if (SWIG_arg_fail(2)) SWIG_fail;
43831 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43832 if (SWIG_arg_fail(3)) SWIG_fail;
43833 {
43834 PyThreadState* __tstate = wxPyBeginAllowThreads();
43835 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
43836
43837 wxPyEndAllowThreads(__tstate);
43838 if (PyErr_Occurred()) SWIG_fail;
43839 }
43840 {
43841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43842 }
43843 return resultobj;
43844 fail:
43845 return NULL;
43846 }
43847
43848
43849 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
43850 PyObject *resultobj;
43851 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
43852 wxEdge arg2 ;
43853 wxWindow *arg3 = (wxWindow *) 0 ;
43854 wxWindow *arg4 = (wxWindow *) 0 ;
43855 int result;
43856 PyObject * obj0 = 0 ;
43857 PyObject * obj1 = 0 ;
43858 PyObject * obj2 = 0 ;
43859 PyObject * obj3 = 0 ;
43860 char *kwnames[] = {
43861 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
43862 };
43863
43864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
43865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
43866 if (SWIG_arg_fail(1)) SWIG_fail;
43867 {
43868 arg2 = (wxEdge)(SWIG_As_int(obj1));
43869 if (SWIG_arg_fail(2)) SWIG_fail;
43870 }
43871 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43872 if (SWIG_arg_fail(3)) SWIG_fail;
43873 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43874 if (SWIG_arg_fail(4)) SWIG_fail;
43875 {
43876 PyThreadState* __tstate = wxPyBeginAllowThreads();
43877 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
43878
43879 wxPyEndAllowThreads(__tstate);
43880 if (PyErr_Occurred()) SWIG_fail;
43881 }
43882 {
43883 resultobj = SWIG_From_int((int)(result));
43884 }
43885 return resultobj;
43886 fail:
43887 return NULL;
43888 }
43889
43890
43891 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
43892 PyObject *obj;
43893 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43894 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
43895 Py_INCREF(obj);
43896 return Py_BuildValue((char *)"");
43897 }
43898 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
43899 PyObject *resultobj;
43900 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43901 wxIndividualLayoutConstraint *result;
43902 PyObject * obj0 = 0 ;
43903 char *kwnames[] = {
43904 (char *) "self", NULL
43905 };
43906
43907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
43908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43909 if (SWIG_arg_fail(1)) SWIG_fail;
43910 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
43911
43912 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43913 return resultobj;
43914 fail:
43915 return NULL;
43916 }
43917
43918
43919 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
43920 PyObject *resultobj;
43921 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43922 wxIndividualLayoutConstraint *result;
43923 PyObject * obj0 = 0 ;
43924 char *kwnames[] = {
43925 (char *) "self", NULL
43926 };
43927
43928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
43929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43930 if (SWIG_arg_fail(1)) SWIG_fail;
43931 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
43932
43933 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43934 return resultobj;
43935 fail:
43936 return NULL;
43937 }
43938
43939
43940 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
43941 PyObject *resultobj;
43942 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43943 wxIndividualLayoutConstraint *result;
43944 PyObject * obj0 = 0 ;
43945 char *kwnames[] = {
43946 (char *) "self", NULL
43947 };
43948
43949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
43950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43951 if (SWIG_arg_fail(1)) SWIG_fail;
43952 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
43953
43954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43955 return resultobj;
43956 fail:
43957 return NULL;
43958 }
43959
43960
43961 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
43962 PyObject *resultobj;
43963 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43964 wxIndividualLayoutConstraint *result;
43965 PyObject * obj0 = 0 ;
43966 char *kwnames[] = {
43967 (char *) "self", NULL
43968 };
43969
43970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
43971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43972 if (SWIG_arg_fail(1)) SWIG_fail;
43973 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
43974
43975 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43976 return resultobj;
43977 fail:
43978 return NULL;
43979 }
43980
43981
43982 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
43983 PyObject *resultobj;
43984 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
43985 wxIndividualLayoutConstraint *result;
43986 PyObject * obj0 = 0 ;
43987 char *kwnames[] = {
43988 (char *) "self", NULL
43989 };
43990
43991 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
43992 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
43993 if (SWIG_arg_fail(1)) SWIG_fail;
43994 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
43995
43996 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
43997 return resultobj;
43998 fail:
43999 return NULL;
44000 }
44001
44002
44003 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
44004 PyObject *resultobj;
44005 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44006 wxIndividualLayoutConstraint *result;
44007 PyObject * obj0 = 0 ;
44008 char *kwnames[] = {
44009 (char *) "self", NULL
44010 };
44011
44012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
44013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44014 if (SWIG_arg_fail(1)) SWIG_fail;
44015 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
44016
44017 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44018 return resultobj;
44019 fail:
44020 return NULL;
44021 }
44022
44023
44024 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
44025 PyObject *resultobj;
44026 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44027 wxIndividualLayoutConstraint *result;
44028 PyObject * obj0 = 0 ;
44029 char *kwnames[] = {
44030 (char *) "self", NULL
44031 };
44032
44033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
44034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44035 if (SWIG_arg_fail(1)) SWIG_fail;
44036 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
44037
44038 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44039 return resultobj;
44040 fail:
44041 return NULL;
44042 }
44043
44044
44045 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
44046 PyObject *resultobj;
44047 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44048 wxIndividualLayoutConstraint *result;
44049 PyObject * obj0 = 0 ;
44050 char *kwnames[] = {
44051 (char *) "self", NULL
44052 };
44053
44054 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
44055 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44056 if (SWIG_arg_fail(1)) SWIG_fail;
44057 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
44058
44059 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
44060 return resultobj;
44061 fail:
44062 return NULL;
44063 }
44064
44065
44066 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44067 PyObject *resultobj;
44068 wxLayoutConstraints *result;
44069 char *kwnames[] = {
44070 NULL
44071 };
44072
44073 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
44074 {
44075 PyThreadState* __tstate = wxPyBeginAllowThreads();
44076 result = (wxLayoutConstraints *)new wxLayoutConstraints();
44077
44078 wxPyEndAllowThreads(__tstate);
44079 if (PyErr_Occurred()) SWIG_fail;
44080 }
44081 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
44082 return resultobj;
44083 fail:
44084 return NULL;
44085 }
44086
44087
44088 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
44089 PyObject *resultobj;
44090 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44091 wxWindow *arg2 = (wxWindow *) 0 ;
44092 int *arg3 = (int *) 0 ;
44093 bool result;
44094 int temp3 ;
44095 int res3 = 0 ;
44096 PyObject * obj0 = 0 ;
44097 PyObject * obj1 = 0 ;
44098 char *kwnames[] = {
44099 (char *) "self",(char *) "win", NULL
44100 };
44101
44102 arg3 = &temp3; res3 = SWIG_NEWOBJ;
44103 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
44104 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44105 if (SWIG_arg_fail(1)) SWIG_fail;
44106 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44107 if (SWIG_arg_fail(2)) SWIG_fail;
44108 {
44109 PyThreadState* __tstate = wxPyBeginAllowThreads();
44110 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
44111
44112 wxPyEndAllowThreads(__tstate);
44113 if (PyErr_Occurred()) SWIG_fail;
44114 }
44115 {
44116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44117 }
44118 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
44119 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
44120 return resultobj;
44121 fail:
44122 return NULL;
44123 }
44124
44125
44126 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
44127 PyObject *resultobj;
44128 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44129 bool result;
44130 PyObject * obj0 = 0 ;
44131 char *kwnames[] = {
44132 (char *) "self", NULL
44133 };
44134
44135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
44136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44137 if (SWIG_arg_fail(1)) SWIG_fail;
44138 {
44139 PyThreadState* __tstate = wxPyBeginAllowThreads();
44140 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
44141
44142 wxPyEndAllowThreads(__tstate);
44143 if (PyErr_Occurred()) SWIG_fail;
44144 }
44145 {
44146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44147 }
44148 return resultobj;
44149 fail:
44150 return NULL;
44151 }
44152
44153
44154 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
44155 PyObject *obj;
44156 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44157 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
44158 Py_INCREF(obj);
44159 return Py_BuildValue((char *)"");
44160 }
44161 static PyMethodDef SwigMethods[] = {
44162 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
44163 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
44164 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44165 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44166 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
44167 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44168 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44169 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44170 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44171 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44172 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
44173 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44174 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44175 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44176 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44177 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
44178 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
44179 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44180 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44181 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44182 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44183 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44184 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
44185 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
44186 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44187 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
44188 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44189 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44190 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44191 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44192 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44193 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44194 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44195 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44196 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44197 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44198 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44199 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44200 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
44201 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44202 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44203 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44204 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44205 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44206 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
44207 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44208 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44209 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44210 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
44211 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44212 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44213 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44214 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44215 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
44216 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44217 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
44218 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
44219 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
44220 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
44221 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44222 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
44223 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44224 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
44225 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44226 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44227 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44228 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44229 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44230 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44231 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44232 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44233 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44234 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44235 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44236 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
44237 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44238 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44239 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44240 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44241 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
44242 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
44243 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
44244 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
44245 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
44246 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
44247 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
44248 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
44249 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
44250 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
44251 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
44252 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44253 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44254 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44255 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
44256 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
44257 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
44258 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44259 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44260 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44261 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44262 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
44263 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
44264 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
44265 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
44266 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44267 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44268 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
44269 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
44270 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
44271 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
44272 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
44273 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
44274 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
44275 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44276 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44277 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
44278 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
44279 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
44280 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
44281 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44282 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
44283 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
44284 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
44285 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
44286 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
44287 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
44288 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
44289 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
44290 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44291 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44292 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44293 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44294 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44295 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
44296 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
44297 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44298 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
44299 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
44300 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
44301 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
44302 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
44303 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
44304 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
44305 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
44306 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
44307 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
44308 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
44309 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
44310 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44311 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
44312 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
44313 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
44314 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
44315 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
44316 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
44317 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
44318 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44319 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
44320 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
44321 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44322 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44323 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44324 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
44325 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
44326 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
44327 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44328 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44329 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44330 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44331 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44332 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44333 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
44334 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44335 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
44336 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
44337 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
44338 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
44339 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44340 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
44341 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
44342 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
44343 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44344 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44345 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44346 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44347 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
44348 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
44349 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
44350 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
44351 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44352 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44353 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44354 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
44355 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44356 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44357 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44358 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44359 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44360 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
44361 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
44362 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44363 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
44364 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44365 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44366 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
44367 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
44368 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
44369 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
44370 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
44371 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44372 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44373 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
44374 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44375 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44376 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44377 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
44378 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
44379 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
44380 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
44381 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44382 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44383 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44384 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
44385 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44386 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
44387 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
44388 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
44389 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
44390 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
44391 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44392 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
44393 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44394 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44395 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44396 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
44397 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
44398 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
44399 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
44400 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
44401 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44402 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44403 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44404 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44405 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44406 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
44407 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
44408 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
44409 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
44410 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
44411 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
44412 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
44413 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44414 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
44415 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
44416 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44417 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
44418 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
44419 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
44420 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44421 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44422 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44423 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
44424 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
44425 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
44426 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
44427 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
44428 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44429 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44430 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
44431 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
44432 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44433 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
44434 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
44435 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
44436 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
44437 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
44438 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
44439 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
44440 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
44441 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
44442 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
44443 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
44444 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
44445 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
44446 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
44447 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
44448 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
44449 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
44450 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
44451 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
44452 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44453 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44454 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44455 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
44456 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44457 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
44458 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
44459 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44460 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
44461 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44462 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
44463 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44464 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
44465 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44466 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
44467 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44468 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
44469 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44470 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
44471 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44472 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
44473 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44474 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
44475 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44476 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
44477 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44478 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
44479 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44480 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
44481 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
44482 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
44483 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44484 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44485 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44486 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44487 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44488 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44489 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44490 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44491 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44492 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44493 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
44494 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
44495 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44496 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
44497 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44498 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
44499 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44500 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
44501 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
44502 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
44503 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
44504 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
44505 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44506 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44507 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44508 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
44509 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
44510 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
44511 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
44512 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
44513 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44514 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
44515 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
44516 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
44517 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
44518 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
44519 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
44520 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
44521 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44522 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44523 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
44524 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
44525 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44526 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
44527 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
44528 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
44529 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
44530 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
44531 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
44532 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
44533 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44534 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
44535 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
44536 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
44537 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
44538 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44539 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44540 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44541 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44542 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44543 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
44544 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44545 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44546 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44547 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
44548 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44549 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
44550 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44551 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
44552 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
44553 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44554 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
44555 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
44556 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44557 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
44558 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
44559 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
44560 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
44561 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44562 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
44563 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44564 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
44565 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
44566 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
44567 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
44568 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
44569 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44570 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44571 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
44572 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44573 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44574 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
44575 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
44576 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
44577 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
44578 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
44579 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44580 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44581 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44582 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44583 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44584 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
44585 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
44586 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
44587 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
44588 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44589 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44590 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44591 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44592 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44593 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44594 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44595 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44596 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44597 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44598 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44599 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44600 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44601 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44602 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44603 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44604 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44605 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44606 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
44607 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
44608 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
44609 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
44610 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
44611 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
44612 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
44613 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44614 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44615 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44616 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44617 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44618 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
44619 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
44620 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44621 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
44622 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
44623 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
44624 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
44625 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
44626 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
44627 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44628 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
44629 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44630 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44631 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44632 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44633 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
44634 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
44635 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
44636 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
44637 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
44638 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
44639 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44640 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44641 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44642 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44643 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44644 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44645 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44646 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44647 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
44648 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
44649 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44650 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44651 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
44652 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
44653 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
44654 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
44655 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
44656 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44657 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44658 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44659 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44660 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44661 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
44662 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
44663 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
44664 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
44665 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
44666 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44667 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44668 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44669 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44670 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44671 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
44672 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44673 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
44674 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44675 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
44676 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44677 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
44678 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
44679 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44680 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44681 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44682 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
44683 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44684 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44685 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
44686 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44687 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44688 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
44689 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44690 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
44691 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44692 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
44693 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
44694 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
44695 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
44696 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44697 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
44698 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
44699 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
44700 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44701 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44702 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
44703 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
44704 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44705 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
44706 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
44707 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
44708 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44709 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
44710 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
44711 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44712 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
44713 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44714 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
44715 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
44716 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
44717 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44718 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44719 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44720 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
44721 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
44722 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
44723 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44724 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
44725 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44726 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
44727 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
44728 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
44729 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
44730 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
44731 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44732 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44733 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
44734 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44735 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
44736 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44737 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44738 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
44739 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44740 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
44741 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44742 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44743 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44744 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
44745 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44746 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
44747 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
44748 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
44749 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44750 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44751 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
44752 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
44753 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
44754 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44755 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44756 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44757 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
44758 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44759 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44760 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
44761 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44762 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44763 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
44764 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44765 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44766 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44767 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
44768 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44769 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
44770 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
44771 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44772 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
44773 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
44774 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
44775 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44776 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44777 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44778 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44779 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
44780 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44781 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44782 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44783 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
44784 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
44785 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44786 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
44787 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
44788 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
44789 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
44790 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
44791 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
44792 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
44793 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
44794 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44795 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
44796 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
44797 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
44798 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
44799 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44800 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
44801 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44802 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
44803 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44804 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44805 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44806 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
44807 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
44808 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44809 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
44810 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
44811 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44812 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44813 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
44814 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
44815 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
44816 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
44817 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
44818 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
44819 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
44820 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
44821 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
44822 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44823 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44824 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44825 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
44826 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
44827 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44828 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44829 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
44830 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
44831 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
44832 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
44833 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
44834 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44835 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
44836 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
44837 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
44838 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
44839 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
44840 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
44841 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
44842 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
44843 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
44844 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44845 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
44846 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
44847 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
44848 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
44849 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
44850 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
44851 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44852 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
44853 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
44854 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
44855 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
44856 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
44857 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
44858 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
44859 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
44860 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
44861 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44862 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44863 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
44864 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
44865 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
44866 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44867 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
44868 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
44869 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
44870 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
44871 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
44872 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
44873 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
44874 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
44875 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
44876 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44877 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
44878 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
44879 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
44880 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
44881 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
44882 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44883 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
44884 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44885 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
44886 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
44887 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
44888 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
44889 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
44890 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
44891 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
44892 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44893 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44894 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
44895 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44896 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
44897 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44898 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44899 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
44900 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
44901 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
44902 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
44903 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
44904 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
44905 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44906 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44907 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
44908 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44909 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
44910 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44911 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
44912 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
44913 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44914 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
44915 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
44916 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44917 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44918 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44919 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
44920 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
44921 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
44922 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
44923 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
44924 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
44925 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
44926 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44927 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
44928 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
44929 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
44930 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
44931 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44932 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
44933 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
44934 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44935 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44936 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
44937 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
44938 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44939 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
44940 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44941 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
44942 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
44943 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
44944 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
44945 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
44946 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
44947 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
44948 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44949 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44950 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44951 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
44952 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
44953 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44954 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
44955 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
44956 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44957 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
44958 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44959 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
44960 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44961 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
44962 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
44963 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44964 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44965 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
44966 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
44967 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
44968 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
44969 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
44970 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
44971 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
44972 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
44973 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
44974 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
44975 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
44976 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
44977 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
44978 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44979 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44980 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44981 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44982 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
44983 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
44984 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
44985 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
44986 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44987 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
44988 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44989 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44990 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
44991 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
44992 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
44993 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
44994 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
44995 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
44996 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
44997 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44998 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
44999 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
45000 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45001 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
45002 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45003 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
45004 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
45005 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
45006 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
45007 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45008 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
45009 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
45010 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
45011 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
45012 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
45013 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
45014 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45015 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
45016 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45017 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45018 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45019 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45020 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45021 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45022 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45023 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
45024 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45025 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45026 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
45027 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45028 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45029 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45030 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
45031 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
45032 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45033 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
45034 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45035 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45036 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45037 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
45038 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
45039 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
45040 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
45041 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
45042 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
45043 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
45044 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
45045 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
45046 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
45047 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45048 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45049 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45050 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
45051 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45052 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
45053 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45054 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
45055 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
45056 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
45057 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45058 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
45059 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
45060 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
45061 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
45062 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
45063 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
45064 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45065 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
45066 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
45067 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
45068 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45069 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
45070 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45071 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
45072 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45073 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45074 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45075 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
45076 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45077 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45078 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
45079 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45080 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45081 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45082 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45083 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
45084 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
45085 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
45086 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
45087 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45088 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
45089 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
45090 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45091 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
45092 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45093 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45094 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45095 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45096 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
45097 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
45098 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
45099 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
45100 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45101 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
45102 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
45103 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45104 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45105 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45106 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45107 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45108 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
45109 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
45110 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45111 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45112 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45113 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45114 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45115 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45116 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45117 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45118 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45119 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
45120 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
45121 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45122 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45123 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
45124 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45125 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
45126 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45127 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
45128 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
45129 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
45130 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
45131 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
45132 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45133 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45134 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45135 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45136 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45137 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45138 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45139 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45140 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45141 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45142 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45143 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45144 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45145 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45146 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45147 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45148 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
45149 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
45150 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45151 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45152 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45153 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45154 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45155 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
45156 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
45157 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
45158 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45159 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45160 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
45161 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45162 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45163 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45164 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
45165 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
45166 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45167 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
45168 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45169 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
45170 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45171 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45172 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45173 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45174 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45175 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45176 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45177 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45178 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
45179 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
45180 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
45181 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
45182 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45183 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
45184 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
45185 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45186 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45187 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45188 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45189 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
45190 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45191 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45192 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45193 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
45194 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45195 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
45196 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45197 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
45198 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45199 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45200 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45201 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45202 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45203 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45204 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45205 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
45206 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45207 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
45208 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45209 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
45210 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45211 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45212 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45213 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
45214 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
45215 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
45216 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45217 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
45218 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45219 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45220 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45221 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
45222 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
45223 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
45224 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45225 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45226 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
45227 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45228 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
45229 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45230 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45231 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45232 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
45233 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45234 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
45235 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45236 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45237 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45238 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45239 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
45240 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
45241 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
45242 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45243 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45244 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45245 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45246 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45247 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45248 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45249 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45250 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45251 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45252 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45253 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
45254 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
45255 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
45256 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45257 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
45258 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45259 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45261 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
45264 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45267 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45269 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45274 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45277 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
45279 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45280 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45281 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
45282 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
45283 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
45284 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45287 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
45295 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
45309 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
45310 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
45312 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
45316 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
45319 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
45329 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
45341 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
45353 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
45363 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45364 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
45373 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
45387 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45392 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
45394 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
45395 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
45396 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
45397 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
45398 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
45403 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
45411 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
45413 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
45421 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45422 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
45430 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
45434 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
45442 { NULL, NULL, 0, NULL }
45443 };
45444
45445
45446 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
45447
45448 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
45449 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
45450 }
45451 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
45452 return (void *)((wxSizer *) ((wxBoxSizer *) x));
45453 }
45454 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
45455 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
45456 }
45457 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
45458 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45459 }
45460 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
45461 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
45462 }
45463 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
45464 return (void *)((wxSizer *) ((wxGridSizer *) x));
45465 }
45466 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
45467 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
45468 }
45469 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
45470 return (void *)((wxSizer *) ((wxPySizer *) x));
45471 }
45472 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
45473 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
45474 }
45475 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
45476 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45477 }
45478 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
45479 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
45480 }
45481 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
45482 return (void *)((wxEvent *) ((wxMenuEvent *) x));
45483 }
45484 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
45485 return (void *)((wxEvent *) ((wxCloseEvent *) x));
45486 }
45487 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
45488 return (void *)((wxEvent *) ((wxMouseEvent *) x));
45489 }
45490 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
45491 return (void *)((wxEvent *) ((wxEraseEvent *) x));
45492 }
45493 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
45494 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
45495 }
45496 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
45497 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
45498 }
45499 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
45500 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
45501 }
45502 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
45503 return (void *)((wxEvent *) ((wxPyEvent *) x));
45504 }
45505 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
45506 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
45507 }
45508 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
45509 return (void *)((wxEvent *) ((wxIdleEvent *) x));
45510 }
45511 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
45512 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
45513 }
45514 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
45515 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
45516 }
45517 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
45518 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
45519 }
45520 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
45521 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
45522 }
45523 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
45524 return (void *)((wxEvent *) ((wxActivateEvent *) x));
45525 }
45526 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
45527 return (void *)((wxEvent *) ((wxSizeEvent *) x));
45528 }
45529 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
45530 return (void *)((wxEvent *) ((wxMoveEvent *) x));
45531 }
45532 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
45533 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
45534 }
45535 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
45536 return (void *)((wxEvent *) ((wxPaintEvent *) x));
45537 }
45538 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
45539 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
45540 }
45541 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
45542 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
45543 }
45544 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
45545 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
45546 }
45547 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
45548 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
45549 }
45550 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
45551 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
45552 }
45553 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
45554 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
45555 }
45556 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
45557 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
45558 }
45559 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
45560 return (void *)((wxEvent *) ((wxFocusEvent *) x));
45561 }
45562 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
45563 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
45564 }
45565 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
45566 return (void *)((wxEvent *) ((wxShowEvent *) x));
45567 }
45568 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
45569 return (void *)((wxEvent *) ((wxCommandEvent *) x));
45570 }
45571 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
45572 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
45573 }
45574 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
45575 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45576 }
45577 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
45578 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
45579 }
45580 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
45581 return (void *)((wxEvent *) ((wxKeyEvent *) x));
45582 }
45583 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
45584 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
45585 }
45586 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
45587 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
45588 }
45589 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
45590 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
45591 }
45592 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
45593 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
45594 }
45595 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
45596 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
45597 }
45598 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
45599 return (void *)((wxControl *) ((wxControlWithItems *) x));
45600 }
45601 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
45602 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
45603 }
45604 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
45605 return (void *)((wxEvtHandler *) ((wxWindow *) x));
45606 }
45607 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
45608 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
45609 }
45610 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
45611 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
45612 }
45613 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
45614 return (void *)((wxEvtHandler *) ((wxValidator *) x));
45615 }
45616 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
45617 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
45618 }
45619 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
45620 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
45621 }
45622 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
45623 return (void *)((wxEvtHandler *) ((wxMenu *) x));
45624 }
45625 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
45626 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
45627 }
45628 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
45629 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
45630 }
45631 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
45632 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
45633 }
45634 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
45635 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
45636 }
45637 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
45638 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
45639 }
45640 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
45641 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45642 }
45643 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
45644 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
45645 }
45646 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
45647 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
45648 }
45649 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
45650 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
45651 }
45652 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
45653 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45654 }
45655 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
45656 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
45657 }
45658 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
45659 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
45660 }
45661 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
45662 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
45663 }
45664 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
45665 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
45666 }
45667 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
45668 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
45669 }
45670 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
45671 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
45672 }
45673 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
45674 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
45675 }
45676 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
45677 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
45678 }
45679 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
45680 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
45681 }
45682 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
45683 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
45684 }
45685 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
45686 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
45687 }
45688 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
45689 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
45690 }
45691 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
45692 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
45693 }
45694 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
45695 return (void *)((wxObject *) ((wxSizerItem *) x));
45696 }
45697 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
45698 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
45699 }
45700 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
45701 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
45702 }
45703 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
45704 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
45705 }
45706 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
45707 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
45708 }
45709 static void *_p_wxSizerTo_p_wxObject(void *x) {
45710 return (void *)((wxObject *) ((wxSizer *) x));
45711 }
45712 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
45713 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
45714 }
45715 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
45716 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
45717 }
45718 static void *_p_wxEventTo_p_wxObject(void *x) {
45719 return (void *)((wxObject *) ((wxEvent *) x));
45720 }
45721 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
45722 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
45723 }
45724 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
45725 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
45726 }
45727 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
45728 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
45729 }
45730 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
45731 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
45732 }
45733 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
45734 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
45735 }
45736 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
45737 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
45738 }
45739 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
45740 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
45741 }
45742 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
45743 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
45744 }
45745 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
45746 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
45747 }
45748 static void *_p_wxControlTo_p_wxObject(void *x) {
45749 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
45750 }
45751 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
45752 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
45753 }
45754 static void *_p_wxFSFileTo_p_wxObject(void *x) {
45755 return (void *)((wxObject *) ((wxFSFile *) x));
45756 }
45757 static void *_p_wxPySizerTo_p_wxObject(void *x) {
45758 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
45759 }
45760 static void *_p_wxPyEventTo_p_wxObject(void *x) {
45761 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
45762 }
45763 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
45764 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
45765 }
45766 static void *_p_wxShowEventTo_p_wxObject(void *x) {
45767 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
45768 }
45769 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
45770 return (void *)((wxObject *) ((wxMenuItem *) x));
45771 }
45772 static void *_p_wxDateEventTo_p_wxObject(void *x) {
45773 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
45774 }
45775 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
45776 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
45777 }
45778 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
45779 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
45780 }
45781 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
45782 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
45783 }
45784 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
45785 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
45786 }
45787 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
45788 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
45789 }
45790 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
45791 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
45792 }
45793 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
45794 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
45795 }
45796 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
45797 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
45798 }
45799 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
45800 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
45801 }
45802 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
45803 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
45804 }
45805 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
45806 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
45807 }
45808 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
45809 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
45810 }
45811 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
45812 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
45813 }
45814 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
45815 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
45816 }
45817 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
45818 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
45819 }
45820 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
45821 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
45822 }
45823 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
45824 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
45825 }
45826 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
45827 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
45828 }
45829 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
45830 return (void *)((wxObject *) ((wxImageHandler *) x));
45831 }
45832 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
45833 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
45834 }
45835 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
45836 return (void *)((wxObject *) ((wxEvtHandler *) x));
45837 }
45838 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
45839 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
45840 }
45841 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
45842 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
45843 }
45844 static void *_p_wxImageTo_p_wxObject(void *x) {
45845 return (void *)((wxObject *) ((wxImage *) x));
45846 }
45847 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
45848 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
45849 }
45850 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
45851 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45852 }
45853 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
45854 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
45855 }
45856 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
45857 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
45858 }
45859 static void *_p_wxWindowTo_p_wxObject(void *x) {
45860 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
45861 }
45862 static void *_p_wxMenuTo_p_wxObject(void *x) {
45863 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
45864 }
45865 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
45866 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
45867 }
45868 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
45869 return (void *)((wxObject *) ((wxFileSystem *) x));
45870 }
45871 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
45872 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
45873 }
45874 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
45875 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
45876 }
45877 static void *_p_wxPyAppTo_p_wxObject(void *x) {
45878 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
45879 }
45880 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
45881 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
45882 }
45883 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
45884 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
45885 }
45886 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
45887 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
45888 }
45889 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
45890 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
45891 }
45892 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
45893 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
45894 }
45895 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
45896 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
45897 }
45898 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
45899 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
45900 }
45901 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
45902 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
45903 }
45904 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
45905 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
45906 }
45907 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
45908 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
45909 }
45910 static void *_p_wxValidatorTo_p_wxObject(void *x) {
45911 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
45912 }
45913 static void *_p_wxControlTo_p_wxWindow(void *x) {
45914 return (void *)((wxWindow *) ((wxControl *) x));
45915 }
45916 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
45917 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
45918 }
45919 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
45920 return (void *)((wxWindow *) ((wxMenuBar *) x));
45921 }
45922 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
45923 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
45924 }
45925 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
45926 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
45927 }
45928 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
45929 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
45930 }
45931 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
45932 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
45933 }
45934 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
45935 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
45936 }
45937 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
45938 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
45939 }
45940 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
45941 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
45942 }
45943 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
45944 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
45945 }
45946 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
45947 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
45948 }
45949 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
45950 return (void *)((wxValidator *) ((wxPyValidator *) x));
45951 }
45952 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}};
45953 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}};
45954 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}};
45955 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}};
45956 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}};
45957 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}};
45958 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}};
45959 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}};
45960 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}};
45961 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}};
45962 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}};
45963 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}};
45964 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}};
45965 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}};
45966 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}};
45967 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}};
45968 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}};
45969 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}};
45970 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}};
45971 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}};
45972 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}};
45973 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}};
45974 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}};
45975 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}};
45976 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}};
45977 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}};
45978 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}};
45979 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}};
45980 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}};
45981 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}};
45982 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}};
45983 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}};
45984 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}};
45985 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}};
45986 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}};
45987 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}};
45988 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}};
45989 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}};
45990 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}};
45991 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}};
45992 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}};
45993 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}};
45994 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}};
45995 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}};
45996 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}};
45997 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}};
45998 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}};
45999 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}};
46000 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}};
46001 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}};
46002 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}};
46003 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}};
46004 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}};
46005 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}};
46006 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}};
46007 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}};
46008 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}};
46009 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}};
46010 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}};
46011 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}};
46012 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}};
46013 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}};
46014 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}};
46015 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}};
46016 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}};
46017 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}};
46018 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}};
46019 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}};
46020 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}};
46021 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}};
46022 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}};
46023 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}};
46024 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}};
46025 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}};
46026 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}};
46027 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}};
46028 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}};
46029 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}};
46030 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}};
46031 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}};
46032 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}};
46033 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}};
46034 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}};
46035 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}};
46036 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}};
46037 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}};
46038 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}};
46039 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}};
46040 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}};
46041 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}};
46042 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}};
46043 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}};
46044 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}};
46045 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}};
46046 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}};
46047 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}};
46048 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}};
46049 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}};
46050 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}};
46051 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}};
46052 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}};
46053 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}};
46054 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}};
46055 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}};
46056 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}};
46057 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}};
46058 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}};
46059 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}};
46060 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}};
46061 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}};
46062 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}};
46063 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *|byte *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
46064 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}};
46065 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}};
46066 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}};
46067 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}};
46068 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}};
46069 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}};
46070 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}};
46071 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}};
46072 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}};
46073 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}};
46074 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}};
46075 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}};
46076 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}};
46077 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}};
46078 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}};
46079
46080 static swig_type_info *swig_types_initial[] = {
46081 _swigt__p_wxLayoutConstraints,
46082 _swigt__p_wxRealPoint,
46083 _swigt__p_wxSizerItem,
46084 _swigt__p_wxGBSizerItem,
46085 _swigt__p_wxScrollEvent,
46086 _swigt__p_wxEventLoop,
46087 _swigt__p_wxIndividualLayoutConstraint,
46088 _swigt__p_wxSizer,
46089 _swigt__p_wxBoxSizer,
46090 _swigt__p_wxStaticBoxSizer,
46091 _swigt__p_wxGridBagSizer,
46092 _swigt__p_wxAcceleratorEntry,
46093 _swigt__p_wxUpdateUIEvent,
46094 _swigt__p_wxEvent,
46095 _swigt__p_wxMenu,
46096 _swigt__p_wxGridSizer,
46097 _swigt__p_wxFlexGridSizer,
46098 _swigt__p_wxInitDialogEvent,
46099 _swigt__p_wxItemContainer,
46100 _swigt__p_wxNcPaintEvent,
46101 _swigt__p_wxPaintEvent,
46102 _swigt__p_wxSysColourChangedEvent,
46103 _swigt__p_wxMouseCaptureChangedEvent,
46104 _swigt__p_wxDisplayChangedEvent,
46105 _swigt__p_wxPaletteChangedEvent,
46106 _swigt__p_wxControl,
46107 _swigt__p_wxFont,
46108 _swigt__p_wxMenuBarBase,
46109 _swigt__p_wxSetCursorEvent,
46110 _swigt__p_wxFSFile,
46111 _swigt__p_wxCaret,
46112 _swigt__ptrdiff_t,
46113 _swigt__std__ptrdiff_t,
46114 _swigt__p_wxRegion,
46115 _swigt__p_wxPoint2D,
46116 _swigt__p_int,
46117 _swigt__p_wxSize,
46118 _swigt__p_wxDC,
46119 _swigt__p_wxPySizer,
46120 _swigt__p_wxVisualAttributes,
46121 _swigt__p_wxNotifyEvent,
46122 _swigt__p_wxPyEvent,
46123 _swigt__p_wxPropagationDisabler,
46124 _swigt__p_form_ops_t,
46125 _swigt__p_wxAppTraits,
46126 _swigt__p_wxArrayString,
46127 _swigt__p_wxShowEvent,
46128 _swigt__p_wxToolTip,
46129 _swigt__p_wxMoveEvent,
46130 _swigt__p_wxSizeEvent,
46131 _swigt__p_wxActivateEvent,
46132 _swigt__p_wxIconizeEvent,
46133 _swigt__p_wxMaximizeEvent,
46134 _swigt__p_wxQueryNewPaletteEvent,
46135 _swigt__p_wxWindowCreateEvent,
46136 _swigt__p_wxIdleEvent,
46137 _swigt__p_wxDateEvent,
46138 _swigt__p_wxMenuItem,
46139 _swigt__p_wxStaticBox,
46140 _swigt__p_long,
46141 _swigt__p_wxDuplexMode,
46142 _swigt__p_wxTIFFHandler,
46143 _swigt__p_wxXPMHandler,
46144 _swigt__p_wxPNMHandler,
46145 _swigt__p_wxJPEGHandler,
46146 _swigt__p_wxPCXHandler,
46147 _swigt__p_wxGIFHandler,
46148 _swigt__p_wxPNGHandler,
46149 _swigt__p_wxANIHandler,
46150 _swigt__p_wxMemoryFSHandler,
46151 _swigt__p_wxZipFSHandler,
46152 _swigt__p_wxInternetFSHandler,
46153 _swigt__p_wxPyFileSystemHandler,
46154 _swigt__p_wxEvtHandler,
46155 _swigt__p_wxCURHandler,
46156 _swigt__p_wxICOHandler,
46157 _swigt__p_wxBMPHandler,
46158 _swigt__p_wxImageHandler,
46159 _swigt__p_wxFileSystemHandler,
46160 _swigt__p_wxRect,
46161 _swigt__p_wxButton,
46162 _swigt__p_wxGBSpan,
46163 _swigt__p_wxPropagateOnce,
46164 _swigt__p_wxAcceleratorTable,
46165 _swigt__p_wxStdDialogButtonSizer,
46166 _swigt__p_char,
46167 _swigt__p_wxGBPosition,
46168 _swigt__p_wxImage,
46169 _swigt__p_wxFrame,
46170 _swigt__p_wxScrollWinEvent,
46171 _swigt__p_wxPaperSize,
46172 _swigt__p_wxImageHistogram,
46173 _swigt__p_wxPoint,
46174 _swigt__p_wxCursor,
46175 _swigt__p_wxObject,
46176 _swigt__p_wxInputStream,
46177 _swigt__p_wxOutputStream,
46178 _swigt__p_wxPyInputStream,
46179 _swigt__p_wxDateTime,
46180 _swigt__p_wxKeyEvent,
46181 _swigt__p_wxNavigationKeyEvent,
46182 _swigt__p_wxWindowDestroyEvent,
46183 _swigt__p_unsigned_long,
46184 _swigt__p_wxWindow,
46185 _swigt__p_wxMenuBar,
46186 _swigt__p_wxFileSystem,
46187 _swigt__p_wxBitmap,
46188 _swigt__unsigned_int,
46189 _swigt__p_unsigned_int,
46190 _swigt__p_wxMenuEvent,
46191 _swigt__p_wxContextMenuEvent,
46192 _swigt__p_unsigned_char,
46193 _swigt__p_wxEraseEvent,
46194 _swigt__p_wxMouseEvent,
46195 _swigt__p_wxCloseEvent,
46196 _swigt__p_wxPyApp,
46197 _swigt__p_wxCommandEvent,
46198 _swigt__p_wxPyCommandEvent,
46199 _swigt__p_wxPyDropTarget,
46200 _swigt__p_wxQuantize,
46201 _swigt__p_wxChildFocusEvent,
46202 _swigt__p_wxFocusEvent,
46203 _swigt__p_wxDropFilesEvent,
46204 _swigt__p_wxControlWithItems,
46205 _swigt__p_wxColour,
46206 _swigt__p_wxValidator,
46207 _swigt__p_wxPyValidator,
46208 0
46209 };
46210
46211
46212 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
46213
46214 static swig_const_info swig_const_table[] = {
46215 {0, 0, 0, 0.0, 0, 0}};
46216
46217 #ifdef __cplusplus
46218 }
46219 #endif
46220
46221
46222 #ifdef __cplusplus
46223 extern "C" {
46224 #endif
46225
46226 /* Python-specific SWIG API */
46227 #define SWIG_newvarlink() SWIG_Python_newvarlink()
46228 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
46229 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
46230
46231 /* -----------------------------------------------------------------------------
46232 * global variable support code.
46233 * ----------------------------------------------------------------------------- */
46234
46235 typedef struct swig_globalvar {
46236 char *name; /* Name of global variable */
46237 PyObject *(*get_attr)(); /* Return the current value */
46238 int (*set_attr)(PyObject *); /* Set the value */
46239 struct swig_globalvar *next;
46240 } swig_globalvar;
46241
46242 typedef struct swig_varlinkobject {
46243 PyObject_HEAD
46244 swig_globalvar *vars;
46245 } swig_varlinkobject;
46246
46247 static PyObject *
46248 swig_varlink_repr(swig_varlinkobject *v) {
46249 v = v;
46250 return PyString_FromString("<Swig global variables>");
46251 }
46252
46253 static int
46254 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
46255 swig_globalvar *var;
46256 flags = flags;
46257 fprintf(fp,"Swig global variables { ");
46258 for (var = v->vars; var; var=var->next) {
46259 fprintf(fp,"%s", var->name);
46260 if (var->next) fprintf(fp,", ");
46261 }
46262 fprintf(fp," }\n");
46263 return 0;
46264 }
46265
46266 static PyObject *
46267 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
46268 swig_globalvar *var = v->vars;
46269 while (var) {
46270 if (strcmp(var->name,n) == 0) {
46271 return (*var->get_attr)();
46272 }
46273 var = var->next;
46274 }
46275 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46276 return NULL;
46277 }
46278
46279 static int
46280 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
46281 swig_globalvar *var = v->vars;
46282 while (var) {
46283 if (strcmp(var->name,n) == 0) {
46284 return (*var->set_attr)(p);
46285 }
46286 var = var->next;
46287 }
46288 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
46289 return 1;
46290 }
46291
46292 static PyTypeObject varlinktype = {
46293 PyObject_HEAD_INIT(0)
46294 0, /* Number of items in variable part (ob_size) */
46295 (char *)"swigvarlink", /* Type name (tp_name) */
46296 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
46297 0, /* Itemsize (tp_itemsize) */
46298 0, /* Deallocator (tp_dealloc) */
46299 (printfunc) swig_varlink_print, /* Print (tp_print) */
46300 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
46301 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
46302 0, /* tp_compare */
46303 (reprfunc) swig_varlink_repr, /* tp_repr */
46304 0, /* tp_as_number */
46305 0, /* tp_as_sequence */
46306 0, /* tp_as_mapping */
46307 0, /* tp_hash */
46308 0, /* tp_call */
46309 0, /* tp_str */
46310 0, /* tp_getattro */
46311 0, /* tp_setattro */
46312 0, /* tp_as_buffer */
46313 0, /* tp_flags */
46314 0, /* tp_doc */
46315 #if PY_VERSION_HEX >= 0x02000000
46316 0, /* tp_traverse */
46317 0, /* tp_clear */
46318 #endif
46319 #if PY_VERSION_HEX >= 0x02010000
46320 0, /* tp_richcompare */
46321 0, /* tp_weaklistoffset */
46322 #endif
46323 #if PY_VERSION_HEX >= 0x02020000
46324 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
46325 #endif
46326 #if PY_VERSION_HEX >= 0x02030000
46327 0, /* tp_del */
46328 #endif
46329 #ifdef COUNT_ALLOCS
46330 0,0,0,0 /* tp_alloc -> tp_next */
46331 #endif
46332 };
46333
46334 /* Create a variable linking object for use later */
46335 static PyObject *
46336 SWIG_Python_newvarlink(void) {
46337 swig_varlinkobject *result = 0;
46338 result = PyMem_NEW(swig_varlinkobject,1);
46339 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
46340 result->ob_type = &varlinktype;
46341 result->vars = 0;
46342 result->ob_refcnt = 0;
46343 Py_XINCREF((PyObject *) result);
46344 return ((PyObject*) result);
46345 }
46346
46347 static void
46348 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
46349 swig_varlinkobject *v;
46350 swig_globalvar *gv;
46351 v= (swig_varlinkobject *) p;
46352 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
46353 gv->name = (char *) malloc(strlen(name)+1);
46354 strcpy(gv->name,name);
46355 gv->get_attr = get_attr;
46356 gv->set_attr = set_attr;
46357 gv->next = v->vars;
46358 v->vars = gv;
46359 }
46360
46361 /* -----------------------------------------------------------------------------
46362 * constants/methods manipulation
46363 * ----------------------------------------------------------------------------- */
46364
46365 /* Install Constants */
46366 static void
46367 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
46368 PyObject *obj = 0;
46369 size_t i;
46370 for (i = 0; constants[i].type; i++) {
46371 switch(constants[i].type) {
46372 case SWIG_PY_INT:
46373 obj = PyInt_FromLong(constants[i].lvalue);
46374 break;
46375 case SWIG_PY_FLOAT:
46376 obj = PyFloat_FromDouble(constants[i].dvalue);
46377 break;
46378 case SWIG_PY_STRING:
46379 if (constants[i].pvalue) {
46380 obj = PyString_FromString((char *) constants[i].pvalue);
46381 } else {
46382 Py_INCREF(Py_None);
46383 obj = Py_None;
46384 }
46385 break;
46386 case SWIG_PY_POINTER:
46387 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
46388 break;
46389 case SWIG_PY_BINARY:
46390 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
46391 break;
46392 default:
46393 obj = 0;
46394 break;
46395 }
46396 if (obj) {
46397 PyDict_SetItemString(d,constants[i].name,obj);
46398 Py_DECREF(obj);
46399 }
46400 }
46401 }
46402
46403 /* -----------------------------------------------------------------------------*/
46404 /* Fix SwigMethods to carry the callback ptrs when needed */
46405 /* -----------------------------------------------------------------------------*/
46406
46407 static void
46408 SWIG_Python_FixMethods(PyMethodDef *methods,
46409 swig_const_info *const_table,
46410 swig_type_info **types,
46411 swig_type_info **types_initial) {
46412 size_t i;
46413 for (i = 0; methods[i].ml_name; ++i) {
46414 char *c = methods[i].ml_doc;
46415 if (c && (c = strstr(c, "swig_ptr: "))) {
46416 int j;
46417 swig_const_info *ci = 0;
46418 char *name = c + 10;
46419 for (j = 0; const_table[j].type; j++) {
46420 if (strncmp(const_table[j].name, name,
46421 strlen(const_table[j].name)) == 0) {
46422 ci = &(const_table[j]);
46423 break;
46424 }
46425 }
46426 if (ci) {
46427 size_t shift = (ci->ptype) - types;
46428 swig_type_info *ty = types_initial[shift];
46429 size_t ldoc = (c - methods[i].ml_doc);
46430 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
46431 char *ndoc = (char*)malloc(ldoc + lptr + 10);
46432 char *buff = ndoc;
46433 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
46434 strncpy(buff, methods[i].ml_doc, ldoc);
46435 buff += ldoc;
46436 strncpy(buff, "swig_ptr: ", 10);
46437 buff += 10;
46438 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
46439 methods[i].ml_doc = ndoc;
46440 }
46441 }
46442 }
46443 }
46444
46445 /* -----------------------------------------------------------------------------*
46446 * Initialize type list
46447 * -----------------------------------------------------------------------------*/
46448
46449 #if PY_MAJOR_VERSION < 2
46450 /* PyModule_AddObject function was introduced in Python 2.0. The following function
46451 is copied out of Python/modsupport.c in python version 2.3.4 */
46452 static int
46453 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
46454 {
46455 PyObject *dict;
46456 if (!PyModule_Check(m)) {
46457 PyErr_SetString(PyExc_TypeError,
46458 "PyModule_AddObject() needs module as first arg");
46459 return -1;
46460 }
46461 if (!o) {
46462 PyErr_SetString(PyExc_TypeError,
46463 "PyModule_AddObject() needs non-NULL value");
46464 return -1;
46465 }
46466
46467 dict = PyModule_GetDict(m);
46468 if (dict == NULL) {
46469 /* Internal error -- modules must have a dict! */
46470 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
46471 PyModule_GetName(m));
46472 return -1;
46473 }
46474 if (PyDict_SetItemString(dict, name, o))
46475 return -1;
46476 Py_DECREF(o);
46477 return 0;
46478 }
46479 #endif
46480
46481 static swig_type_info **
46482 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
46483 static PyMethodDef swig_empty_runtime_method_table[] = {
46484 {
46485 NULL, NULL, 0, NULL
46486 }
46487 };/* Sentinel */
46488
46489 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
46490 swig_empty_runtime_method_table);
46491 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
46492 if (pointer && module) {
46493 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
46494 }
46495 return type_list_handle;
46496 }
46497
46498 static swig_type_info **
46499 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
46500 swig_type_info **type_pointer;
46501
46502 /* first check if module already created */
46503 type_pointer = SWIG_Python_GetTypeListHandle();
46504 if (type_pointer) {
46505 return type_pointer;
46506 } else {
46507 /* create a new module and variable */
46508 return SWIG_Python_SetTypeListHandle(type_list_handle);
46509 }
46510 }
46511
46512 #ifdef __cplusplus
46513 }
46514 #endif
46515
46516 /* -----------------------------------------------------------------------------*
46517 * Partial Init method
46518 * -----------------------------------------------------------------------------*/
46519
46520 #ifdef SWIG_LINK_RUNTIME
46521 #ifdef __cplusplus
46522 extern "C"
46523 #endif
46524 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
46525 #endif
46526
46527 #ifdef __cplusplus
46528 extern "C"
46529 #endif
46530 SWIGEXPORT(void) SWIG_init(void) {
46531 static PyObject *SWIG_globals = 0;
46532 static int typeinit = 0;
46533 PyObject *m, *d;
46534 int i;
46535 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
46536
46537 /* Fix SwigMethods to carry the callback ptrs when needed */
46538 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
46539
46540 m = Py_InitModule((char *) SWIG_name, SwigMethods);
46541 d = PyModule_GetDict(m);
46542
46543 if (!typeinit) {
46544 #ifdef SWIG_LINK_RUNTIME
46545 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
46546 #else
46547 # ifndef SWIG_STATIC_RUNTIME
46548 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
46549 # endif
46550 #endif
46551 for (i = 0; swig_types_initial[i]; i++) {
46552 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
46553 }
46554 typeinit = 1;
46555 }
46556 SWIG_InstallConstants(d,swig_const_table);
46557
46558
46559 #ifndef wxPyUSE_EXPORT
46560 // Make our API structure a CObject so other modules can import it
46561 // from this module.
46562 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
46563 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
46564 Py_XDECREF(cobj);
46565 #endif
46566
46567 {
46568 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
46569 }
46570 {
46571 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
46572 }
46573 {
46574 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
46575 }
46576 {
46577 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
46578 }
46579 {
46580 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
46581 }
46582 {
46583 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
46584 }
46585 {
46586 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
46587 }
46588 {
46589 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
46590 }
46591 {
46592 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
46593 }
46594 {
46595 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
46596 }
46597 {
46598 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
46599 }
46600 {
46601 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
46602 }
46603 {
46604 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
46605 }
46606 {
46607 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
46608 }
46609 {
46610 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
46611 }
46612 {
46613 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
46614 }
46615 {
46616 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
46617 }
46618 {
46619 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
46620 }
46621 {
46622 PyDict_SetItemString(d,"ED_CLIENT_MARGIN", SWIG_From_int((int)(wxED_CLIENT_MARGIN)));
46623 }
46624 {
46625 PyDict_SetItemString(d,"ED_BUTTONS_BOTTOM", SWIG_From_int((int)(wxED_BUTTONS_BOTTOM)));
46626 }
46627 {
46628 PyDict_SetItemString(d,"ED_BUTTONS_RIGHT", SWIG_From_int((int)(wxED_BUTTONS_RIGHT)));
46629 }
46630 {
46631 PyDict_SetItemString(d,"ED_STATIC_LINE", SWIG_From_int((int)(wxED_STATIC_LINE)));
46632 }
46633 {
46634 PyDict_SetItemString(d,"EXT_DIALOG_STYLE", SWIG_From_int((int)(wxEXT_DIALOG_STYLE)));
46635 }
46636 {
46637 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
46638 }
46639 {
46640 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
46641 }
46642 {
46643 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
46644 }
46645 {
46646 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
46647 }
46648 {
46649 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
46650 }
46651 {
46652 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
46653 }
46654 {
46655 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
46656 }
46657 {
46658 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
46659 }
46660 {
46661 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
46662 }
46663 {
46664 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
46665 }
46666 {
46667 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
46668 }
46669 {
46670 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
46671 }
46672 {
46673 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
46674 }
46675 {
46676 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
46677 }
46678 {
46679 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
46680 }
46681 {
46682 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
46683 }
46684 {
46685 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
46686 }
46687 {
46688 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
46689 }
46690 {
46691 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
46692 }
46693 {
46694 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
46695 }
46696 {
46697 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
46698 }
46699 {
46700 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
46701 }
46702 {
46703 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
46704 }
46705 {
46706 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
46707 }
46708 {
46709 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
46710 }
46711 {
46712 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
46713 }
46714 {
46715 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
46716 }
46717 {
46718 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
46719 }
46720 {
46721 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
46722 }
46723 {
46724 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
46725 }
46726 {
46727 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
46728 }
46729 {
46730 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
46731 }
46732 {
46733 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
46734 }
46735 {
46736 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
46737 }
46738 {
46739 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
46740 }
46741 {
46742 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
46743 }
46744 {
46745 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
46746 }
46747 {
46748 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
46749 }
46750 {
46751 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
46752 }
46753 {
46754 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
46755 }
46756 {
46757 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
46758 }
46759 {
46760 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
46761 }
46762 {
46763 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
46764 }
46765 {
46766 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
46767 }
46768 {
46769 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
46770 }
46771 {
46772 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
46773 }
46774 {
46775 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
46776 }
46777 {
46778 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
46779 }
46780 {
46781 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
46782 }
46783 {
46784 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
46785 }
46786 {
46787 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
46788 }
46789 {
46790 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
46791 }
46792 {
46793 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
46794 }
46795 {
46796 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
46797 }
46798 {
46799 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
46800 }
46801 {
46802 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
46803 }
46804 {
46805 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
46806 }
46807 {
46808 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
46809 }
46810 {
46811 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
46812 }
46813 {
46814 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
46815 }
46816 {
46817 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
46818 }
46819 {
46820 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
46821 }
46822 {
46823 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
46824 }
46825 {
46826 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
46827 }
46828 {
46829 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
46830 }
46831 {
46832 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
46833 }
46834 {
46835 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
46836 }
46837 {
46838 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
46839 }
46840 {
46841 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
46842 }
46843 {
46844 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
46845 }
46846 {
46847 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
46848 }
46849 {
46850 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
46851 }
46852 {
46853 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
46854 }
46855 {
46856 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
46857 }
46858 {
46859 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
46860 }
46861 {
46862 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
46863 }
46864 {
46865 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
46866 }
46867 {
46868 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
46869 }
46870 {
46871 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
46872 }
46873 {
46874 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
46875 }
46876 {
46877 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
46878 }
46879 {
46880 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
46881 }
46882 {
46883 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
46884 }
46885 {
46886 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
46887 }
46888 {
46889 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
46890 }
46891 {
46892 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
46893 }
46894 {
46895 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
46896 }
46897 {
46898 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
46899 }
46900 {
46901 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
46902 }
46903 {
46904 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
46905 }
46906 {
46907 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
46908 }
46909 {
46910 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
46911 }
46912 {
46913 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
46914 }
46915 {
46916 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
46917 }
46918 {
46919 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
46920 }
46921 {
46922 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
46923 }
46924 {
46925 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
46926 }
46927 {
46928 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
46929 }
46930 {
46931 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
46932 }
46933 {
46934 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
46935 }
46936 {
46937 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
46938 }
46939 {
46940 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
46941 }
46942 {
46943 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
46944 }
46945 {
46946 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
46947 }
46948 {
46949 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
46950 }
46951 {
46952 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
46953 }
46954 {
46955 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
46956 }
46957 {
46958 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
46959 }
46960 {
46961 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
46962 }
46963 {
46964 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
46965 }
46966 {
46967 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
46968 }
46969 {
46970 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
46971 }
46972 {
46973 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
46974 }
46975 {
46976 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
46977 }
46978 {
46979 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
46980 }
46981 {
46982 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
46983 }
46984 {
46985 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
46986 }
46987 {
46988 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
46989 }
46990 {
46991 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
46992 }
46993 {
46994 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
46995 }
46996 {
46997 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
46998 }
46999 {
47000 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
47001 }
47002 {
47003 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
47004 }
47005 {
47006 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
47007 }
47008 {
47009 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
47010 }
47011 {
47012 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
47013 }
47014 {
47015 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
47016 }
47017 {
47018 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
47019 }
47020 {
47021 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
47022 }
47023 {
47024 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
47025 }
47026 {
47027 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
47028 }
47029 {
47030 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
47031 }
47032 {
47033 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
47034 }
47035 {
47036 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
47037 }
47038 {
47039 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
47040 }
47041 {
47042 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
47043 }
47044 {
47045 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
47046 }
47047 {
47048 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
47049 }
47050 {
47051 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
47052 }
47053 {
47054 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
47055 }
47056 {
47057 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
47058 }
47059 {
47060 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
47061 }
47062 {
47063 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
47064 }
47065 {
47066 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
47067 }
47068 {
47069 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
47070 }
47071 {
47072 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
47073 }
47074 {
47075 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
47076 }
47077 {
47078 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
47079 }
47080 {
47081 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
47082 }
47083 {
47084 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
47085 }
47086 {
47087 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
47088 }
47089 {
47090 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
47091 }
47092 {
47093 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
47094 }
47095 {
47096 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
47097 }
47098 {
47099 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
47100 }
47101 {
47102 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
47103 }
47104 {
47105 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
47106 }
47107 {
47108 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
47109 }
47110 {
47111 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
47112 }
47113 {
47114 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
47115 }
47116 {
47117 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
47118 }
47119 {
47120 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
47121 }
47122 {
47123 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
47124 }
47125 {
47126 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
47127 }
47128 {
47129 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
47130 }
47131 {
47132 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
47133 }
47134 {
47135 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
47136 }
47137 {
47138 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
47139 }
47140 {
47141 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
47142 }
47143 {
47144 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
47145 }
47146 {
47147 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
47148 }
47149 {
47150 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
47151 }
47152 {
47153 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
47154 }
47155 {
47156 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
47157 }
47158 {
47159 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
47160 }
47161 {
47162 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
47163 }
47164 {
47165 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
47166 }
47167 {
47168 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
47169 }
47170 {
47171 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
47172 }
47173 {
47174 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
47175 }
47176 {
47177 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
47178 }
47179 {
47180 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
47181 }
47182 {
47183 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
47184 }
47185 {
47186 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
47187 }
47188 {
47189 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
47190 }
47191 {
47192 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
47193 }
47194 {
47195 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
47196 }
47197 {
47198 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
47199 }
47200 {
47201 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
47202 }
47203 {
47204 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
47205 }
47206 {
47207 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
47208 }
47209 {
47210 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
47211 }
47212 {
47213 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
47214 }
47215 {
47216 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
47217 }
47218 {
47219 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
47220 }
47221 {
47222 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
47223 }
47224 {
47225 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
47226 }
47227 {
47228 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
47229 }
47230 {
47231 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
47232 }
47233 {
47234 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
47235 }
47236 {
47237 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
47238 }
47239 {
47240 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
47241 }
47242 {
47243 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
47244 }
47245 {
47246 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
47247 }
47248 {
47249 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
47250 }
47251 {
47252 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
47253 }
47254 {
47255 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
47256 }
47257 {
47258 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
47259 }
47260 {
47261 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
47262 }
47263 {
47264 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
47265 }
47266 {
47267 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
47268 }
47269 {
47270 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
47271 }
47272 {
47273 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
47274 }
47275 {
47276 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
47277 }
47278 {
47279 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
47280 }
47281 {
47282 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
47283 }
47284 {
47285 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
47286 }
47287 {
47288 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
47289 }
47290 {
47291 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
47292 }
47293 {
47294 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
47295 }
47296 {
47297 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
47298 }
47299 {
47300 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
47301 }
47302 {
47303 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
47304 }
47305 {
47306 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
47307 }
47308 {
47309 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
47310 }
47311 {
47312 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
47313 }
47314 {
47315 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
47316 }
47317 {
47318 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
47319 }
47320 {
47321 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
47322 }
47323 {
47324 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
47325 }
47326 {
47327 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
47328 }
47329 {
47330 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
47331 }
47332 {
47333 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
47334 }
47335 {
47336 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
47337 }
47338 {
47339 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
47340 }
47341 {
47342 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
47343 }
47344 {
47345 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
47346 }
47347 {
47348 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
47349 }
47350 {
47351 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
47352 }
47353 {
47354 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
47355 }
47356 {
47357 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
47358 }
47359 {
47360 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
47361 }
47362 {
47363 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
47364 }
47365 {
47366 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
47367 }
47368 {
47369 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
47370 }
47371 {
47372 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
47373 }
47374 {
47375 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
47376 }
47377 {
47378 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
47379 }
47380 {
47381 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
47382 }
47383 {
47384 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
47385 }
47386 {
47387 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
47388 }
47389 {
47390 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
47391 }
47392 {
47393 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
47394 }
47395 {
47396 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
47397 }
47398 {
47399 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
47400 }
47401 {
47402 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
47403 }
47404 {
47405 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
47406 }
47407 {
47408 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
47409 }
47410 {
47411 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
47412 }
47413 {
47414 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
47415 }
47416 {
47417 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
47418 }
47419 {
47420 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
47421 }
47422 {
47423 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
47424 }
47425 {
47426 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
47427 }
47428 {
47429 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
47430 }
47431 {
47432 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
47433 }
47434 {
47435 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
47436 }
47437 {
47438 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
47439 }
47440 {
47441 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
47442 }
47443 {
47444 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
47445 }
47446 {
47447 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
47448 }
47449 {
47450 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
47451 }
47452 {
47453 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
47454 }
47455 {
47456 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
47457 }
47458 {
47459 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
47460 }
47461 {
47462 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
47463 }
47464 {
47465 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
47466 }
47467 {
47468 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
47469 }
47470 {
47471 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
47472 }
47473 {
47474 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
47475 }
47476 {
47477 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
47478 }
47479 {
47480 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
47481 }
47482 {
47483 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
47484 }
47485 {
47486 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
47487 }
47488 {
47489 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
47490 }
47491 {
47492 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
47493 }
47494 {
47495 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
47496 }
47497 {
47498 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
47499 }
47500 {
47501 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
47502 }
47503 {
47504 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
47505 }
47506 {
47507 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
47508 }
47509 {
47510 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
47511 }
47512 {
47513 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
47514 }
47515 {
47516 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
47517 }
47518 {
47519 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
47520 }
47521 {
47522 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
47523 }
47524 {
47525 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
47526 }
47527 {
47528 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
47529 }
47530 {
47531 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
47532 }
47533 {
47534 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
47535 }
47536 {
47537 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
47538 }
47539 {
47540 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
47541 }
47542 {
47543 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
47544 }
47545 {
47546 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
47547 }
47548 {
47549 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
47550 }
47551 {
47552 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
47553 }
47554 {
47555 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
47556 }
47557 {
47558 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
47559 }
47560 {
47561 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
47562 }
47563 {
47564 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
47565 }
47566 {
47567 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
47568 }
47569 {
47570 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
47571 }
47572 {
47573 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
47574 }
47575 {
47576 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
47577 }
47578 {
47579 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
47580 }
47581 {
47582 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
47583 }
47584 {
47585 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
47586 }
47587 {
47588 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
47589 }
47590 {
47591 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
47592 }
47593 {
47594 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
47595 }
47596 {
47597 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
47598 }
47599 {
47600 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
47601 }
47602 {
47603 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
47604 }
47605 {
47606 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
47607 }
47608 {
47609 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
47610 }
47611 {
47612 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
47613 }
47614 {
47615 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
47616 }
47617 {
47618 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
47619 }
47620 {
47621 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
47622 }
47623 {
47624 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
47625 }
47626 {
47627 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
47628 }
47629 {
47630 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
47631 }
47632 {
47633 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
47634 }
47635 {
47636 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
47637 }
47638 {
47639 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
47640 }
47641 {
47642 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
47643 }
47644 {
47645 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
47646 }
47647 {
47648 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
47649 }
47650 {
47651 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
47652 }
47653 {
47654 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
47655 }
47656 {
47657 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
47658 }
47659 {
47660 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
47661 }
47662 {
47663 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
47664 }
47665 {
47666 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
47667 }
47668 {
47669 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
47670 }
47671 {
47672 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
47673 }
47674 {
47675 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
47676 }
47677 {
47678 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
47679 }
47680 {
47681 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
47682 }
47683 {
47684 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
47685 }
47686 {
47687 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
47688 }
47689 {
47690 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
47691 }
47692 {
47693 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
47694 }
47695 {
47696 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
47697 }
47698 {
47699 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
47700 }
47701 {
47702 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
47703 }
47704 {
47705 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
47706 }
47707 {
47708 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
47709 }
47710 {
47711 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
47712 }
47713 {
47714 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
47715 }
47716 {
47717 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
47718 }
47719 {
47720 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
47721 }
47722 {
47723 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
47724 }
47725 {
47726 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
47727 }
47728 {
47729 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
47730 }
47731 {
47732 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
47733 }
47734 {
47735 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
47736 }
47737 {
47738 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
47739 }
47740 {
47741 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
47742 }
47743 {
47744 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
47745 }
47746 {
47747 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
47748 }
47749 {
47750 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
47751 }
47752 {
47753 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
47754 }
47755 {
47756 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
47757 }
47758 {
47759 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
47760 }
47761 {
47762 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
47763 }
47764 {
47765 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
47766 }
47767 {
47768 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
47769 }
47770 {
47771 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
47772 }
47773 {
47774 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
47775 }
47776 {
47777 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
47778 }
47779 {
47780 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
47781 }
47782 {
47783 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
47784 }
47785 {
47786 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
47787 }
47788 {
47789 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
47790 }
47791 {
47792 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
47793 }
47794 {
47795 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
47796 }
47797 {
47798 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
47799 }
47800 {
47801 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
47802 }
47803 {
47804 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
47805 }
47806 {
47807 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
47808 }
47809 {
47810 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
47811 }
47812 {
47813 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
47814 }
47815 {
47816 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
47817 }
47818 {
47819 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
47820 }
47821 {
47822 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
47823 }
47824 {
47825 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
47826 }
47827 {
47828 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
47829 }
47830 {
47831 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
47832 }
47833 {
47834 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
47835 }
47836 {
47837 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
47838 }
47839 {
47840 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
47841 }
47842 {
47843 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
47844 }
47845 {
47846 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
47847 }
47848 {
47849 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
47850 }
47851 {
47852 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
47853 }
47854 {
47855 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
47856 }
47857 {
47858 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
47859 }
47860 {
47861 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
47862 }
47863 {
47864 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
47865 }
47866 {
47867 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
47868 }
47869 {
47870 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
47871 }
47872 {
47873 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
47874 }
47875 {
47876 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
47877 }
47878 {
47879 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
47880 }
47881 {
47882 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
47883 }
47884 {
47885 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
47886 }
47887 {
47888 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
47889 }
47890 {
47891 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
47892 }
47893 {
47894 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
47895 }
47896 {
47897 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
47898 }
47899 {
47900 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
47901 }
47902 {
47903 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
47904 }
47905 {
47906 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
47907 }
47908 {
47909 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
47910 }
47911 {
47912 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
47913 }
47914 {
47915 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
47916 }
47917 {
47918 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
47919 }
47920 {
47921 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
47922 }
47923 {
47924 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
47925 }
47926 {
47927 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
47928 }
47929 {
47930 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
47931 }
47932 {
47933 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
47934 }
47935 {
47936 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
47937 }
47938 {
47939 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
47940 }
47941 {
47942 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
47943 }
47944 {
47945 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
47946 }
47947 {
47948 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
47949 }
47950 {
47951 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
47952 }
47953 {
47954 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
47955 }
47956 {
47957 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
47958 }
47959 {
47960 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
47961 }
47962 {
47963 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
47964 }
47965 {
47966 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
47967 }
47968 {
47969 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
47970 }
47971 {
47972 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
47973 }
47974 {
47975 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
47976 }
47977 {
47978 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
47979 }
47980 {
47981 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
47982 }
47983 {
47984 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
47985 }
47986 {
47987 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
47988 }
47989 {
47990 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
47991 }
47992 {
47993 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
47994 }
47995 {
47996 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
47997 }
47998 {
47999 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
48000 }
48001 {
48002 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
48003 }
48004 {
48005 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
48006 }
48007 {
48008 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
48009 }
48010 {
48011 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
48012 }
48013 {
48014 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
48015 }
48016 {
48017 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
48018 }
48019 {
48020 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
48021 }
48022 {
48023 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
48024 }
48025 {
48026 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
48027 }
48028 {
48029 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
48030 }
48031 {
48032 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
48033 }
48034 {
48035 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
48036 }
48037 {
48038 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
48039 }
48040 {
48041 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
48042 }
48043 {
48044 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
48045 }
48046 {
48047 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
48048 }
48049 {
48050 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
48051 }
48052 {
48053 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
48054 }
48055 {
48056 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
48057 }
48058 {
48059 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
48060 }
48061 {
48062 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
48063 }
48064 {
48065 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
48066 }
48067 {
48068 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
48069 }
48070 {
48071 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
48072 }
48073 {
48074 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
48075 }
48076 {
48077 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
48078 }
48079 {
48080 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
48081 }
48082 {
48083 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
48084 }
48085 {
48086 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
48087 }
48088 {
48089 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
48090 }
48091 {
48092 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
48093 }
48094 {
48095 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
48096 }
48097 {
48098 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
48099 }
48100 {
48101 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
48102 }
48103 {
48104 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
48105 }
48106 {
48107 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
48108 }
48109 {
48110 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
48111 }
48112 {
48113 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
48114 }
48115 {
48116 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
48117 }
48118 {
48119 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
48120 }
48121 {
48122 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
48123 }
48124 {
48125 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
48126 }
48127 {
48128 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
48129 }
48130 {
48131 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
48132 }
48133 {
48134 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
48135 }
48136 {
48137 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
48138 }
48139 {
48140 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
48141 }
48142 {
48143 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
48144 }
48145 {
48146 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
48147 }
48148 {
48149 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
48150 }
48151 {
48152 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
48153 }
48154 {
48155 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
48156 }
48157 {
48158 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
48159 }
48160 {
48161 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
48162 }
48163 {
48164 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
48165 }
48166 {
48167 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
48168 }
48169 {
48170 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
48171 }
48172 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
48173 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
48174 {
48175 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
48176 }
48177 {
48178 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
48179 }
48180 {
48181 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
48182 }
48183 {
48184 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
48185 }
48186 {
48187 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
48188 }
48189 {
48190 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
48191 }
48192 {
48193 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
48194 }
48195 {
48196 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
48197 }
48198 {
48199 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
48200 }
48201 {
48202 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
48203 }
48204 {
48205 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
48206 }
48207 {
48208 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
48209 }
48210 {
48211 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
48212 }
48213 {
48214 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
48215 }
48216 {
48217 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
48218 }
48219 {
48220 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
48221 }
48222 {
48223 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
48224 }
48225 {
48226 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
48227 }
48228 {
48229 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
48230 }
48231 {
48232 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
48233 }
48234 {
48235 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
48236 }
48237 {
48238 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
48239 }
48240 {
48241 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
48242 }
48243 {
48244 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
48245 }
48246 {
48247 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
48248 }
48249 {
48250 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
48251 }
48252 {
48253 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
48254 }
48255 {
48256 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
48257 }
48258 {
48259 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
48260 }
48261 {
48262 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
48263 }
48264 {
48265 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
48266 }
48267 {
48268 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
48269 }
48270 {
48271 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
48272 }
48273 {
48274 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
48275 }
48276 {
48277 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
48278 }
48279 {
48280 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
48281 }
48282 {
48283 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
48284 }
48285 {
48286 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
48287 }
48288 {
48289 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
48290 }
48291 {
48292 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
48293 }
48294 {
48295 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
48296 }
48297 {
48298 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
48299 }
48300 {
48301 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
48302 }
48303 {
48304 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
48305 }
48306 {
48307 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
48308 }
48309 {
48310 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
48311 }
48312 {
48313 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
48314 }
48315 {
48316 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
48317 }
48318 {
48319 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
48320 }
48321 {
48322 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
48323 }
48324 {
48325 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
48326 }
48327 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
48328 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
48329 {
48330 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
48331 }
48332 {
48333 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
48334 }
48335 {
48336 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
48337 }
48338
48339 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
48340
48341
48342 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
48343
48344 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
48345 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
48346 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
48347 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
48348 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
48349 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
48350 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
48351 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
48352 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
48353 {
48354 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
48355 }
48356 {
48357 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
48358 }
48359 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
48360 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
48361 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
48362 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
48363 {
48364 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
48365 }
48366 {
48367 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
48368 }
48369 {
48370 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
48371 }
48372 {
48373 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
48374 }
48375 {
48376 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
48377 }
48378 {
48379 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
48380 }
48381 {
48382 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
48383 }
48384 {
48385 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
48386 }
48387 {
48388 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
48389 }
48390 {
48391 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
48392 }
48393 {
48394 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
48395 }
48396 {
48397 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
48398 }
48399 {
48400 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
48401 }
48402 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
48403 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
48404 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
48405 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
48406 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
48407 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
48408 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
48409 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
48410 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
48411 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
48412 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
48413 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
48414 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
48415 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
48416 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
48417 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
48418 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
48419 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
48420 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
48421 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
48422 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
48423 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
48424 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
48425 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
48426 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
48427 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
48428 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
48429 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
48430 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
48431 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
48432 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
48433 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
48434 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
48435 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
48436 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
48437 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
48438 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
48439 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
48440 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
48441 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
48442 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
48443 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
48444 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
48445 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
48446 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
48447 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
48448 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
48449 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
48450 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
48451 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
48452 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
48453 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
48454 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
48455 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
48456 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
48457 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
48458 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
48459 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
48460 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
48461 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
48462 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
48463 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
48464 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
48465 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
48466 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
48467 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
48468 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
48469 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
48470 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
48471 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
48472 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
48473 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
48474 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
48475 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
48476 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
48477 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
48478 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
48479 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
48480 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
48481 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
48482 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
48483 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
48484 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
48485 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
48486 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
48487 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
48488 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
48489 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
48490 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
48491 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
48492 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
48493 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
48494 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
48495 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
48496 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
48497 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
48498 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
48499 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
48500 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
48501 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
48502 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
48503 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
48504 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
48505 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
48506 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
48507 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
48508 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
48509 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
48510 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
48511 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
48512 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
48513 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
48514 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
48515 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
48516 {
48517 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
48518 }
48519 {
48520 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
48521 }
48522 {
48523 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
48524 }
48525 {
48526 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
48527 }
48528 {
48529 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
48530 }
48531 {
48532 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
48533 }
48534 {
48535 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
48536 }
48537 {
48538 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
48539 }
48540 {
48541 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
48542 }
48543 {
48544 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
48545 }
48546 {
48547 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
48548 }
48549 {
48550 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
48551 }
48552 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
48553 {
48554 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
48555 }
48556 {
48557 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
48558 }
48559 {
48560 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
48561 }
48562 {
48563 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
48564 }
48565 {
48566 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
48567 }
48568 {
48569 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
48570 }
48571 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
48572 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
48573 {
48574 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
48575 }
48576 {
48577 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
48578 }
48579 {
48580 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
48581 }
48582 {
48583 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
48584 }
48585 {
48586 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
48587 }
48588 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
48589 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
48590 {
48591 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
48592 }
48593 {
48594 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
48595 }
48596 {
48597 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
48598 }
48599 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
48600 {
48601 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
48602 }
48603 {
48604 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
48605 }
48606 {
48607 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
48608 }
48609 {
48610 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
48611 }
48612 {
48613 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
48614 }
48615 {
48616 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
48617 }
48618 {
48619 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
48620 }
48621 {
48622 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
48623 }
48624 {
48625 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
48626 }
48627 {
48628 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
48629 }
48630 {
48631 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
48632 }
48633 {
48634 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
48635 }
48636 {
48637 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
48638 }
48639 {
48640 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
48641 }
48642 {
48643 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
48644 }
48645 {
48646 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
48647 }
48648 {
48649 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
48650 }
48651 {
48652 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
48653 }
48654 {
48655 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
48656 }
48657
48658 // Initialize threading, some globals and such
48659 __wxPyPreStart(d);
48660
48661
48662 // Although these are defined in __version__ they need to be here too so
48663 // that an assert can be done to ensure that the wxPython and the wxWindows
48664 // versions match.
48665 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
48666 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
48667 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
48668
48669 }
48670
wxWidgets (Impactor)