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


772e9668dae58ab91c159c80df920b489adbd2a3
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 if (str)
1041 Py_DECREF(str);
1042 return;
1043 }
1044 }
1045 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1046 } else {
1047 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1048 }
1049 }
1050
1051 SWIGRUNTIMEINLINE void
1052 SWIG_Python_NullRef(const char *type)
1053 {
1054 if (type) {
1055 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1056 } else {
1057 PyErr_Format(PyExc_TypeError, "null reference was received");
1058 }
1059 }
1060
1061 SWIGRUNTIME int
1062 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1063 {
1064 if (PyErr_Occurred()) {
1065 PyObject *type = 0;
1066 PyObject *value = 0;
1067 PyObject *traceback = 0;
1068 PyErr_Fetch(&type, &value, &traceback);
1069 if (value) {
1070 PyObject *old_str = PyObject_Str(value);
1071 Py_XINCREF(type);
1072 PyErr_Clear();
1073 if (infront) {
1074 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1075 } else {
1076 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1077 }
1078 Py_DECREF(old_str);
1079 }
1080 return 1;
1081 } else {
1082 return 0;
1083 }
1084 }
1085
1086 SWIGRUNTIME int
1087 SWIG_Python_ArgFail(int argnum)
1088 {
1089 if (PyErr_Occurred()) {
1090 /* add information about failing argument */
1091 char mesg[256];
1092 sprintf(mesg, "argument number %d:", argnum);
1093 return SWIG_Python_AddErrMesg(mesg, 1);
1094 } else {
1095 return 0;
1096 }
1097 }
1098
1099
1100 /* -----------------------------------------------------------------------------
1101 * pointers/data manipulation
1102 * ----------------------------------------------------------------------------- */
1103
1104 /* Convert a pointer value */
1105 SWIGRUNTIME int
1106 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1107 swig_type_info *tc;
1108 const char *c = 0;
1109 static PyObject *SWIG_this = 0;
1110 int newref = 0;
1111 PyObject *pyobj = 0;
1112 void *vptr;
1113
1114 if (!obj) return 0;
1115 if (obj == Py_None) {
1116 *ptr = 0;
1117 return 0;
1118 }
1119
1120 #ifdef SWIG_COBJECT_TYPES
1121 if (!(PySwigObject_Check(obj))) {
1122 if (!SWIG_this)
1123 SWIG_this = PyString_FromString("this");
1124 pyobj = obj;
1125 obj = PyObject_GetAttr(obj,SWIG_this);
1126 newref = 1;
1127 if (!obj) goto type_error;
1128 if (!PySwigObject_Check(obj)) {
1129 Py_DECREF(obj);
1130 goto type_error;
1131 }
1132 }
1133 vptr = PySwigObject_AsVoidPtr(obj);
1134 c = (const char *) PySwigObject_GetDesc(obj);
1135 if (newref) { Py_DECREF(obj); }
1136 goto type_check;
1137 #else
1138 if (!(PyString_Check(obj))) {
1139 if (!SWIG_this)
1140 SWIG_this = PyString_FromString("this");
1141 pyobj = obj;
1142 obj = PyObject_GetAttr(obj,SWIG_this);
1143 newref = 1;
1144 if (!obj) goto type_error;
1145 if (!PyString_Check(obj)) {
1146 Py_DECREF(obj);
1147 goto type_error;
1148 }
1149 }
1150 c = PyString_AS_STRING(obj);
1151 /* Pointer values must start with leading underscore */
1152 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1153 if (newref) { Py_DECREF(obj); }
1154 if (!c) goto type_error;
1155 #endif
1156
1157 type_check:
1158
1159 if (ty) {
1160 tc = SWIG_TypeCheck(c,ty);
1161 if (!tc) goto type_error;
1162 *ptr = SWIG_TypeCast(tc,vptr);
1163 } else {
1164 *ptr = vptr;
1165 }
1166
1167 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1168 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1169 }
1170 return 0;
1171
1172 type_error:
1173 PyErr_Clear();
1174 if (pyobj && !obj) {
1175 obj = pyobj;
1176 if (PyCFunction_Check(obj)) {
1177 /* here we get the method pointer for callbacks */
1178 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1179 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1180 if (c) {
1181 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1182 if (!c) goto type_error;
1183 goto type_check;
1184 }
1185 }
1186 }
1187 if (flags & SWIG_POINTER_EXCEPTION) {
1188 if (ty) {
1189 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1190 } else {
1191 SWIG_Python_TypeError("C/C++ pointer", obj);
1192 }
1193 }
1194 return -1;
1195 }
1196
1197 /* Convert a pointer value, signal an exception on a type mismatch */
1198 SWIGRUNTIME void *
1199 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1200 void *result;
1201 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1202 PyErr_Clear();
1203 if (flags & SWIG_POINTER_EXCEPTION) {
1204 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1205 SWIG_Python_ArgFail(argnum);
1206 }
1207 }
1208 return result;
1209 }
1210
1211 /* Convert a packed value value */
1212 SWIGRUNTIME int
1213 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1214 swig_type_info *tc;
1215 const char *c = 0;
1216
1217 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1218 c = PySwigPacked_UnpackData(obj, ptr, sz);
1219 #else
1220 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1221 c = PyString_AS_STRING(obj);
1222 /* Pointer values must start with leading underscore */
1223 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1224 #endif
1225 if (!c) goto type_error;
1226 if (ty) {
1227 tc = SWIG_TypeCheck(c,ty);
1228 if (!tc) goto type_error;
1229 }
1230 return 0;
1231
1232 type_error:
1233 PyErr_Clear();
1234 if (flags & SWIG_POINTER_EXCEPTION) {
1235 if (ty) {
1236 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1237 } else {
1238 SWIG_Python_TypeError("C/C++ packed data", obj);
1239 }
1240 }
1241 return -1;
1242 }
1243
1244 /* Create a new array object */
1245 SWIGRUNTIME PyObject *
1246 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1247 PyObject *robj = 0;
1248 if (!ptr) {
1249 Py_INCREF(Py_None);
1250 return Py_None;
1251 }
1252 #ifdef SWIG_COBJECT_TYPES
1253 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1254 #else
1255 {
1256 char result[SWIG_BUFFER_SIZE];
1257 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1258 PyString_FromString(result) : 0;
1259 }
1260 #endif
1261 if (!robj || (robj == Py_None)) return robj;
1262 if (type->clientdata) {
1263 PyObject *inst;
1264 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1265 Py_DECREF(robj);
1266 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1267 Py_DECREF(args);
1268 if (inst) {
1269 if (own) {
1270 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1271 }
1272 robj = inst;
1273 }
1274 }
1275 return robj;
1276 }
1277
1278 SWIGRUNTIME PyObject *
1279 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1280 PyObject *robj = 0;
1281 if (!ptr) {
1282 Py_INCREF(Py_None);
1283 return Py_None;
1284 }
1285 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1286 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1287 #else
1288 {
1289 char result[SWIG_BUFFER_SIZE];
1290 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1291 PyString_FromString(result) : 0;
1292 }
1293 #endif
1294 return robj;
1295 }
1296
1297 /* -----------------------------------------------------------------------------*
1298 * Get type list
1299 * -----------------------------------------------------------------------------*/
1300
1301 #ifdef SWIG_LINK_RUNTIME
1302 void *SWIG_ReturnGlobalTypeList(void *);
1303 #endif
1304
1305 SWIGRUNTIME swig_type_info **
1306 SWIG_Python_GetTypeListHandle() {
1307 static void *type_pointer = (void *)0;
1308 /* first check if module already created */
1309 if (!type_pointer) {
1310 #ifdef SWIG_LINK_RUNTIME
1311 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1312 #else
1313 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1314 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1315 if (PyErr_Occurred()) {
1316 PyErr_Clear();
1317 type_pointer = (void *)0;
1318 }
1319 }
1320 #endif
1321 return (swig_type_info **) type_pointer;
1322 }
1323
1324 /*
1325 Search for a swig_type_info structure
1326 */
1327 SWIGRUNTIMEINLINE swig_type_info *
1328 SWIG_Python_GetTypeList() {
1329 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1330 return tlh ? *tlh : (swig_type_info*)0;
1331 }
1332
1333 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1334
1335 #ifdef __cplusplus
1336 }
1337 #endif
1338
1339
1340 /* -------- TYPES TABLE (BEGIN) -------- */
1341
1342 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1343 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1344 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1345 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1346 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1347 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1348 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1349 #define SWIGTYPE_p_wxSizer swig_types[7]
1350 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1351 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1352 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1353 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1354 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1355 #define SWIGTYPE_p_wxEvent swig_types[13]
1356 #define SWIGTYPE_p_buffer swig_types[14]
1357 #define SWIGTYPE_p_wxMenu swig_types[15]
1358 #define SWIGTYPE_p_wxGridSizer swig_types[16]
1359 #define SWIGTYPE_p_wxFlexGridSizer swig_types[17]
1360 #define SWIGTYPE_p_wxInitDialogEvent swig_types[18]
1361 #define SWIGTYPE_p_wxItemContainer swig_types[19]
1362 #define SWIGTYPE_p_wxNcPaintEvent swig_types[20]
1363 #define SWIGTYPE_p_wxPaintEvent swig_types[21]
1364 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[22]
1365 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[23]
1366 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[24]
1367 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[25]
1368 #define SWIGTYPE_p_wxControl swig_types[26]
1369 #define SWIGTYPE_p_wxFont swig_types[27]
1370 #define SWIGTYPE_p_wxMenuBarBase swig_types[28]
1371 #define SWIGTYPE_p_wxSetCursorEvent swig_types[29]
1372 #define SWIGTYPE_p_wxFSFile swig_types[30]
1373 #define SWIGTYPE_p_wxCaret swig_types[31]
1374 #define SWIGTYPE_ptrdiff_t swig_types[32]
1375 #define SWIGTYPE_std__ptrdiff_t swig_types[33]
1376 #define SWIGTYPE_p_wxRegion swig_types[34]
1377 #define SWIGTYPE_p_wxPoint2D swig_types[35]
1378 #define SWIGTYPE_p_wxImage_HSVValue swig_types[36]
1379 #define SWIGTYPE_p_int swig_types[37]
1380 #define SWIGTYPE_p_wxSize swig_types[38]
1381 #define SWIGTYPE_p_wxDC swig_types[39]
1382 #define SWIGTYPE_p_wxPySizer swig_types[40]
1383 #define SWIGTYPE_p_wxVisualAttributes swig_types[41]
1384 #define SWIGTYPE_p_wxImage_RGBValue swig_types[42]
1385 #define SWIGTYPE_p_wxNotifyEvent swig_types[43]
1386 #define SWIGTYPE_p_wxPyEvent swig_types[44]
1387 #define SWIGTYPE_p_wxPropagationDisabler swig_types[45]
1388 #define SWIGTYPE_p_form_ops_t swig_types[46]
1389 #define SWIGTYPE_p_wxAppTraits swig_types[47]
1390 #define SWIGTYPE_p_wxArrayString swig_types[48]
1391 #define SWIGTYPE_p_wxShowEvent swig_types[49]
1392 #define SWIGTYPE_p_wxToolTip swig_types[50]
1393 #define SWIGTYPE_p_wxMoveEvent swig_types[51]
1394 #define SWIGTYPE_p_wxSizeEvent swig_types[52]
1395 #define SWIGTYPE_p_wxActivateEvent swig_types[53]
1396 #define SWIGTYPE_p_wxIconizeEvent swig_types[54]
1397 #define SWIGTYPE_p_wxMaximizeEvent swig_types[55]
1398 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[56]
1399 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[57]
1400 #define SWIGTYPE_p_wxIdleEvent swig_types[58]
1401 #define SWIGTYPE_p_wxDateEvent swig_types[59]
1402 #define SWIGTYPE_p_wxMenuItem swig_types[60]
1403 #define SWIGTYPE_p_wxStaticBox swig_types[61]
1404 #define SWIGTYPE_p_long swig_types[62]
1405 #define SWIGTYPE_p_wxDuplexMode swig_types[63]
1406 #define SWIGTYPE_p_wxTIFFHandler swig_types[64]
1407 #define SWIGTYPE_p_wxXPMHandler swig_types[65]
1408 #define SWIGTYPE_p_wxPNMHandler swig_types[66]
1409 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
1410 #define SWIGTYPE_p_wxPCXHandler swig_types[68]
1411 #define SWIGTYPE_p_wxGIFHandler swig_types[69]
1412 #define SWIGTYPE_p_wxPNGHandler swig_types[70]
1413 #define SWIGTYPE_p_wxANIHandler swig_types[71]
1414 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[72]
1415 #define SWIGTYPE_p_wxZipFSHandler swig_types[73]
1416 #define SWIGTYPE_p_wxInternetFSHandler swig_types[74]
1417 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[75]
1418 #define SWIGTYPE_p_wxEvtHandler swig_types[76]
1419 #define SWIGTYPE_p_wxCURHandler swig_types[77]
1420 #define SWIGTYPE_p_wxICOHandler swig_types[78]
1421 #define SWIGTYPE_p_wxBMPHandler swig_types[79]
1422 #define SWIGTYPE_p_wxImageHandler swig_types[80]
1423 #define SWIGTYPE_p_wxFileSystemHandler swig_types[81]
1424 #define SWIGTYPE_p_wxRect swig_types[82]
1425 #define SWIGTYPE_p_wxButton swig_types[83]
1426 #define SWIGTYPE_p_wxGBSpan swig_types[84]
1427 #define SWIGTYPE_p_wxPropagateOnce swig_types[85]
1428 #define SWIGTYPE_p_wxAcceleratorTable swig_types[86]
1429 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[87]
1430 #define SWIGTYPE_p_char swig_types[88]
1431 #define SWIGTYPE_p_wxGBPosition swig_types[89]
1432 #define SWIGTYPE_p_wxImage swig_types[90]
1433 #define SWIGTYPE_p_wxFrame swig_types[91]
1434 #define SWIGTYPE_p_wxScrollWinEvent swig_types[92]
1435 #define SWIGTYPE_p_wxPaperSize swig_types[93]
1436 #define SWIGTYPE_p_wxImageHistogram swig_types[94]
1437 #define SWIGTYPE_p_wxPoint swig_types[95]
1438 #define SWIGTYPE_p_wxCursor swig_types[96]
1439 #define SWIGTYPE_p_wxObject swig_types[97]
1440 #define SWIGTYPE_p_wxInputStream swig_types[98]
1441 #define SWIGTYPE_p_wxOutputStream swig_types[99]
1442 #define SWIGTYPE_p_wxPyInputStream swig_types[100]
1443 #define SWIGTYPE_p_wxDateTime swig_types[101]
1444 #define SWIGTYPE_p_wxKeyEvent swig_types[102]
1445 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[103]
1446 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[104]
1447 #define SWIGTYPE_p_unsigned_long swig_types[105]
1448 #define SWIGTYPE_p_wxWindow swig_types[106]
1449 #define SWIGTYPE_p_wxMenuBar swig_types[107]
1450 #define SWIGTYPE_p_wxFileSystem swig_types[108]
1451 #define SWIGTYPE_p_wxBitmap swig_types[109]
1452 #define SWIGTYPE_unsigned_int swig_types[110]
1453 #define SWIGTYPE_p_unsigned_int swig_types[111]
1454 #define SWIGTYPE_p_wxMenuEvent swig_types[112]
1455 #define SWIGTYPE_p_wxContextMenuEvent swig_types[113]
1456 #define SWIGTYPE_p_unsigned_char swig_types[114]
1457 #define SWIGTYPE_p_wxMouseEvent swig_types[115]
1458 #define SWIGTYPE_p_wxEraseEvent swig_types[116]
1459 #define SWIGTYPE_p_wxCloseEvent swig_types[117]
1460 #define SWIGTYPE_p_wxPyApp swig_types[118]
1461 #define SWIGTYPE_p_wxCommandEvent swig_types[119]
1462 #define SWIGTYPE_p_wxPyCommandEvent swig_types[120]
1463 #define SWIGTYPE_p_wxPyDropTarget swig_types[121]
1464 #define SWIGTYPE_p_wxQuantize swig_types[122]
1465 #define SWIGTYPE_p_wxFocusEvent swig_types[123]
1466 #define SWIGTYPE_p_wxChildFocusEvent swig_types[124]
1467 #define SWIGTYPE_p_wxDropFilesEvent swig_types[125]
1468 #define SWIGTYPE_p_wxControlWithItems swig_types[126]
1469 #define SWIGTYPE_p_wxColour swig_types[127]
1470 #define SWIGTYPE_p_wxValidator swig_types[128]
1471 #define SWIGTYPE_p_wxPyValidator swig_types[129]
1472 static swig_type_info *swig_types[131];
1473
1474 /* -------- TYPES TABLE (END) -------- */
1475
1476
1477 /*-----------------------------------------------
1478 @(target):= _core_.so
1479 ------------------------------------------------*/
1480 #define SWIG_init init_core_
1481
1482 #define SWIG_name "_core_"
1483
1484 #include "wx/wxPython/wxPython_int.h"
1485 #include "wx/wxPython/pyclasses.h"
1486
1487
1488 #ifndef wxPyUSE_EXPORT
1489 // Helper functions for dealing with SWIG objects and such. These are
1490 // located here so they know about the SWIG types and functions declared
1491 // in the wrapper code.
1492
1493 #include <wx/hashmap.h>
1494 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1495
1496
1497 // Maintains a hashmap of className to swig_type_info pointers. Given the
1498 // name of a class either looks up the type info in the cache, or scans the
1499 // SWIG tables for it.
1500 extern PyObject* wxPyPtrTypeMap;
1501 static
1502 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1503
1504 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1505
1506 if (typeInfoCache == NULL)
1507 typeInfoCache = new wxPyTypeInfoHashMap;
1508
1509 wxString name(className);
1510 swig_type_info* swigType = (*typeInfoCache)[name];
1511
1512 if (! swigType) {
1513 // it wasn't in the cache, so look it up from SWIG
1514 name.Append(wxT(" *"));
1515 swigType = SWIG_TypeQuery(name.mb_str());
1516
1517 // if it still wasn't found, try looking for a mapped name
1518 if (!swigType) {
1519 PyObject* item;
1520 name = className;
1521
1522 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1523 (char*)(const char*)name.mbc_str())) != NULL) {
1524 name = wxString(PyString_AsString(item), *wxConvCurrent);
1525 name.Append(wxT(" *"));
1526 swigType = SWIG_TypeQuery(name.mb_str());
1527 }
1528 }
1529 if (swigType) {
1530 // and add it to the map if found
1531 (*typeInfoCache)[className] = swigType;
1532 }
1533 }
1534 return swigType;
1535 }
1536
1537
1538 // Check if a class name is a type known to SWIG
1539 bool wxPyCheckSwigType(const wxChar* className) {
1540
1541 swig_type_info* swigType = wxPyFindSwigType(className);
1542 return swigType != NULL;
1543 }
1544
1545
1546 // Given a pointer to a C++ object and a class name, construct a Python proxy
1547 // object for it.
1548 PyObject* wxPyConstructObject(void* ptr,
1549 const wxChar* className,
1550 int setThisOwn) {
1551
1552 swig_type_info* swigType = wxPyFindSwigType(className);
1553 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1554
1555 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1556 }
1557
1558
1559 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1560 // Ensures that the proxy object is of the specified (or derived) type. If
1561 // not able to perform the conversion then a Python exception is set and the
1562 // error should be handled properly in the caller. Returns True on success.
1563 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1564 const wxChar* className) {
1565
1566 swig_type_info* swigType = wxPyFindSwigType(className);
1567 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1568
1569 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1570 }
1571
1572
1573 // Make a SWIGified pointer object suitable for a .this attribute
1574 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1575
1576 PyObject* robj = NULL;
1577
1578 swig_type_info* swigType = wxPyFindSwigType(className);
1579 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1580
1581 #ifdef SWIG_COBJECT_TYPES
1582 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1583 #else
1584 {
1585 char result[1024];
1586 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1587 PyString_FromString(result) : 0;
1588 }
1589 #endif
1590
1591 return robj;
1592 }
1593
1594
1595
1596
1597 // Export a C API in a struct. Other modules will be able to load this from
1598 // the wx._core_ module and will then have safe access to these functions,
1599 // even if they are located in another shared library.
1600 static wxPyCoreAPI API = {
1601
1602 wxPyCheckSwigType,
1603 wxPyConstructObject,
1604 wxPyConvertSwigPtr,
1605 wxPyMakeSwigPtr,
1606
1607 wxPyBeginAllowThreads,
1608 wxPyEndAllowThreads,
1609 wxPyBeginBlockThreads,
1610 wxPyEndBlockThreads,
1611
1612 wxPy_ConvertList,
1613
1614 wxString_in_helper,
1615 Py2wxString,
1616 wx2PyString,
1617
1618 byte_LIST_helper,
1619 int_LIST_helper,
1620 long_LIST_helper,
1621 string_LIST_helper,
1622 wxPoint_LIST_helper,
1623 wxBitmap_LIST_helper,
1624 wxString_LIST_helper,
1625 wxAcceleratorEntry_LIST_helper,
1626
1627 wxSize_helper,
1628 wxPoint_helper,
1629 wxRealPoint_helper,
1630 wxRect_helper,
1631 wxColour_helper,
1632 wxPoint2D_helper,
1633
1634 wxPySimple_typecheck,
1635 wxColour_typecheck,
1636
1637 wxPyCBH_setCallbackInfo,
1638 wxPyCBH_findCallback,
1639 wxPyCBH_callCallback,
1640 wxPyCBH_callCallbackObj,
1641 wxPyCBH_delete,
1642
1643 wxPyMake_wxObject,
1644 wxPyMake_wxSizer,
1645 wxPyPtrTypeMap_Add,
1646 wxPy2int_seq_helper,
1647 wxPy4int_seq_helper,
1648 wxArrayString2PyList_helper,
1649 wxArrayInt2PyList_helper,
1650
1651 wxPyClientData_dtor,
1652 wxPyUserData_dtor,
1653 wxPyOORClientData_dtor,
1654
1655 wxPyCBInputStream_create,
1656 wxPyCBInputStream_copy,
1657
1658 wxPyInstance_Check,
1659 wxPySwigInstance_Check,
1660
1661 wxPyCheckForApp
1662
1663 };
1664
1665 #endif
1666
1667
1668 #if !WXWIN_COMPATIBILITY_2_4
1669 #define wxHIDE_READONLY 0
1670 #endif
1671
1672
1673 /*@C:\\SWIG-1.3.24\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1674 #define SWIG_From_int PyInt_FromLong
1675 /*@@*/
1676
1677
1678 #if ! wxUSE_HOTKEY
1679 enum wxHotkeyModifier
1680 {
1681 wxMOD_NONE = 0,
1682 wxMOD_ALT = 1,
1683 wxMOD_CONTROL = 2,
1684 wxMOD_SHIFT = 4,
1685 wxMOD_WIN = 8
1686 };
1687 #define wxEVT_HOTKEY 9999
1688 #endif
1689
1690 static const wxString wxPyEmptyString(wxEmptyString);
1691 static wxString wxObject_GetClassName(wxObject *self){
1692 return self->GetClassInfo()->GetClassName();
1693 }
1694 static void wxObject_Destroy(wxObject *self){
1695 delete self;
1696 }
1697
1698 #ifndef __WXMAC__
1699 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1700 #endif
1701
1702
1703 #include <limits.h>
1704
1705
1706 SWIGINTERN int
1707 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1708 const char *errmsg)
1709 {
1710 if (value < min_value) {
1711 if (errmsg) {
1712 PyErr_Format(PyExc_OverflowError,
1713 "value %ld is less than '%s' minimum %ld",
1714 value, errmsg, min_value);
1715 }
1716 return 0;
1717 } else if (value > max_value) {
1718 if (errmsg) {
1719 PyErr_Format(PyExc_OverflowError,
1720 "value %ld is greater than '%s' maximum %ld",
1721 value, errmsg, max_value);
1722 }
1723 return 0;
1724 }
1725 return 1;
1726 }
1727
1728
1729 SWIGINTERN int
1730 SWIG_AsVal_long(PyObject* obj, long* val)
1731 {
1732 if (PyNumber_Check(obj)) {
1733 if (val) *val = PyInt_AsLong(obj);
1734 return 1;
1735 }
1736 else {
1737 SWIG_type_error("number", obj);
1738 }
1739 return 0;
1740 }
1741
1742
1743 #if INT_MAX != LONG_MAX
1744 SWIGINTERN int
1745 SWIG_AsVal_int(PyObject *obj, int *val)
1746 {
1747 const char* errmsg = val ? "int" : (char*)0;
1748 long v;
1749 if (SWIG_AsVal_long(obj, &v)) {
1750 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1751 if (val) *val = (int)(v);
1752 return 1;
1753 } else {
1754 return 0;
1755 }
1756 } else {
1757 PyErr_Clear();
1758 }
1759 if (val) {
1760 SWIG_type_error(errmsg, obj);
1761 }
1762 return 0;
1763 }
1764 #else
1765 SWIGINTERNSHORT int
1766 SWIG_AsVal_int(PyObject *obj, int *val)
1767 {
1768 return SWIG_AsVal_long(obj,(long*)val);
1769 }
1770 #endif
1771
1772
1773 SWIGINTERNSHORT int
1774 SWIG_As_int(PyObject* obj)
1775 {
1776 int v;
1777 if (!SWIG_AsVal_int(obj, &v)) {
1778 /*
1779 this is needed to make valgrind/purify happier.
1780 */
1781 memset((void*)&v, 0, sizeof(int));
1782 }
1783 return v;
1784 }
1785
1786
1787 SWIGINTERNSHORT int
1788 SWIG_Check_int(PyObject* obj)
1789 {
1790 return SWIG_AsVal_int(obj, (int*)0);
1791 }
1792
1793 static PyObject *wxSize_Get(wxSize *self){
1794 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1795 PyObject* tup = PyTuple_New(2);
1796 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1797 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1798 wxPyEndBlockThreads(blocked);
1799 return tup;
1800 }
1801
1802 SWIGINTERN int
1803 SWIG_AsVal_double(PyObject *obj, double* val)
1804 {
1805 if (PyNumber_Check(obj)) {
1806 if (val) *val = PyFloat_AsDouble(obj);
1807 return 1;
1808 }
1809 else {
1810 SWIG_type_error("number", obj);
1811 }
1812 return 0;
1813 }
1814
1815
1816 SWIGINTERNSHORT double
1817 SWIG_As_double(PyObject* obj)
1818 {
1819 double v;
1820 if (!SWIG_AsVal_double(obj, &v)) {
1821 /*
1822 this is needed to make valgrind/purify happier.
1823 */
1824 memset((void*)&v, 0, sizeof(double));
1825 }
1826 return v;
1827 }
1828
1829
1830 SWIGINTERNSHORT int
1831 SWIG_Check_double(PyObject* obj)
1832 {
1833 return SWIG_AsVal_double(obj, (double*)0);
1834 }
1835
1836
1837 /*@C:\\SWIG-1.3.24\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
1838 #define SWIG_From_double PyFloat_FromDouble
1839 /*@@*/
1840
1841 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1842 self->x = x;
1843 self->y = y;
1844 }
1845 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1846 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1847 PyObject* tup = PyTuple_New(2);
1848 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1849 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1850 wxPyEndBlockThreads(blocked);
1851 return tup;
1852 }
1853
1854 SWIGINTERNSHORT long
1855 SWIG_As_long(PyObject* obj)
1856 {
1857 long v;
1858 if (!SWIG_AsVal_long(obj, &v)) {
1859 /*
1860 this is needed to make valgrind/purify happier.
1861 */
1862 memset((void*)&v, 0, sizeof(long));
1863 }
1864 return v;
1865 }
1866
1867
1868 SWIGINTERNSHORT int
1869 SWIG_Check_long(PyObject* obj)
1870 {
1871 return SWIG_AsVal_long(obj, (long*)0);
1872 }
1873
1874 static void wxPoint_Set(wxPoint *self,long x,long y){
1875 self->x = x;
1876 self->y = y;
1877 }
1878 static PyObject *wxPoint_Get(wxPoint *self){
1879 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1880 PyObject* tup = PyTuple_New(2);
1881 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1882 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1883 wxPyEndBlockThreads(blocked);
1884 return tup;
1885 }
1886 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1887 self->x = x;
1888 self->y = y;
1889 self->width = width;
1890 self->height = height;
1891 }
1892 static PyObject *wxRect_Get(wxRect *self){
1893 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1894 PyObject* tup = PyTuple_New(4);
1895 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1896 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1897 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1898 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1899 wxPyEndBlockThreads(blocked);
1900 return tup;
1901 }
1902
1903 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1904 wxRegion reg1(*r1);
1905 wxRegion reg2(*r2);
1906 wxRect dest(0,0,0,0);
1907 PyObject* obj;
1908
1909 reg1.Intersect(reg2);
1910 dest = reg1.GetBox();
1911
1912 if (dest != wxRect(0,0,0,0)) {
1913 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1914 wxRect* newRect = new wxRect(dest);
1915 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1916 wxPyEndBlockThreads(blocked);
1917 return obj;
1918 }
1919 Py_INCREF(Py_None);
1920 return Py_None;
1921 }
1922
1923
1924 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1925 PyObject* o2;
1926 PyObject* o3;
1927
1928 if (!target) {
1929 target = o;
1930 } else if (target == Py_None) {
1931 Py_DECREF(Py_None);
1932 target = o;
1933 } else {
1934 if (!PyTuple_Check(target)) {
1935 o2 = target;
1936 target = PyTuple_New(1);
1937 PyTuple_SetItem(target, 0, o2);
1938 }
1939 o3 = PyTuple_New(1);
1940 PyTuple_SetItem(o3, 0, o);
1941
1942 o2 = target;
1943 target = PySequence_Concat(o2, o3);
1944 Py_DECREF(o2);
1945 Py_DECREF(o3);
1946 }
1947 return target;
1948 }
1949
1950
1951 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1952 self->m_x = x;
1953 self->m_y = y;
1954 }
1955 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1956 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1957 PyObject* tup = PyTuple_New(2);
1958 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1959 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1960 wxPyEndBlockThreads(blocked);
1961 return tup;
1962 }
1963
1964 #include "wx/wxPython/pyistream.h"
1965
1966 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1967 wxInputStream* wxis = wxPyCBInputStream::create(p);
1968 if (wxis)
1969 return new wxPyInputStream(wxis);
1970 else
1971 return NULL;
1972 }
1973
1974 SWIGINTERNSHORT PyObject*
1975 SWIG_From_char(char c)
1976 {
1977 return PyString_FromStringAndSize(&c,1);
1978 }
1979
1980
1981 SWIGINTERNSHORT PyObject*
1982 SWIG_From_unsigned_SS_long(unsigned long value)
1983 {
1984 return (value > LONG_MAX) ?
1985 PyLong_FromUnsignedLong(value)
1986 : PyInt_FromLong((long)(value));
1987 }
1988
1989
1990 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1991 SWIGINTERN int
1992 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1993 {
1994 static swig_type_info* pchar_info = 0;
1995 char* vptr = 0;
1996 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1997 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1998 if (cptr) *cptr = vptr;
1999 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
2000 return SWIG_OLDOBJ;
2001 } else {
2002 PyErr_Clear();
2003 if (PyString_Check(obj)) {
2004 if (cptr) {
2005 *cptr = PyString_AS_STRING(obj);
2006 if (psize) {
2007 *psize = PyString_GET_SIZE(obj) + 1;
2008 }
2009 }
2010 return SWIG_PYSTR;
2011 }
2012 }
2013 if (cptr) {
2014 SWIG_type_error("char *", obj);
2015 }
2016 return 0;
2017 }
2018
2019
2020 SWIGINTERN int
2021 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2022 {
2023 char* cptr; size_t csize;
2024 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2025 /* in C you can do:
2026
2027 char x[5] = "hello";
2028
2029 ie, assing the array using an extra '0' char.
2030 */
2031 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2032 if (csize <= size) {
2033 if (val) {
2034 if (csize) memcpy(val, cptr, csize);
2035 if (csize < size) memset(val + csize, 0, size - csize);
2036 }
2037 return 1;
2038 }
2039 }
2040 if (val) {
2041 PyErr_Format(PyExc_TypeError,
2042 "a char array of maximum size %lu is expected",
2043 (unsigned long) size);
2044 }
2045 return 0;
2046 }
2047
2048
2049 SWIGINTERN int
2050 SWIG_AsVal_char(PyObject *obj, char *val)
2051 {
2052 const char* errmsg = val ? "char" : (char*)0;
2053 long v;
2054 if (SWIG_AsVal_long(obj, &v)) {
2055 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2056 if (val) *val = (char)(v);
2057 return 1;
2058 } else {
2059 return 0;
2060 }
2061 } else {
2062 PyErr_Clear();
2063 return SWIG_AsCharArray(obj, val, 1);
2064 }
2065 }
2066
2067
2068 SWIGINTERNSHORT char
2069 SWIG_As_char(PyObject* obj)
2070 {
2071 char v;
2072 if (!SWIG_AsVal_char(obj, &v)) {
2073 /*
2074 this is needed to make valgrind/purify happier.
2075 */
2076 memset((void*)&v, 0, sizeof(char));
2077 }
2078 return v;
2079 }
2080
2081
2082 SWIGINTERNSHORT int
2083 SWIG_Check_char(PyObject* obj)
2084 {
2085 return SWIG_AsVal_char(obj, (char*)0);
2086 }
2087
2088
2089 /*@C:\\SWIG-1.3.24\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2090 #define SWIG_From_long PyInt_FromLong
2091 /*@@*/
2092
2093 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2094 // We use only strings for the streams, not unicode
2095 PyObject* str = PyObject_Str(obj);
2096 if (! str) {
2097 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2098 return;
2099 }
2100 self->Write(PyString_AS_STRING(str),
2101 PyString_GET_SIZE(str));
2102 Py_DECREF(str);
2103 }
2104
2105 #include "wx/wxPython/pyistream.h"
2106
2107
2108 class wxPyFileSystemHandler : public wxFileSystemHandler
2109 {
2110 public:
2111 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2112
2113 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2114 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2115 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2116 DEC_PYCALLBACK_STRING__pure(FindNext);
2117
2118 wxString GetProtocol(const wxString& location) {
2119 return wxFileSystemHandler::GetProtocol(location);
2120 }
2121
2122 wxString GetLeftLocation(const wxString& location) {
2123 return wxFileSystemHandler::GetLeftLocation(location);
2124 }
2125
2126 wxString GetAnchor(const wxString& location) {
2127 return wxFileSystemHandler::GetAnchor(location);
2128 }
2129
2130 wxString GetRightLocation(const wxString& location) {
2131 return wxFileSystemHandler::GetRightLocation(location);
2132 }
2133
2134 wxString GetMimeTypeFromExt(const wxString& location) {
2135 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2136 }
2137
2138 PYPRIVATE;
2139 };
2140
2141
2142 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2143 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2144 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2145 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2146
2147
2148 SWIGINTERN int
2149 SWIG_AsVal_bool(PyObject *obj, bool *val)
2150 {
2151 if (obj == Py_True) {
2152 if (val) *val = true;
2153 return 1;
2154 }
2155 if (obj == Py_False) {
2156 if (val) *val = false;
2157 return 1;
2158 }
2159 int res = 0;
2160 if (SWIG_AsVal_int(obj, &res)) {
2161 if (val) *val = res ? true : false;
2162 return 1;
2163 } else {
2164 PyErr_Clear();
2165 }
2166 if (val) {
2167 SWIG_type_error("bool", obj);
2168 }
2169 return 0;
2170 }
2171
2172
2173 SWIGINTERNSHORT bool
2174 SWIG_As_bool(PyObject* obj)
2175 {
2176 bool v;
2177 if (!SWIG_AsVal_bool(obj, &v)) {
2178 /*
2179 this is needed to make valgrind/purify happier.
2180 */
2181 memset((void*)&v, 0, sizeof(bool));
2182 }
2183 return v;
2184 }
2185
2186
2187 SWIGINTERNSHORT int
2188 SWIG_Check_bool(PyObject* obj)
2189 {
2190 return SWIG_AsVal_bool(obj, (bool*)0);
2191 }
2192
2193 static wxString FileSystem_URLToFileName(wxString const &url){
2194 wxFileName fname = wxFileSystem::URLToFileName(url);
2195 return fname.GetFullPath();
2196 }
2197
2198 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2199 wxImage& image,
2200 long type) {
2201 wxMemoryFSHandler::AddFile(filename, image, type);
2202 }
2203
2204 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2205 const wxBitmap& bitmap,
2206 long type) {
2207 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2208 }
2209
2210 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2211 PyObject* data) {
2212 if (! PyString_Check(data)) {
2213 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2214 "Expected string object"));
2215 return;
2216 }
2217
2218 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2219 void* ptr = (void*)PyString_AsString(data);
2220 size_t size = PyString_Size(data);
2221 wxPyEndBlockThreads(blocked);
2222
2223 wxMemoryFSHandler::AddFile(filename, ptr, size);
2224 }
2225
2226
2227 #include "wx/wxPython/pyistream.h"
2228
2229
2230 SWIGINTERN int
2231 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2232 {
2233 long v = 0;
2234 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2235 SWIG_type_error("unsigned number", obj);
2236 }
2237 else if (val)
2238 *val = (unsigned long)v;
2239 return 1;
2240 }
2241
2242
2243 SWIGINTERNSHORT int
2244 SWIG_CheckUnsignedLongInRange(unsigned long value,
2245 unsigned long max_value,
2246 const char *errmsg)
2247 {
2248 if (value > max_value) {
2249 if (errmsg) {
2250 PyErr_Format(PyExc_OverflowError,
2251 "value %lu is greater than '%s' minimum %lu",
2252 value, errmsg, max_value);
2253 }
2254 return 0;
2255 }
2256 return 1;
2257 }
2258
2259
2260 SWIGINTERN int
2261 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2262 {
2263 const char* errmsg = val ? "unsigned char" : (char*)0;
2264 unsigned long v;
2265 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2266 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2267 if (val) *val = (unsigned char)(v);
2268 return 1;
2269 } else {
2270 return 0;
2271 }
2272 } else {
2273 PyErr_Clear();
2274 }
2275 if (val) {
2276 SWIG_type_error(errmsg, obj);
2277 }
2278 return 0;
2279 }
2280
2281
2282 SWIGINTERNSHORT unsigned char
2283 SWIG_As_unsigned_SS_char(PyObject* obj)
2284 {
2285 unsigned char v;
2286 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2287 /*
2288 this is needed to make valgrind/purify happier.
2289 */
2290 memset((void*)&v, 0, sizeof(unsigned char));
2291 }
2292 return v;
2293 }
2294
2295
2296 SWIGINTERNSHORT int
2297 SWIG_Check_unsigned_SS_char(PyObject* obj)
2298 {
2299 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2300 }
2301
2302
2303 /*@C:\\SWIG-1.3.24\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2304 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2305 /*@@*/
2306
2307
2308
2309 SWIGINTERNSHORT unsigned long
2310 SWIG_As_unsigned_SS_long(PyObject* obj)
2311 {
2312 unsigned long v;
2313 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2314 /*
2315 this is needed to make valgrind/purify happier.
2316 */
2317 memset((void*)&v, 0, sizeof(unsigned long));
2318 }
2319 return v;
2320 }
2321
2322
2323 SWIGINTERNSHORT int
2324 SWIG_Check_unsigned_SS_long(PyObject* obj)
2325 {
2326 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2327 }
2328
2329 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2330 wxImageHistogramEntry e = (*self)[key];
2331 return e.value;
2332 }
2333 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
2334 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2335 wxImageHistogramEntry e = (*self)[key];
2336 return e.value;
2337 }
2338 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2339 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2340 colour.Green(),
2341 colour.Blue());
2342 wxImageHistogramEntry e = (*self)[key];
2343 return e.value;
2344 }
2345
2346 typedef unsigned char* buffer;
2347
2348
2349 // Pull the nested class out to the top level for SWIG's sake
2350 #define wxImage_RGBValue wxImage::RGBValue
2351 #define wxImage_HSVValue wxImage::HSVValue
2352
2353 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2354 if (width > 0 && height > 0)
2355 return new wxImage(width, height, clear);
2356 else
2357 return new wxImage;
2358 }
2359 static wxImage *new_wxImage(wxBitmap const &bitmap){
2360 return new wxImage(bitmap.ConvertToImage());
2361 }
2362 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2363 if (DATASIZE != width*height*3) {
2364 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2365 return NULL;
2366 }
2367
2368 // Copy the source data so the wxImage can clean it up later
2369 buffer copy = (buffer)malloc(DATASIZE);
2370 if (copy == NULL) {
2371 wxPyBLOCK_THREADS(PyErr_NoMemory());
2372 return NULL;
2373 }
2374 memcpy(copy, data, DATASIZE);
2375 return new wxImage(width, height, copy, false);
2376 }
2377 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2378 if (DATASIZE != width*height*3) {
2379 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2380 return NULL;
2381 }
2382 if (ALPHASIZE != width*height) {
2383 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2384 return NULL;
2385 }
2386
2387 // Copy the source data so the wxImage can clean it up later
2388 buffer dcopy = (buffer)malloc(DATASIZE);
2389 if (dcopy == NULL) {
2390 wxPyBLOCK_THREADS(PyErr_NoMemory());
2391 return NULL;
2392 }
2393 memcpy(dcopy, data, DATASIZE);
2394
2395 buffer acopy = (buffer)malloc(ALPHASIZE);
2396 if (acopy == NULL) {
2397 wxPyBLOCK_THREADS(PyErr_NoMemory());
2398 return NULL;
2399 }
2400 memcpy(acopy, alpha, ALPHASIZE);
2401
2402 return new wxImage(width, height, dcopy, acopy, false);
2403 }
2404 static wxSize wxImage_GetSize(wxImage *self){
2405 wxSize size(self->GetWidth(), self->GetHeight());
2406 return size;
2407 }
2408 static PyObject *wxImage_GetData(wxImage *self){
2409 buffer data = self->GetData();
2410 int len = self->GetWidth() * self->GetHeight() * 3;
2411 PyObject* rv;
2412 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2413 return rv;
2414 }
2415 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2416 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2417 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2418 return;
2419 }
2420 buffer copy = (buffer)malloc(DATASIZE);
2421 if (copy == NULL) {
2422 wxPyBLOCK_THREADS(PyErr_NoMemory());
2423 return;
2424 }
2425 memcpy(copy, data, DATASIZE);
2426 self->SetData(copy, false);
2427 // wxImage takes ownership of copy...
2428 }
2429 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2430 buffer data = self->GetData();
2431 int len = self->GetWidth() * self->GetHeight() * 3;
2432 PyObject* rv;
2433 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2434 return rv;
2435 }
2436 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2437 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2438 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2439 return;
2440 }
2441 self->SetData(data, true);
2442 }
2443 static PyObject *wxImage_GetAlphaData(wxImage *self){
2444 buffer data = self->GetAlpha();
2445 if (! data) {
2446 RETURN_NONE();
2447 } else {
2448 int len = self->GetWidth() * self->GetHeight();
2449 PyObject* rv;
2450 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2451 return rv;
2452 }
2453 }
2454 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2455 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2456 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2457 return;
2458 }
2459 buffer acopy = (buffer)malloc(ALPHASIZE);
2460 if (acopy == NULL) {
2461 wxPyBLOCK_THREADS(PyErr_NoMemory());
2462 return;
2463 }
2464 memcpy(acopy, alpha, ALPHASIZE);
2465 self->SetAlpha(acopy, false);
2466 // wxImage takes ownership of acopy...
2467 }
2468 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2469 buffer data = self->GetAlpha();
2470 int len = self->GetWidth() * self->GetHeight();
2471 PyObject* rv;
2472 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2473 return rv;
2474 }
2475 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2476 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2477 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2478 return;
2479 }
2480 self->SetAlpha(alpha, true);
2481 }
2482 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2483 wxBitmap bitmap(*self, depth);
2484 return bitmap;
2485 }
2486 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
2487 wxImage mono = self->ConvertToMono( red, green, blue );
2488 wxBitmap bitmap( mono, 1 );
2489 return bitmap;
2490 }
2491 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2492 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2493 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2494 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2495 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2496 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2497 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2498 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2499 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2500 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2501 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2502 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2503 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2504 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2505 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2506
2507 #include <wx/quantize.h>
2508
2509 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2510 return wxQuantize::Quantize(src, dest,
2511 //NULL, // palette
2512 desiredNoColours,
2513 NULL, // eightBitData
2514 flags);
2515 }
2516 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2517 if (PyCallable_Check(func)) {
2518 self->Connect(id, lastId, eventType,
2519 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2520 new wxPyCallback(func));
2521 }
2522 else if (func == Py_None) {
2523 self->Disconnect(id, lastId, eventType,
2524 (wxObjectEventFunction)
2525 &wxPyCallback::EventThunker);
2526 }
2527 else {
2528 wxPyBLOCK_THREADS(
2529 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2530 }
2531 }
2532 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2533 return self->Disconnect(id, lastId, eventType,
2534 (wxObjectEventFunction)
2535 &wxPyCallback::EventThunker);
2536 }
2537 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2538 if (_self && _self != Py_None) {
2539 self->SetClientObject(new wxPyOORClientData(_self, incref));
2540 }
2541 else {
2542 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2543 if (data) {
2544 self->SetClientObject(NULL); // This will delete it too
2545 }
2546 }
2547 }
2548
2549 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2550 #if wxUSE_UNICODE
2551 return self->GetUnicodeKey();
2552 #else
2553 return 0;
2554 #endif
2555 }
2556
2557 #if UINT_MAX < LONG_MAX
2558 /*@C:\\SWIG-1.3.24\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2559 #define SWIG_From_unsigned_SS_int SWIG_From_long
2560 /*@@*/
2561 #else
2562 /*@C:\\SWIG-1.3.24\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2563 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2564 /*@@*/
2565 #endif
2566
2567
2568 #if UINT_MAX != ULONG_MAX
2569 SWIGINTERN int
2570 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2571 {
2572 const char* errmsg = val ? "unsigned int" : (char*)0;
2573 unsigned long v;
2574 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2575 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2576 if (val) *val = (unsigned int)(v);
2577 return 1;
2578 }
2579 } else {
2580 PyErr_Clear();
2581 }
2582 if (val) {
2583 SWIG_type_error(errmsg, obj);
2584 }
2585 return 0;
2586 }
2587 #else
2588 SWIGINTERNSHORT unsigned int
2589 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2590 {
2591 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2592 }
2593 #endif
2594
2595
2596 SWIGINTERNSHORT unsigned int
2597 SWIG_As_unsigned_SS_int(PyObject* obj)
2598 {
2599 unsigned int v;
2600 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2601 /*
2602 this is needed to make valgrind/purify happier.
2603 */
2604 memset((void*)&v, 0, sizeof(unsigned int));
2605 }
2606 return v;
2607 }
2608
2609
2610 SWIGINTERNSHORT int
2611 SWIG_Check_unsigned_SS_int(PyObject* obj)
2612 {
2613 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2614 }
2615
2616 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2617 self->m_size = size;
2618 }
2619 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2620 int count = self->GetNumberOfFiles();
2621 wxString* files = self->GetFiles();
2622 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2623 PyObject* list = PyList_New(count);
2624
2625 if (!list) {
2626 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2627 wxPyEndBlockThreads(blocked);
2628 return NULL;
2629 }
2630
2631 for (int i=0; i<count; i++) {
2632 PyList_SetItem(list, i, wx2PyString(files[i]));
2633 }
2634 wxPyEndBlockThreads(blocked);
2635 return list;
2636 }
2637
2638
2639 static wxPyApp *new_wxPyApp(){
2640 wxPythonApp = new wxPyApp();
2641 return wxPythonApp;
2642 }
2643
2644 void wxApp_CleanUp() {
2645 __wxPyCleanup();
2646 }
2647
2648
2649 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2650
2651
2652 SWIGINTERNSHORT int
2653 SWIG_AsCharPtr(PyObject *obj, char **val)
2654 {
2655 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2656 return 1;
2657 }
2658 if (val) {
2659 PyErr_Clear();
2660 SWIG_type_error("char *", obj);
2661 }
2662 return 0;
2663 }
2664
2665
2666 SWIGINTERN PyObject *
2667 SWIG_FromCharPtr(const char* cptr)
2668 {
2669 if (cptr) {
2670 size_t size = strlen(cptr);
2671 if (size > INT_MAX) {
2672 return SWIG_NewPointerObj((char*)(cptr),
2673 SWIG_TypeQuery("char *"), 0);
2674 } else {
2675 if (size != 0) {
2676 return PyString_FromStringAndSize(cptr, size);
2677 } else {
2678 return PyString_FromString(cptr);
2679 }
2680 }
2681 }
2682 Py_INCREF(Py_None);
2683 return Py_None;
2684 }
2685
2686
2687 #ifdef __WXMAC__
2688
2689 // A dummy class that raises an exception if used...
2690 class wxEventLoop
2691 {
2692 public:
2693 wxEventLoop() { wxPyRaiseNotImplemented(); }
2694 int Run() { return 0; }
2695 void Exit(int rc = 0) {}
2696 bool Pending() const { return false; }
2697 bool Dispatch() { return false; }
2698 bool IsRunning() const { return false; }
2699 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2700 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2701 };
2702
2703 #else
2704
2705 #include <wx/evtloop.h>
2706
2707 #endif
2708
2709
2710
2711 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2712 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2713 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2714 static PyObject *wxWindow_GetChildren(wxWindow *self){
2715 wxWindowList& list = self->GetChildren();
2716 return wxPy_ConvertList(&list);
2717 }
2718 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2719 #if wxUSE_HOTKEY
2720 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2721 #else
2722 return false;
2723 #endif
2724 }
2725 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2726
2727
2728
2729 return false;
2730
2731 }
2732 static long wxWindow_GetHandle(wxWindow *self){
2733 return wxPyGetWinHandle(self);
2734 }
2735 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2736 self->AssociateHandle((WXWidget)handle);
2737 }
2738
2739 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2740 return wxWindow::FindWindowById(id, parent);
2741 }
2742
2743 wxWindow* wxFindWindowByName( const wxString& name,
2744 const wxWindow *parent = NULL ) {
2745 return wxWindow::FindWindowByName(name, parent);
2746 }
2747
2748 wxWindow* wxFindWindowByLabel( const wxString& label,
2749 const wxWindow *parent = NULL ) {
2750 return wxWindow::FindWindowByLabel(label, parent);
2751 }
2752
2753
2754 #ifdef __WXMSW__
2755 #include <wx/msw/private.h> // to get wxGetWindowId
2756 #endif
2757
2758
2759 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2760 #ifdef __WXMSW__
2761 WXHWND hWnd = (WXHWND)_hWnd;
2762 long id = wxGetWindowId(hWnd);
2763 wxWindow* win = new wxWindow;
2764 parent->AddChild(win);
2765 win->SetEventHandler(win);
2766 win->SetHWND(hWnd);
2767 win->SetId(id);
2768 win->SubclassWin(hWnd);
2769 win->AdoptAttributesFromHWND();
2770 win->SetupColours();
2771 return win;
2772 #else
2773 wxPyRaiseNotImplemented();
2774 return NULL;
2775 #endif
2776 }
2777
2778
2779 PyObject* GetTopLevelWindows() {
2780 return wxPy_ConvertList(&wxTopLevelWindows);
2781 }
2782
2783
2784 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2785 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2786 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2787
2788 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2789
2790 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2791 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2792 wxMenuItemList& list = self->GetMenuItems();
2793 return wxPy_ConvertList(&list);
2794 }
2795 static void MenuBar_SetAutoWindowMenu(bool enable){}
2796 static bool MenuBar_GetAutoWindowMenu(){ return false; }
2797 static const wxString wxPyControlNameStr(wxControlNameStr);
2798 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2799 if (clientData) {
2800 wxPyClientData* data = new wxPyClientData(clientData);
2801 return self->Append(item, data);
2802 } else
2803 return self->Append(item);
2804 }
2805 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2806 if (clientData) {
2807 wxPyClientData* data = new wxPyClientData(clientData);
2808 return self->Insert(item, pos, data);
2809 } else
2810 return self->Insert(item, pos);
2811 }
2812 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2813 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2814 if (data) {
2815 Py_INCREF(data->m_obj);
2816 return data->m_obj;
2817 } else {
2818 Py_INCREF(Py_None);
2819 return Py_None;
2820 }
2821 }
2822 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2823 wxPyClientData* data = new wxPyClientData(clientData);
2824 self->SetClientObject(n, data);
2825 }
2826
2827
2828 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2829 wxPyUserData* data = NULL;
2830 if ( userData ) {
2831 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2832 data = new wxPyUserData(userData);
2833 wxPyEndBlockThreads(blocked);
2834 }
2835 return new wxSizerItem(window, proportion, flag, border, data);
2836 }
2837 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2838 wxPyUserData* data = NULL;
2839 if ( userData ) {
2840 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2841 data = new wxPyUserData(userData);
2842 wxPyEndBlockThreads(blocked);
2843 }
2844 return new wxSizerItem(width, height, proportion, flag, border, data);
2845 }
2846 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2847 wxPyUserData* data = NULL;
2848 if ( userData ) {
2849 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2850 data = new wxPyUserData(userData);
2851 wxPyEndBlockThreads(blocked);
2852 }
2853 return new wxSizerItem(sizer, proportion, flag, border, data);
2854 }
2855
2856 #include <float.h>
2857 SWIGINTERN int
2858 SWIG_CheckDoubleInRange(double value, double min_value,
2859 double max_value, const char* errmsg)
2860 {
2861 if (value < min_value) {
2862 if (errmsg) {
2863 PyErr_Format(PyExc_OverflowError,
2864 "value %g is less than %s minimum %g",
2865 value, errmsg, min_value);
2866 }
2867 return 0;
2868 } else if (value > max_value) {
2869 if (errmsg) {
2870 PyErr_Format(PyExc_OverflowError,
2871 "value %g is greater than %s maximum %g",
2872 value, errmsg, max_value);
2873 }
2874 return 0;
2875 }
2876 return 1;
2877 }
2878
2879
2880 SWIGINTERN int
2881 SWIG_AsVal_float(PyObject *obj, float *val)
2882 {
2883 const char* errmsg = val ? "float" : (char*)0;
2884 double v;
2885 if (SWIG_AsVal_double(obj, &v)) {
2886 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2887 if (val) *val = (float)(v);
2888 return 1;
2889 } else {
2890 return 0;
2891 }
2892 } else {
2893 PyErr_Clear();
2894 }
2895 if (val) {
2896 SWIG_type_error(errmsg, obj);
2897 }
2898 return 0;
2899 }
2900
2901
2902 SWIGINTERNSHORT float
2903 SWIG_As_float(PyObject* obj)
2904 {
2905 float v;
2906 if (!SWIG_AsVal_float(obj, &v)) {
2907 /*
2908 this is needed to make valgrind/purify happier.
2909 */
2910 memset((void*)&v, 0, sizeof(float));
2911 }
2912 return v;
2913 }
2914
2915
2916 SWIGINTERNSHORT int
2917 SWIG_Check_float(PyObject* obj)
2918 {
2919 return SWIG_AsVal_float(obj, (float*)0);
2920 }
2921
2922
2923 /*@C:\\SWIG-1.3.24\\Lib\\python\\pymacros.swg,66,SWIG_define@*/
2924 #define SWIG_From_float PyFloat_FromDouble
2925 /*@@*/
2926
2927 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2928 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2929 if (data) {
2930 Py_INCREF(data->m_obj);
2931 return data->m_obj;
2932 } else {
2933 Py_INCREF(Py_None);
2934 return Py_None;
2935 }
2936 }
2937
2938 // Figure out the type of the sizer item
2939
2940 struct wxPySizerItemInfo {
2941 wxPySizerItemInfo()
2942 : window(NULL), sizer(NULL), gotSize(false),
2943 size(wxDefaultSize), gotPos(false), pos(-1)
2944 {}
2945
2946 wxWindow* window;
2947 wxSizer* sizer;
2948 bool gotSize;
2949 wxSize size;
2950 bool gotPos;
2951 int pos;
2952 };
2953
2954 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2955
2956 wxPySizerItemInfo info;
2957 wxSize size;
2958 wxSize* sizePtr = &size;
2959
2960 // Find out what the type of the item is
2961 // try wxWindow
2962 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2963 PyErr_Clear();
2964 info.window = NULL;
2965
2966 // try wxSizer
2967 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2968 PyErr_Clear();
2969 info.sizer = NULL;
2970
2971 // try wxSize or (w,h)
2972 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2973 info.size = *sizePtr;
2974 info.gotSize = true;
2975 }
2976
2977 // or a single int
2978 if (checkIdx && PyInt_Check(item)) {
2979 info.pos = PyInt_AsLong(item);
2980 info.gotPos = true;
2981 }
2982 }
2983 }
2984
2985 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2986 // no expected type, figure out what kind of error message to generate
2987 if ( !checkSize && !checkIdx )
2988 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2989 else if ( checkSize && !checkIdx )
2990 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2991 else if ( !checkSize && checkIdx)
2992 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2993 else
2994 // can this one happen?
2995 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2996 }
2997
2998 return info;
2999 }
3000
3001 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3002 if (!self->GetClientObject())
3003 self->SetClientObject(new wxPyOORClientData(_self));
3004 }
3005 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3006
3007 wxPyUserData* data = NULL;
3008 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3009 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3010 if ( userData && (info.window || info.sizer || info.gotSize) )
3011 data = new wxPyUserData(userData);
3012 wxPyEndBlockThreads(blocked);
3013
3014 // Now call the real Add method if a valid item type was found
3015 if ( info.window )
3016 return self->Add(info.window, proportion, flag, border, data);
3017 else if ( info.sizer )
3018 return self->Add(info.sizer, proportion, flag, border, data);
3019 else if (info.gotSize)
3020 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3021 proportion, flag, border, data);
3022 else
3023 return NULL;
3024 }
3025 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3026
3027 wxPyUserData* data = NULL;
3028 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3029 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3030 if ( userData && (info.window || info.sizer || info.gotSize) )
3031 data = new wxPyUserData(userData);
3032 wxPyEndBlockThreads(blocked);
3033
3034 // Now call the real Insert method if a valid item type was found
3035 if ( info.window )
3036 return self->Insert(before, info.window, proportion, flag, border, data);
3037 else if ( info.sizer )
3038 return self->Insert(before, info.sizer, proportion, flag, border, data);
3039 else if (info.gotSize)
3040 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3041 proportion, flag, border, data);
3042 else
3043 return NULL;
3044 }
3045 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3046
3047 wxPyUserData* data = NULL;
3048 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3049 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3050 if ( userData && (info.window || info.sizer || info.gotSize) )
3051 data = new wxPyUserData(userData);
3052 wxPyEndBlockThreads(blocked);
3053
3054 // Now call the real Prepend method if a valid item type was found
3055 if ( info.window )
3056 return self->Prepend(info.window, proportion, flag, border, data);
3057 else if ( info.sizer )
3058 return self->Prepend(info.sizer, proportion, flag, border, data);
3059 else if (info.gotSize)
3060 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3061 proportion, flag, border, data);
3062 else
3063 return NULL;
3064 }
3065 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3066 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3067 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3068 wxPyEndBlockThreads(blocked);
3069 if ( info.window )
3070 return self->Remove(info.window);
3071 else if ( info.sizer )
3072 return self->Remove(info.sizer);
3073 else if ( info.gotPos )
3074 return self->Remove(info.pos);
3075 else
3076 return false;
3077 }
3078 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3079 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3080 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3081 wxPyEndBlockThreads(blocked);
3082 if ( info.window )
3083 return self->Detach(info.window);
3084 else if ( info.sizer )
3085 return self->Detach(info.sizer);
3086 else if ( info.gotPos )
3087 return self->Detach(info.pos);
3088 else
3089 return false;
3090 }
3091 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3092 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3093 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3094 wxPyEndBlockThreads(blocked);
3095 if ( info.window )
3096 return self->GetItem(info.window);
3097 else if ( info.sizer )
3098 return self->GetItem(info.sizer);
3099 else if ( info.gotPos )
3100 return self->GetItem(info.pos);
3101 else
3102 return NULL;
3103 }
3104 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3105 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3106 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3107 wxPyEndBlockThreads(blocked);
3108 if ( info.window )
3109 self->SetItemMinSize(info.window, size);
3110 else if ( info.sizer )
3111 self->SetItemMinSize(info.sizer, size);
3112 else if ( info.gotPos )
3113 self->SetItemMinSize(info.pos, size);
3114 }
3115 static PyObject *wxSizer_GetChildren(wxSizer *self){
3116 wxSizerItemList& list = self->GetChildren();
3117 return wxPy_ConvertList(&list);
3118 }
3119 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3120 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3121 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3122 wxPyEndBlockThreads(blocked);
3123 if ( info.window )
3124 return self->Show(info.window, show, recursive);
3125 else if ( info.sizer )
3126 return self->Show(info.sizer, show, recursive);
3127 else if ( info.gotPos )
3128 return self->Show(info.pos, show);
3129 else
3130 return false;
3131 }
3132 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3133 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3134 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3135 wxPyEndBlockThreads(blocked);
3136 if ( info.window )
3137 return self->IsShown(info.window);
3138 else if ( info.sizer )
3139 return self->IsShown(info.sizer);
3140 else if ( info.gotPos )
3141 return self->IsShown(info.pos);
3142 else
3143 return false;
3144 }
3145
3146 // See pyclasses.h
3147 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3148 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3149 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3150
3151
3152
3153
3154 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3155 {
3156 if (source == Py_None) {
3157 **obj = wxGBPosition(-1,-1);
3158 return true;
3159 }
3160 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3161 }
3162
3163 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3164 {
3165 if (source == Py_None) {
3166 **obj = wxGBSpan(-1,-1);
3167 return true;
3168 }
3169 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3170 }
3171
3172
3173 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3174 self->SetRow(row);
3175 self->SetCol(col);
3176 }
3177 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3178 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3179 PyObject* tup = PyTuple_New(2);
3180 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3181 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3182 wxPyEndBlockThreads(blocked);
3183 return tup;
3184 }
3185 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3186 self->SetRowspan(rowspan);
3187 self->SetColspan(colspan);
3188 }
3189 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3190 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3191 PyObject* tup = PyTuple_New(2);
3192 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3193 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3194 wxPyEndBlockThreads(blocked);
3195 return tup;
3196 }
3197 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3198 wxPyUserData* data = NULL;
3199 if ( userData ) {
3200 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3201 data = new wxPyUserData(userData);
3202 wxPyEndBlockThreads(blocked);
3203 }
3204 return new wxGBSizerItem(window, pos, span, flag, border, data);
3205 }
3206 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3207 wxPyUserData* data = NULL;
3208 if ( userData ) {
3209 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3210 data = new wxPyUserData(userData);
3211 wxPyEndBlockThreads(blocked);
3212 }
3213 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3214 }
3215 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3216 wxPyUserData* data = NULL;
3217 if ( userData ) {
3218 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3219 data = new wxPyUserData(userData);
3220 wxPyEndBlockThreads(blocked);
3221 }
3222 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3223 }
3224 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3225 int row, col;
3226 self->GetEndPos(row, col);
3227 return wxGBPosition(row, col);
3228 }
3229 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3230
3231 wxPyUserData* data = NULL;
3232 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3233 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3234 if ( userData && (info.window || info.sizer || info.gotSize) )
3235 data = new wxPyUserData(userData);
3236 wxPyEndBlockThreads(blocked);
3237
3238 // Now call the real Add method if a valid item type was found
3239 if ( info.window )
3240 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3241 else if ( info.sizer )
3242 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3243 else if (info.gotSize)
3244 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3245 pos, span, flag, border, data);
3246 return NULL;
3247 }
3248
3249
3250 #ifdef __cplusplus
3251 extern "C" {
3252 #endif
3253 static int _wrap_EmptyString_set(PyObject *) {
3254 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3255 return 1;
3256 }
3257
3258
3259 static PyObject *_wrap_EmptyString_get(void) {
3260 PyObject *pyobj;
3261
3262 {
3263 #if wxUSE_UNICODE
3264 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3265 #else
3266 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3267 #endif
3268 }
3269 return pyobj;
3270 }
3271
3272
3273 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3274 PyObject *resultobj;
3275 wxObject *arg1 = (wxObject *) 0 ;
3276 wxString result;
3277 PyObject * obj0 = 0 ;
3278 char *kwnames[] = {
3279 (char *) "self", NULL
3280 };
3281
3282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3284 if (SWIG_arg_fail(1)) SWIG_fail;
3285 {
3286 PyThreadState* __tstate = wxPyBeginAllowThreads();
3287 result = wxObject_GetClassName(arg1);
3288
3289 wxPyEndAllowThreads(__tstate);
3290 if (PyErr_Occurred()) SWIG_fail;
3291 }
3292 {
3293 #if wxUSE_UNICODE
3294 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3295 #else
3296 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3297 #endif
3298 }
3299 return resultobj;
3300 fail:
3301 return NULL;
3302 }
3303
3304
3305 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3306 PyObject *resultobj;
3307 wxObject *arg1 = (wxObject *) 0 ;
3308 PyObject * obj0 = 0 ;
3309 char *kwnames[] = {
3310 (char *) "self", NULL
3311 };
3312
3313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3315 if (SWIG_arg_fail(1)) SWIG_fail;
3316 {
3317 PyThreadState* __tstate = wxPyBeginAllowThreads();
3318 wxObject_Destroy(arg1);
3319
3320 wxPyEndAllowThreads(__tstate);
3321 if (PyErr_Occurred()) SWIG_fail;
3322 }
3323 Py_INCREF(Py_None); resultobj = Py_None;
3324 return resultobj;
3325 fail:
3326 return NULL;
3327 }
3328
3329
3330 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3331 PyObject *obj;
3332 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3333 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3334 Py_INCREF(obj);
3335 return Py_BuildValue((char *)"");
3336 }
3337 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3338 PyObject *resultobj;
3339 wxSize *arg1 = (wxSize *) 0 ;
3340 int arg2 ;
3341 PyObject * obj0 = 0 ;
3342 PyObject * obj1 = 0 ;
3343 char *kwnames[] = {
3344 (char *) "self",(char *) "x", NULL
3345 };
3346
3347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3349 if (SWIG_arg_fail(1)) SWIG_fail;
3350 {
3351 arg2 = (int)(SWIG_As_int(obj1));
3352 if (SWIG_arg_fail(2)) SWIG_fail;
3353 }
3354 if (arg1) (arg1)->x = arg2;
3355
3356 Py_INCREF(Py_None); resultobj = Py_None;
3357 return resultobj;
3358 fail:
3359 return NULL;
3360 }
3361
3362
3363 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3364 PyObject *resultobj;
3365 wxSize *arg1 = (wxSize *) 0 ;
3366 int result;
3367 PyObject * obj0 = 0 ;
3368 char *kwnames[] = {
3369 (char *) "self", NULL
3370 };
3371
3372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3374 if (SWIG_arg_fail(1)) SWIG_fail;
3375 result = (int) ((arg1)->x);
3376
3377 {
3378 resultobj = SWIG_From_int((int)(result));
3379 }
3380 return resultobj;
3381 fail:
3382 return NULL;
3383 }
3384
3385
3386 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3387 PyObject *resultobj;
3388 wxSize *arg1 = (wxSize *) 0 ;
3389 int arg2 ;
3390 PyObject * obj0 = 0 ;
3391 PyObject * obj1 = 0 ;
3392 char *kwnames[] = {
3393 (char *) "self",(char *) "y", NULL
3394 };
3395
3396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3398 if (SWIG_arg_fail(1)) SWIG_fail;
3399 {
3400 arg2 = (int)(SWIG_As_int(obj1));
3401 if (SWIG_arg_fail(2)) SWIG_fail;
3402 }
3403 if (arg1) (arg1)->y = arg2;
3404
3405 Py_INCREF(Py_None); resultobj = Py_None;
3406 return resultobj;
3407 fail:
3408 return NULL;
3409 }
3410
3411
3412 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3413 PyObject *resultobj;
3414 wxSize *arg1 = (wxSize *) 0 ;
3415 int result;
3416 PyObject * obj0 = 0 ;
3417 char *kwnames[] = {
3418 (char *) "self", NULL
3419 };
3420
3421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3423 if (SWIG_arg_fail(1)) SWIG_fail;
3424 result = (int) ((arg1)->y);
3425
3426 {
3427 resultobj = SWIG_From_int((int)(result));
3428 }
3429 return resultobj;
3430 fail:
3431 return NULL;
3432 }
3433
3434
3435 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3436 PyObject *resultobj;
3437 int arg1 = (int) 0 ;
3438 int arg2 = (int) 0 ;
3439 wxSize *result;
3440 PyObject * obj0 = 0 ;
3441 PyObject * obj1 = 0 ;
3442 char *kwnames[] = {
3443 (char *) "w",(char *) "h", NULL
3444 };
3445
3446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3447 if (obj0) {
3448 {
3449 arg1 = (int)(SWIG_As_int(obj0));
3450 if (SWIG_arg_fail(1)) SWIG_fail;
3451 }
3452 }
3453 if (obj1) {
3454 {
3455 arg2 = (int)(SWIG_As_int(obj1));
3456 if (SWIG_arg_fail(2)) SWIG_fail;
3457 }
3458 }
3459 {
3460 PyThreadState* __tstate = wxPyBeginAllowThreads();
3461 result = (wxSize *)new wxSize(arg1,arg2);
3462
3463 wxPyEndAllowThreads(__tstate);
3464 if (PyErr_Occurred()) SWIG_fail;
3465 }
3466 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3467 return resultobj;
3468 fail:
3469 return NULL;
3470 }
3471
3472
3473 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3474 PyObject *resultobj;
3475 wxSize *arg1 = (wxSize *) 0 ;
3476 PyObject * obj0 = 0 ;
3477 char *kwnames[] = {
3478 (char *) "self", NULL
3479 };
3480
3481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3483 if (SWIG_arg_fail(1)) SWIG_fail;
3484 {
3485 PyThreadState* __tstate = wxPyBeginAllowThreads();
3486 delete arg1;
3487
3488 wxPyEndAllowThreads(__tstate);
3489 if (PyErr_Occurred()) SWIG_fail;
3490 }
3491 Py_INCREF(Py_None); resultobj = Py_None;
3492 return resultobj;
3493 fail:
3494 return NULL;
3495 }
3496
3497
3498 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3499 PyObject *resultobj;
3500 wxSize *arg1 = (wxSize *) 0 ;
3501 wxSize *arg2 = 0 ;
3502 bool result;
3503 wxSize temp2 ;
3504 PyObject * obj0 = 0 ;
3505 PyObject * obj1 = 0 ;
3506 char *kwnames[] = {
3507 (char *) "self",(char *) "sz", NULL
3508 };
3509
3510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3512 if (SWIG_arg_fail(1)) SWIG_fail;
3513 {
3514 arg2 = &temp2;
3515 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3516 }
3517 {
3518 PyThreadState* __tstate = wxPyBeginAllowThreads();
3519 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3520
3521 wxPyEndAllowThreads(__tstate);
3522 if (PyErr_Occurred()) SWIG_fail;
3523 }
3524 {
3525 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3526 }
3527 return resultobj;
3528 fail:
3529 return NULL;
3530 }
3531
3532
3533 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3534 PyObject *resultobj;
3535 wxSize *arg1 = (wxSize *) 0 ;
3536 wxSize *arg2 = 0 ;
3537 bool result;
3538 wxSize temp2 ;
3539 PyObject * obj0 = 0 ;
3540 PyObject * obj1 = 0 ;
3541 char *kwnames[] = {
3542 (char *) "self",(char *) "sz", NULL
3543 };
3544
3545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3547 if (SWIG_arg_fail(1)) SWIG_fail;
3548 {
3549 arg2 = &temp2;
3550 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3551 }
3552 {
3553 PyThreadState* __tstate = wxPyBeginAllowThreads();
3554 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3555
3556 wxPyEndAllowThreads(__tstate);
3557 if (PyErr_Occurred()) SWIG_fail;
3558 }
3559 {
3560 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3561 }
3562 return resultobj;
3563 fail:
3564 return NULL;
3565 }
3566
3567
3568 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3569 PyObject *resultobj;
3570 wxSize *arg1 = (wxSize *) 0 ;
3571 wxSize *arg2 = 0 ;
3572 wxSize result;
3573 wxSize temp2 ;
3574 PyObject * obj0 = 0 ;
3575 PyObject * obj1 = 0 ;
3576 char *kwnames[] = {
3577 (char *) "self",(char *) "sz", NULL
3578 };
3579
3580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3582 if (SWIG_arg_fail(1)) SWIG_fail;
3583 {
3584 arg2 = &temp2;
3585 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3586 }
3587 {
3588 PyThreadState* __tstate = wxPyBeginAllowThreads();
3589 result = (arg1)->operator +((wxSize const &)*arg2);
3590
3591 wxPyEndAllowThreads(__tstate);
3592 if (PyErr_Occurred()) SWIG_fail;
3593 }
3594 {
3595 wxSize * resultptr;
3596 resultptr = new wxSize((wxSize &)(result));
3597 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3598 }
3599 return resultobj;
3600 fail:
3601 return NULL;
3602 }
3603
3604
3605 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3606 PyObject *resultobj;
3607 wxSize *arg1 = (wxSize *) 0 ;
3608 wxSize *arg2 = 0 ;
3609 wxSize result;
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___sub__",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 result = (arg1)->operator -((wxSize const &)*arg2);
3627
3628 wxPyEndAllowThreads(__tstate);
3629 if (PyErr_Occurred()) SWIG_fail;
3630 }
3631 {
3632 wxSize * resultptr;
3633 resultptr = new wxSize((wxSize &)(result));
3634 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3635 }
3636 return resultobj;
3637 fail:
3638 return NULL;
3639 }
3640
3641
3642 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3643 PyObject *resultobj;
3644 wxSize *arg1 = (wxSize *) 0 ;
3645 wxSize *arg2 = 0 ;
3646 wxSize temp2 ;
3647 PyObject * obj0 = 0 ;
3648 PyObject * obj1 = 0 ;
3649 char *kwnames[] = {
3650 (char *) "self",(char *) "sz", NULL
3651 };
3652
3653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3655 if (SWIG_arg_fail(1)) SWIG_fail;
3656 {
3657 arg2 = &temp2;
3658 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3659 }
3660 {
3661 PyThreadState* __tstate = wxPyBeginAllowThreads();
3662 (arg1)->IncTo((wxSize const &)*arg2);
3663
3664 wxPyEndAllowThreads(__tstate);
3665 if (PyErr_Occurred()) SWIG_fail;
3666 }
3667 Py_INCREF(Py_None); resultobj = Py_None;
3668 return resultobj;
3669 fail:
3670 return NULL;
3671 }
3672
3673
3674 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3675 PyObject *resultobj;
3676 wxSize *arg1 = (wxSize *) 0 ;
3677 wxSize *arg2 = 0 ;
3678 wxSize temp2 ;
3679 PyObject * obj0 = 0 ;
3680 PyObject * obj1 = 0 ;
3681 char *kwnames[] = {
3682 (char *) "self",(char *) "sz", NULL
3683 };
3684
3685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3687 if (SWIG_arg_fail(1)) SWIG_fail;
3688 {
3689 arg2 = &temp2;
3690 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3691 }
3692 {
3693 PyThreadState* __tstate = wxPyBeginAllowThreads();
3694 (arg1)->DecTo((wxSize const &)*arg2);
3695
3696 wxPyEndAllowThreads(__tstate);
3697 if (PyErr_Occurred()) SWIG_fail;
3698 }
3699 Py_INCREF(Py_None); resultobj = Py_None;
3700 return resultobj;
3701 fail:
3702 return NULL;
3703 }
3704
3705
3706 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3707 PyObject *resultobj;
3708 wxSize *arg1 = (wxSize *) 0 ;
3709 int arg2 ;
3710 int arg3 ;
3711 PyObject * obj0 = 0 ;
3712 PyObject * obj1 = 0 ;
3713 PyObject * obj2 = 0 ;
3714 char *kwnames[] = {
3715 (char *) "self",(char *) "w",(char *) "h", NULL
3716 };
3717
3718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3720 if (SWIG_arg_fail(1)) SWIG_fail;
3721 {
3722 arg2 = (int)(SWIG_As_int(obj1));
3723 if (SWIG_arg_fail(2)) SWIG_fail;
3724 }
3725 {
3726 arg3 = (int)(SWIG_As_int(obj2));
3727 if (SWIG_arg_fail(3)) SWIG_fail;
3728 }
3729 {
3730 PyThreadState* __tstate = wxPyBeginAllowThreads();
3731 (arg1)->Set(arg2,arg3);
3732
3733 wxPyEndAllowThreads(__tstate);
3734 if (PyErr_Occurred()) SWIG_fail;
3735 }
3736 Py_INCREF(Py_None); resultobj = Py_None;
3737 return resultobj;
3738 fail:
3739 return NULL;
3740 }
3741
3742
3743 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3744 PyObject *resultobj;
3745 wxSize *arg1 = (wxSize *) 0 ;
3746 int arg2 ;
3747 PyObject * obj0 = 0 ;
3748 PyObject * obj1 = 0 ;
3749 char *kwnames[] = {
3750 (char *) "self",(char *) "w", NULL
3751 };
3752
3753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3755 if (SWIG_arg_fail(1)) SWIG_fail;
3756 {
3757 arg2 = (int)(SWIG_As_int(obj1));
3758 if (SWIG_arg_fail(2)) SWIG_fail;
3759 }
3760 {
3761 PyThreadState* __tstate = wxPyBeginAllowThreads();
3762 (arg1)->SetWidth(arg2);
3763
3764 wxPyEndAllowThreads(__tstate);
3765 if (PyErr_Occurred()) SWIG_fail;
3766 }
3767 Py_INCREF(Py_None); resultobj = Py_None;
3768 return resultobj;
3769 fail:
3770 return NULL;
3771 }
3772
3773
3774 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3775 PyObject *resultobj;
3776 wxSize *arg1 = (wxSize *) 0 ;
3777 int arg2 ;
3778 PyObject * obj0 = 0 ;
3779 PyObject * obj1 = 0 ;
3780 char *kwnames[] = {
3781 (char *) "self",(char *) "h", NULL
3782 };
3783
3784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3786 if (SWIG_arg_fail(1)) SWIG_fail;
3787 {
3788 arg2 = (int)(SWIG_As_int(obj1));
3789 if (SWIG_arg_fail(2)) SWIG_fail;
3790 }
3791 {
3792 PyThreadState* __tstate = wxPyBeginAllowThreads();
3793 (arg1)->SetHeight(arg2);
3794
3795 wxPyEndAllowThreads(__tstate);
3796 if (PyErr_Occurred()) SWIG_fail;
3797 }
3798 Py_INCREF(Py_None); resultobj = Py_None;
3799 return resultobj;
3800 fail:
3801 return NULL;
3802 }
3803
3804
3805 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3806 PyObject *resultobj;
3807 wxSize *arg1 = (wxSize *) 0 ;
3808 int result;
3809 PyObject * obj0 = 0 ;
3810 char *kwnames[] = {
3811 (char *) "self", NULL
3812 };
3813
3814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3816 if (SWIG_arg_fail(1)) SWIG_fail;
3817 {
3818 PyThreadState* __tstate = wxPyBeginAllowThreads();
3819 result = (int)((wxSize const *)arg1)->GetWidth();
3820
3821 wxPyEndAllowThreads(__tstate);
3822 if (PyErr_Occurred()) SWIG_fail;
3823 }
3824 {
3825 resultobj = SWIG_From_int((int)(result));
3826 }
3827 return resultobj;
3828 fail:
3829 return NULL;
3830 }
3831
3832
3833 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3834 PyObject *resultobj;
3835 wxSize *arg1 = (wxSize *) 0 ;
3836 int result;
3837 PyObject * obj0 = 0 ;
3838 char *kwnames[] = {
3839 (char *) "self", NULL
3840 };
3841
3842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3844 if (SWIG_arg_fail(1)) SWIG_fail;
3845 {
3846 PyThreadState* __tstate = wxPyBeginAllowThreads();
3847 result = (int)((wxSize const *)arg1)->GetHeight();
3848
3849 wxPyEndAllowThreads(__tstate);
3850 if (PyErr_Occurred()) SWIG_fail;
3851 }
3852 {
3853 resultobj = SWIG_From_int((int)(result));
3854 }
3855 return resultobj;
3856 fail:
3857 return NULL;
3858 }
3859
3860
3861 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3862 PyObject *resultobj;
3863 wxSize *arg1 = (wxSize *) 0 ;
3864 bool result;
3865 PyObject * obj0 = 0 ;
3866 char *kwnames[] = {
3867 (char *) "self", NULL
3868 };
3869
3870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3872 if (SWIG_arg_fail(1)) SWIG_fail;
3873 {
3874 PyThreadState* __tstate = wxPyBeginAllowThreads();
3875 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3876
3877 wxPyEndAllowThreads(__tstate);
3878 if (PyErr_Occurred()) SWIG_fail;
3879 }
3880 {
3881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3882 }
3883 return resultobj;
3884 fail:
3885 return NULL;
3886 }
3887
3888
3889 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3890 PyObject *resultobj;
3891 wxSize *arg1 = (wxSize *) 0 ;
3892 wxSize *arg2 = 0 ;
3893 wxSize temp2 ;
3894 PyObject * obj0 = 0 ;
3895 PyObject * obj1 = 0 ;
3896 char *kwnames[] = {
3897 (char *) "self",(char *) "size", NULL
3898 };
3899
3900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3902 if (SWIG_arg_fail(1)) SWIG_fail;
3903 {
3904 arg2 = &temp2;
3905 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3906 }
3907 {
3908 PyThreadState* __tstate = wxPyBeginAllowThreads();
3909 (arg1)->SetDefaults((wxSize const &)*arg2);
3910
3911 wxPyEndAllowThreads(__tstate);
3912 if (PyErr_Occurred()) SWIG_fail;
3913 }
3914 Py_INCREF(Py_None); resultobj = Py_None;
3915 return resultobj;
3916 fail:
3917 return NULL;
3918 }
3919
3920
3921 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3922 PyObject *resultobj;
3923 wxSize *arg1 = (wxSize *) 0 ;
3924 PyObject *result;
3925 PyObject * obj0 = 0 ;
3926 char *kwnames[] = {
3927 (char *) "self", NULL
3928 };
3929
3930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3932 if (SWIG_arg_fail(1)) SWIG_fail;
3933 {
3934 PyThreadState* __tstate = wxPyBeginAllowThreads();
3935 result = (PyObject *)wxSize_Get(arg1);
3936
3937 wxPyEndAllowThreads(__tstate);
3938 if (PyErr_Occurred()) SWIG_fail;
3939 }
3940 resultobj = result;
3941 return resultobj;
3942 fail:
3943 return NULL;
3944 }
3945
3946
3947 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3948 PyObject *obj;
3949 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3950 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3951 Py_INCREF(obj);
3952 return Py_BuildValue((char *)"");
3953 }
3954 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3955 PyObject *resultobj;
3956 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3957 double arg2 ;
3958 PyObject * obj0 = 0 ;
3959 PyObject * obj1 = 0 ;
3960 char *kwnames[] = {
3961 (char *) "self",(char *) "x", NULL
3962 };
3963
3964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3966 if (SWIG_arg_fail(1)) SWIG_fail;
3967 {
3968 arg2 = (double)(SWIG_As_double(obj1));
3969 if (SWIG_arg_fail(2)) SWIG_fail;
3970 }
3971 if (arg1) (arg1)->x = arg2;
3972
3973 Py_INCREF(Py_None); resultobj = Py_None;
3974 return resultobj;
3975 fail:
3976 return NULL;
3977 }
3978
3979
3980 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3981 PyObject *resultobj;
3982 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3983 double result;
3984 PyObject * obj0 = 0 ;
3985 char *kwnames[] = {
3986 (char *) "self", NULL
3987 };
3988
3989 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3991 if (SWIG_arg_fail(1)) SWIG_fail;
3992 result = (double) ((arg1)->x);
3993
3994 {
3995 resultobj = SWIG_From_double((double)(result));
3996 }
3997 return resultobj;
3998 fail:
3999 return NULL;
4000 }
4001
4002
4003 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4004 PyObject *resultobj;
4005 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4006 double arg2 ;
4007 PyObject * obj0 = 0 ;
4008 PyObject * obj1 = 0 ;
4009 char *kwnames[] = {
4010 (char *) "self",(char *) "y", NULL
4011 };
4012
4013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4015 if (SWIG_arg_fail(1)) SWIG_fail;
4016 {
4017 arg2 = (double)(SWIG_As_double(obj1));
4018 if (SWIG_arg_fail(2)) SWIG_fail;
4019 }
4020 if (arg1) (arg1)->y = arg2;
4021
4022 Py_INCREF(Py_None); resultobj = Py_None;
4023 return resultobj;
4024 fail:
4025 return NULL;
4026 }
4027
4028
4029 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4030 PyObject *resultobj;
4031 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4032 double result;
4033 PyObject * obj0 = 0 ;
4034 char *kwnames[] = {
4035 (char *) "self", NULL
4036 };
4037
4038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4040 if (SWIG_arg_fail(1)) SWIG_fail;
4041 result = (double) ((arg1)->y);
4042
4043 {
4044 resultobj = SWIG_From_double((double)(result));
4045 }
4046 return resultobj;
4047 fail:
4048 return NULL;
4049 }
4050
4051
4052 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4053 PyObject *resultobj;
4054 double arg1 = (double) 0.0 ;
4055 double arg2 = (double) 0.0 ;
4056 wxRealPoint *result;
4057 PyObject * obj0 = 0 ;
4058 PyObject * obj1 = 0 ;
4059 char *kwnames[] = {
4060 (char *) "x",(char *) "y", NULL
4061 };
4062
4063 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4064 if (obj0) {
4065 {
4066 arg1 = (double)(SWIG_As_double(obj0));
4067 if (SWIG_arg_fail(1)) SWIG_fail;
4068 }
4069 }
4070 if (obj1) {
4071 {
4072 arg2 = (double)(SWIG_As_double(obj1));
4073 if (SWIG_arg_fail(2)) SWIG_fail;
4074 }
4075 }
4076 {
4077 PyThreadState* __tstate = wxPyBeginAllowThreads();
4078 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4079
4080 wxPyEndAllowThreads(__tstate);
4081 if (PyErr_Occurred()) SWIG_fail;
4082 }
4083 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4084 return resultobj;
4085 fail:
4086 return NULL;
4087 }
4088
4089
4090 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4091 PyObject *resultobj;
4092 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4093 PyObject * obj0 = 0 ;
4094 char *kwnames[] = {
4095 (char *) "self", NULL
4096 };
4097
4098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4100 if (SWIG_arg_fail(1)) SWIG_fail;
4101 {
4102 PyThreadState* __tstate = wxPyBeginAllowThreads();
4103 delete arg1;
4104
4105 wxPyEndAllowThreads(__tstate);
4106 if (PyErr_Occurred()) SWIG_fail;
4107 }
4108 Py_INCREF(Py_None); resultobj = Py_None;
4109 return resultobj;
4110 fail:
4111 return NULL;
4112 }
4113
4114
4115 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4116 PyObject *resultobj;
4117 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4118 wxRealPoint *arg2 = 0 ;
4119 bool result;
4120 wxRealPoint temp2 ;
4121 PyObject * obj0 = 0 ;
4122 PyObject * obj1 = 0 ;
4123 char *kwnames[] = {
4124 (char *) "self",(char *) "pt", NULL
4125 };
4126
4127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4129 if (SWIG_arg_fail(1)) SWIG_fail;
4130 {
4131 arg2 = &temp2;
4132 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4133 }
4134 {
4135 PyThreadState* __tstate = wxPyBeginAllowThreads();
4136 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4137
4138 wxPyEndAllowThreads(__tstate);
4139 if (PyErr_Occurred()) SWIG_fail;
4140 }
4141 {
4142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4143 }
4144 return resultobj;
4145 fail:
4146 return NULL;
4147 }
4148
4149
4150 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4151 PyObject *resultobj;
4152 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4153 wxRealPoint *arg2 = 0 ;
4154 bool result;
4155 wxRealPoint temp2 ;
4156 PyObject * obj0 = 0 ;
4157 PyObject * obj1 = 0 ;
4158 char *kwnames[] = {
4159 (char *) "self",(char *) "pt", NULL
4160 };
4161
4162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4164 if (SWIG_arg_fail(1)) SWIG_fail;
4165 {
4166 arg2 = &temp2;
4167 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4168 }
4169 {
4170 PyThreadState* __tstate = wxPyBeginAllowThreads();
4171 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4172
4173 wxPyEndAllowThreads(__tstate);
4174 if (PyErr_Occurred()) SWIG_fail;
4175 }
4176 {
4177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4178 }
4179 return resultobj;
4180 fail:
4181 return NULL;
4182 }
4183
4184
4185 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4186 PyObject *resultobj;
4187 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4188 wxRealPoint *arg2 = 0 ;
4189 wxRealPoint result;
4190 wxRealPoint temp2 ;
4191 PyObject * obj0 = 0 ;
4192 PyObject * obj1 = 0 ;
4193 char *kwnames[] = {
4194 (char *) "self",(char *) "pt", NULL
4195 };
4196
4197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4199 if (SWIG_arg_fail(1)) SWIG_fail;
4200 {
4201 arg2 = &temp2;
4202 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4203 }
4204 {
4205 PyThreadState* __tstate = wxPyBeginAllowThreads();
4206 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4207
4208 wxPyEndAllowThreads(__tstate);
4209 if (PyErr_Occurred()) SWIG_fail;
4210 }
4211 {
4212 wxRealPoint * resultptr;
4213 resultptr = new wxRealPoint((wxRealPoint &)(result));
4214 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4215 }
4216 return resultobj;
4217 fail:
4218 return NULL;
4219 }
4220
4221
4222 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4223 PyObject *resultobj;
4224 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4225 wxRealPoint *arg2 = 0 ;
4226 wxRealPoint result;
4227 wxRealPoint temp2 ;
4228 PyObject * obj0 = 0 ;
4229 PyObject * obj1 = 0 ;
4230 char *kwnames[] = {
4231 (char *) "self",(char *) "pt", NULL
4232 };
4233
4234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4236 if (SWIG_arg_fail(1)) SWIG_fail;
4237 {
4238 arg2 = &temp2;
4239 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4240 }
4241 {
4242 PyThreadState* __tstate = wxPyBeginAllowThreads();
4243 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4244
4245 wxPyEndAllowThreads(__tstate);
4246 if (PyErr_Occurred()) SWIG_fail;
4247 }
4248 {
4249 wxRealPoint * resultptr;
4250 resultptr = new wxRealPoint((wxRealPoint &)(result));
4251 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4252 }
4253 return resultobj;
4254 fail:
4255 return NULL;
4256 }
4257
4258
4259 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4260 PyObject *resultobj;
4261 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4262 double arg2 ;
4263 double arg3 ;
4264 PyObject * obj0 = 0 ;
4265 PyObject * obj1 = 0 ;
4266 PyObject * obj2 = 0 ;
4267 char *kwnames[] = {
4268 (char *) "self",(char *) "x",(char *) "y", NULL
4269 };
4270
4271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4273 if (SWIG_arg_fail(1)) SWIG_fail;
4274 {
4275 arg2 = (double)(SWIG_As_double(obj1));
4276 if (SWIG_arg_fail(2)) SWIG_fail;
4277 }
4278 {
4279 arg3 = (double)(SWIG_As_double(obj2));
4280 if (SWIG_arg_fail(3)) SWIG_fail;
4281 }
4282 {
4283 PyThreadState* __tstate = wxPyBeginAllowThreads();
4284 wxRealPoint_Set(arg1,arg2,arg3);
4285
4286 wxPyEndAllowThreads(__tstate);
4287 if (PyErr_Occurred()) SWIG_fail;
4288 }
4289 Py_INCREF(Py_None); resultobj = Py_None;
4290 return resultobj;
4291 fail:
4292 return NULL;
4293 }
4294
4295
4296 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4297 PyObject *resultobj;
4298 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4299 PyObject *result;
4300 PyObject * obj0 = 0 ;
4301 char *kwnames[] = {
4302 (char *) "self", NULL
4303 };
4304
4305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4307 if (SWIG_arg_fail(1)) SWIG_fail;
4308 {
4309 PyThreadState* __tstate = wxPyBeginAllowThreads();
4310 result = (PyObject *)wxRealPoint_Get(arg1);
4311
4312 wxPyEndAllowThreads(__tstate);
4313 if (PyErr_Occurred()) SWIG_fail;
4314 }
4315 resultobj = result;
4316 return resultobj;
4317 fail:
4318 return NULL;
4319 }
4320
4321
4322 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4323 PyObject *obj;
4324 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4325 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4326 Py_INCREF(obj);
4327 return Py_BuildValue((char *)"");
4328 }
4329 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4330 PyObject *resultobj;
4331 wxPoint *arg1 = (wxPoint *) 0 ;
4332 int arg2 ;
4333 PyObject * obj0 = 0 ;
4334 PyObject * obj1 = 0 ;
4335 char *kwnames[] = {
4336 (char *) "self",(char *) "x", NULL
4337 };
4338
4339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4341 if (SWIG_arg_fail(1)) SWIG_fail;
4342 {
4343 arg2 = (int)(SWIG_As_int(obj1));
4344 if (SWIG_arg_fail(2)) SWIG_fail;
4345 }
4346 if (arg1) (arg1)->x = arg2;
4347
4348 Py_INCREF(Py_None); resultobj = Py_None;
4349 return resultobj;
4350 fail:
4351 return NULL;
4352 }
4353
4354
4355 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4356 PyObject *resultobj;
4357 wxPoint *arg1 = (wxPoint *) 0 ;
4358 int result;
4359 PyObject * obj0 = 0 ;
4360 char *kwnames[] = {
4361 (char *) "self", NULL
4362 };
4363
4364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4366 if (SWIG_arg_fail(1)) SWIG_fail;
4367 result = (int) ((arg1)->x);
4368
4369 {
4370 resultobj = SWIG_From_int((int)(result));
4371 }
4372 return resultobj;
4373 fail:
4374 return NULL;
4375 }
4376
4377
4378 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4379 PyObject *resultobj;
4380 wxPoint *arg1 = (wxPoint *) 0 ;
4381 int arg2 ;
4382 PyObject * obj0 = 0 ;
4383 PyObject * obj1 = 0 ;
4384 char *kwnames[] = {
4385 (char *) "self",(char *) "y", NULL
4386 };
4387
4388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4390 if (SWIG_arg_fail(1)) SWIG_fail;
4391 {
4392 arg2 = (int)(SWIG_As_int(obj1));
4393 if (SWIG_arg_fail(2)) SWIG_fail;
4394 }
4395 if (arg1) (arg1)->y = arg2;
4396
4397 Py_INCREF(Py_None); resultobj = Py_None;
4398 return resultobj;
4399 fail:
4400 return NULL;
4401 }
4402
4403
4404 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4405 PyObject *resultobj;
4406 wxPoint *arg1 = (wxPoint *) 0 ;
4407 int result;
4408 PyObject * obj0 = 0 ;
4409 char *kwnames[] = {
4410 (char *) "self", NULL
4411 };
4412
4413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4415 if (SWIG_arg_fail(1)) SWIG_fail;
4416 result = (int) ((arg1)->y);
4417
4418 {
4419 resultobj = SWIG_From_int((int)(result));
4420 }
4421 return resultobj;
4422 fail:
4423 return NULL;
4424 }
4425
4426
4427 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4428 PyObject *resultobj;
4429 int arg1 = (int) 0 ;
4430 int arg2 = (int) 0 ;
4431 wxPoint *result;
4432 PyObject * obj0 = 0 ;
4433 PyObject * obj1 = 0 ;
4434 char *kwnames[] = {
4435 (char *) "x",(char *) "y", NULL
4436 };
4437
4438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4439 if (obj0) {
4440 {
4441 arg1 = (int)(SWIG_As_int(obj0));
4442 if (SWIG_arg_fail(1)) SWIG_fail;
4443 }
4444 }
4445 if (obj1) {
4446 {
4447 arg2 = (int)(SWIG_As_int(obj1));
4448 if (SWIG_arg_fail(2)) SWIG_fail;
4449 }
4450 }
4451 {
4452 PyThreadState* __tstate = wxPyBeginAllowThreads();
4453 result = (wxPoint *)new wxPoint(arg1,arg2);
4454
4455 wxPyEndAllowThreads(__tstate);
4456 if (PyErr_Occurred()) SWIG_fail;
4457 }
4458 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4459 return resultobj;
4460 fail:
4461 return NULL;
4462 }
4463
4464
4465 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4466 PyObject *resultobj;
4467 wxPoint *arg1 = (wxPoint *) 0 ;
4468 PyObject * obj0 = 0 ;
4469 char *kwnames[] = {
4470 (char *) "self", NULL
4471 };
4472
4473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4475 if (SWIG_arg_fail(1)) SWIG_fail;
4476 {
4477 PyThreadState* __tstate = wxPyBeginAllowThreads();
4478 delete arg1;
4479
4480 wxPyEndAllowThreads(__tstate);
4481 if (PyErr_Occurred()) SWIG_fail;
4482 }
4483 Py_INCREF(Py_None); resultobj = Py_None;
4484 return resultobj;
4485 fail:
4486 return NULL;
4487 }
4488
4489
4490 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4491 PyObject *resultobj;
4492 wxPoint *arg1 = (wxPoint *) 0 ;
4493 wxPoint *arg2 = 0 ;
4494 bool result;
4495 wxPoint temp2 ;
4496 PyObject * obj0 = 0 ;
4497 PyObject * obj1 = 0 ;
4498 char *kwnames[] = {
4499 (char *) "self",(char *) "pt", NULL
4500 };
4501
4502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4504 if (SWIG_arg_fail(1)) SWIG_fail;
4505 {
4506 arg2 = &temp2;
4507 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4508 }
4509 {
4510 PyThreadState* __tstate = wxPyBeginAllowThreads();
4511 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4512
4513 wxPyEndAllowThreads(__tstate);
4514 if (PyErr_Occurred()) SWIG_fail;
4515 }
4516 {
4517 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4518 }
4519 return resultobj;
4520 fail:
4521 return NULL;
4522 }
4523
4524
4525 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4526 PyObject *resultobj;
4527 wxPoint *arg1 = (wxPoint *) 0 ;
4528 wxPoint *arg2 = 0 ;
4529 bool result;
4530 wxPoint temp2 ;
4531 PyObject * obj0 = 0 ;
4532 PyObject * obj1 = 0 ;
4533 char *kwnames[] = {
4534 (char *) "self",(char *) "pt", NULL
4535 };
4536
4537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4539 if (SWIG_arg_fail(1)) SWIG_fail;
4540 {
4541 arg2 = &temp2;
4542 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4543 }
4544 {
4545 PyThreadState* __tstate = wxPyBeginAllowThreads();
4546 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4547
4548 wxPyEndAllowThreads(__tstate);
4549 if (PyErr_Occurred()) SWIG_fail;
4550 }
4551 {
4552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4553 }
4554 return resultobj;
4555 fail:
4556 return NULL;
4557 }
4558
4559
4560 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4561 PyObject *resultobj;
4562 wxPoint *arg1 = (wxPoint *) 0 ;
4563 wxPoint *arg2 = 0 ;
4564 wxPoint result;
4565 wxPoint temp2 ;
4566 PyObject * obj0 = 0 ;
4567 PyObject * obj1 = 0 ;
4568 char *kwnames[] = {
4569 (char *) "self",(char *) "pt", NULL
4570 };
4571
4572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4574 if (SWIG_arg_fail(1)) SWIG_fail;
4575 {
4576 arg2 = &temp2;
4577 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4578 }
4579 {
4580 PyThreadState* __tstate = wxPyBeginAllowThreads();
4581 result = (arg1)->operator +((wxPoint const &)*arg2);
4582
4583 wxPyEndAllowThreads(__tstate);
4584 if (PyErr_Occurred()) SWIG_fail;
4585 }
4586 {
4587 wxPoint * resultptr;
4588 resultptr = new wxPoint((wxPoint &)(result));
4589 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4590 }
4591 return resultobj;
4592 fail:
4593 return NULL;
4594 }
4595
4596
4597 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4598 PyObject *resultobj;
4599 wxPoint *arg1 = (wxPoint *) 0 ;
4600 wxPoint *arg2 = 0 ;
4601 wxPoint result;
4602 wxPoint temp2 ;
4603 PyObject * obj0 = 0 ;
4604 PyObject * obj1 = 0 ;
4605 char *kwnames[] = {
4606 (char *) "self",(char *) "pt", NULL
4607 };
4608
4609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4611 if (SWIG_arg_fail(1)) SWIG_fail;
4612 {
4613 arg2 = &temp2;
4614 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4615 }
4616 {
4617 PyThreadState* __tstate = wxPyBeginAllowThreads();
4618 result = (arg1)->operator -((wxPoint const &)*arg2);
4619
4620 wxPyEndAllowThreads(__tstate);
4621 if (PyErr_Occurred()) SWIG_fail;
4622 }
4623 {
4624 wxPoint * resultptr;
4625 resultptr = new wxPoint((wxPoint &)(result));
4626 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4627 }
4628 return resultobj;
4629 fail:
4630 return NULL;
4631 }
4632
4633
4634 static PyObject *_wrap_Point___iadd__(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___iadd__",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___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4671 PyObject *resultobj;
4672 wxPoint *arg1 = (wxPoint *) 0 ;
4673 wxPoint *arg2 = 0 ;
4674 wxPoint *result;
4675 wxPoint temp2 ;
4676 PyObject * obj0 = 0 ;
4677 PyObject * obj1 = 0 ;
4678 char *kwnames[] = {
4679 (char *) "self",(char *) "pt", NULL
4680 };
4681
4682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4684 if (SWIG_arg_fail(1)) SWIG_fail;
4685 {
4686 arg2 = &temp2;
4687 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4688 }
4689 {
4690 PyThreadState* __tstate = wxPyBeginAllowThreads();
4691 {
4692 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4693 result = (wxPoint *) &_result_ref;
4694 }
4695
4696 wxPyEndAllowThreads(__tstate);
4697 if (PyErr_Occurred()) SWIG_fail;
4698 }
4699 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4700 return resultobj;
4701 fail:
4702 return NULL;
4703 }
4704
4705
4706 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4707 PyObject *resultobj;
4708 wxPoint *arg1 = (wxPoint *) 0 ;
4709 long arg2 ;
4710 long arg3 ;
4711 PyObject * obj0 = 0 ;
4712 PyObject * obj1 = 0 ;
4713 PyObject * obj2 = 0 ;
4714 char *kwnames[] = {
4715 (char *) "self",(char *) "x",(char *) "y", NULL
4716 };
4717
4718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4720 if (SWIG_arg_fail(1)) SWIG_fail;
4721 {
4722 arg2 = (long)(SWIG_As_long(obj1));
4723 if (SWIG_arg_fail(2)) SWIG_fail;
4724 }
4725 {
4726 arg3 = (long)(SWIG_As_long(obj2));
4727 if (SWIG_arg_fail(3)) SWIG_fail;
4728 }
4729 {
4730 PyThreadState* __tstate = wxPyBeginAllowThreads();
4731 wxPoint_Set(arg1,arg2,arg3);
4732
4733 wxPyEndAllowThreads(__tstate);
4734 if (PyErr_Occurred()) SWIG_fail;
4735 }
4736 Py_INCREF(Py_None); resultobj = Py_None;
4737 return resultobj;
4738 fail:
4739 return NULL;
4740 }
4741
4742
4743 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4744 PyObject *resultobj;
4745 wxPoint *arg1 = (wxPoint *) 0 ;
4746 PyObject *result;
4747 PyObject * obj0 = 0 ;
4748 char *kwnames[] = {
4749 (char *) "self", NULL
4750 };
4751
4752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4754 if (SWIG_arg_fail(1)) SWIG_fail;
4755 {
4756 PyThreadState* __tstate = wxPyBeginAllowThreads();
4757 result = (PyObject *)wxPoint_Get(arg1);
4758
4759 wxPyEndAllowThreads(__tstate);
4760 if (PyErr_Occurred()) SWIG_fail;
4761 }
4762 resultobj = result;
4763 return resultobj;
4764 fail:
4765 return NULL;
4766 }
4767
4768
4769 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4770 PyObject *obj;
4771 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4772 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4773 Py_INCREF(obj);
4774 return Py_BuildValue((char *)"");
4775 }
4776 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4777 PyObject *resultobj;
4778 int arg1 = (int) 0 ;
4779 int arg2 = (int) 0 ;
4780 int arg3 = (int) 0 ;
4781 int arg4 = (int) 0 ;
4782 wxRect *result;
4783 PyObject * obj0 = 0 ;
4784 PyObject * obj1 = 0 ;
4785 PyObject * obj2 = 0 ;
4786 PyObject * obj3 = 0 ;
4787 char *kwnames[] = {
4788 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4789 };
4790
4791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4792 if (obj0) {
4793 {
4794 arg1 = (int)(SWIG_As_int(obj0));
4795 if (SWIG_arg_fail(1)) SWIG_fail;
4796 }
4797 }
4798 if (obj1) {
4799 {
4800 arg2 = (int)(SWIG_As_int(obj1));
4801 if (SWIG_arg_fail(2)) SWIG_fail;
4802 }
4803 }
4804 if (obj2) {
4805 {
4806 arg3 = (int)(SWIG_As_int(obj2));
4807 if (SWIG_arg_fail(3)) SWIG_fail;
4808 }
4809 }
4810 if (obj3) {
4811 {
4812 arg4 = (int)(SWIG_As_int(obj3));
4813 if (SWIG_arg_fail(4)) SWIG_fail;
4814 }
4815 }
4816 {
4817 PyThreadState* __tstate = wxPyBeginAllowThreads();
4818 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
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_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4831 PyObject *resultobj;
4832 wxPoint *arg1 = 0 ;
4833 wxPoint *arg2 = 0 ;
4834 wxRect *result;
4835 wxPoint temp1 ;
4836 wxPoint temp2 ;
4837 PyObject * obj0 = 0 ;
4838 PyObject * obj1 = 0 ;
4839 char *kwnames[] = {
4840 (char *) "topLeft",(char *) "bottomRight", NULL
4841 };
4842
4843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4844 {
4845 arg1 = &temp1;
4846 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4847 }
4848 {
4849 arg2 = &temp2;
4850 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4851 }
4852 {
4853 PyThreadState* __tstate = wxPyBeginAllowThreads();
4854 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint 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_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4867 PyObject *resultobj;
4868 wxPoint *arg1 = 0 ;
4869 wxSize *arg2 = 0 ;
4870 wxRect *result;
4871 wxPoint temp1 ;
4872 wxSize temp2 ;
4873 PyObject * obj0 = 0 ;
4874 PyObject * obj1 = 0 ;
4875 char *kwnames[] = {
4876 (char *) "pos",(char *) "size", NULL
4877 };
4878
4879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4880 {
4881 arg1 = &temp1;
4882 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4883 }
4884 {
4885 arg2 = &temp2;
4886 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4887 }
4888 {
4889 PyThreadState* __tstate = wxPyBeginAllowThreads();
4890 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4891
4892 wxPyEndAllowThreads(__tstate);
4893 if (PyErr_Occurred()) SWIG_fail;
4894 }
4895 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4896 return resultobj;
4897 fail:
4898 return NULL;
4899 }
4900
4901
4902 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4903 PyObject *resultobj;
4904 wxSize *arg1 = 0 ;
4905 wxRect *result;
4906 wxSize temp1 ;
4907 PyObject * obj0 = 0 ;
4908 char *kwnames[] = {
4909 (char *) "size", NULL
4910 };
4911
4912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4913 {
4914 arg1 = &temp1;
4915 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4916 }
4917 {
4918 PyThreadState* __tstate = wxPyBeginAllowThreads();
4919 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4920
4921 wxPyEndAllowThreads(__tstate);
4922 if (PyErr_Occurred()) SWIG_fail;
4923 }
4924 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4925 return resultobj;
4926 fail:
4927 return NULL;
4928 }
4929
4930
4931 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4932 PyObject *resultobj;
4933 wxRect *arg1 = (wxRect *) 0 ;
4934 PyObject * obj0 = 0 ;
4935 char *kwnames[] = {
4936 (char *) "self", NULL
4937 };
4938
4939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4941 if (SWIG_arg_fail(1)) SWIG_fail;
4942 {
4943 PyThreadState* __tstate = wxPyBeginAllowThreads();
4944 delete arg1;
4945
4946 wxPyEndAllowThreads(__tstate);
4947 if (PyErr_Occurred()) SWIG_fail;
4948 }
4949 Py_INCREF(Py_None); resultobj = Py_None;
4950 return resultobj;
4951 fail:
4952 return NULL;
4953 }
4954
4955
4956 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4957 PyObject *resultobj;
4958 wxRect *arg1 = (wxRect *) 0 ;
4959 int result;
4960 PyObject * obj0 = 0 ;
4961 char *kwnames[] = {
4962 (char *) "self", NULL
4963 };
4964
4965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4967 if (SWIG_arg_fail(1)) SWIG_fail;
4968 {
4969 PyThreadState* __tstate = wxPyBeginAllowThreads();
4970 result = (int)((wxRect const *)arg1)->GetX();
4971
4972 wxPyEndAllowThreads(__tstate);
4973 if (PyErr_Occurred()) SWIG_fail;
4974 }
4975 {
4976 resultobj = SWIG_From_int((int)(result));
4977 }
4978 return resultobj;
4979 fail:
4980 return NULL;
4981 }
4982
4983
4984 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4985 PyObject *resultobj;
4986 wxRect *arg1 = (wxRect *) 0 ;
4987 int arg2 ;
4988 PyObject * obj0 = 0 ;
4989 PyObject * obj1 = 0 ;
4990 char *kwnames[] = {
4991 (char *) "self",(char *) "x", NULL
4992 };
4993
4994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4996 if (SWIG_arg_fail(1)) SWIG_fail;
4997 {
4998 arg2 = (int)(SWIG_As_int(obj1));
4999 if (SWIG_arg_fail(2)) SWIG_fail;
5000 }
5001 {
5002 PyThreadState* __tstate = wxPyBeginAllowThreads();
5003 (arg1)->SetX(arg2);
5004
5005 wxPyEndAllowThreads(__tstate);
5006 if (PyErr_Occurred()) SWIG_fail;
5007 }
5008 Py_INCREF(Py_None); resultobj = Py_None;
5009 return resultobj;
5010 fail:
5011 return NULL;
5012 }
5013
5014
5015 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5016 PyObject *resultobj;
5017 wxRect *arg1 = (wxRect *) 0 ;
5018 int result;
5019 PyObject * obj0 = 0 ;
5020 char *kwnames[] = {
5021 (char *) "self", NULL
5022 };
5023
5024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5026 if (SWIG_arg_fail(1)) SWIG_fail;
5027 {
5028 PyThreadState* __tstate = wxPyBeginAllowThreads();
5029 result = (int)(arg1)->GetY();
5030
5031 wxPyEndAllowThreads(__tstate);
5032 if (PyErr_Occurred()) SWIG_fail;
5033 }
5034 {
5035 resultobj = SWIG_From_int((int)(result));
5036 }
5037 return resultobj;
5038 fail:
5039 return NULL;
5040 }
5041
5042
5043 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5044 PyObject *resultobj;
5045 wxRect *arg1 = (wxRect *) 0 ;
5046 int arg2 ;
5047 PyObject * obj0 = 0 ;
5048 PyObject * obj1 = 0 ;
5049 char *kwnames[] = {
5050 (char *) "self",(char *) "y", NULL
5051 };
5052
5053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5055 if (SWIG_arg_fail(1)) SWIG_fail;
5056 {
5057 arg2 = (int)(SWIG_As_int(obj1));
5058 if (SWIG_arg_fail(2)) SWIG_fail;
5059 }
5060 {
5061 PyThreadState* __tstate = wxPyBeginAllowThreads();
5062 (arg1)->SetY(arg2);
5063
5064 wxPyEndAllowThreads(__tstate);
5065 if (PyErr_Occurred()) SWIG_fail;
5066 }
5067 Py_INCREF(Py_None); resultobj = Py_None;
5068 return resultobj;
5069 fail:
5070 return NULL;
5071 }
5072
5073
5074 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5075 PyObject *resultobj;
5076 wxRect *arg1 = (wxRect *) 0 ;
5077 int result;
5078 PyObject * obj0 = 0 ;
5079 char *kwnames[] = {
5080 (char *) "self", NULL
5081 };
5082
5083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5085 if (SWIG_arg_fail(1)) SWIG_fail;
5086 {
5087 PyThreadState* __tstate = wxPyBeginAllowThreads();
5088 result = (int)((wxRect const *)arg1)->GetWidth();
5089
5090 wxPyEndAllowThreads(__tstate);
5091 if (PyErr_Occurred()) SWIG_fail;
5092 }
5093 {
5094 resultobj = SWIG_From_int((int)(result));
5095 }
5096 return resultobj;
5097 fail:
5098 return NULL;
5099 }
5100
5101
5102 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5103 PyObject *resultobj;
5104 wxRect *arg1 = (wxRect *) 0 ;
5105 int arg2 ;
5106 PyObject * obj0 = 0 ;
5107 PyObject * obj1 = 0 ;
5108 char *kwnames[] = {
5109 (char *) "self",(char *) "w", NULL
5110 };
5111
5112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5114 if (SWIG_arg_fail(1)) SWIG_fail;
5115 {
5116 arg2 = (int)(SWIG_As_int(obj1));
5117 if (SWIG_arg_fail(2)) SWIG_fail;
5118 }
5119 {
5120 PyThreadState* __tstate = wxPyBeginAllowThreads();
5121 (arg1)->SetWidth(arg2);
5122
5123 wxPyEndAllowThreads(__tstate);
5124 if (PyErr_Occurred()) SWIG_fail;
5125 }
5126 Py_INCREF(Py_None); resultobj = Py_None;
5127 return resultobj;
5128 fail:
5129 return NULL;
5130 }
5131
5132
5133 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5134 PyObject *resultobj;
5135 wxRect *arg1 = (wxRect *) 0 ;
5136 int result;
5137 PyObject * obj0 = 0 ;
5138 char *kwnames[] = {
5139 (char *) "self", NULL
5140 };
5141
5142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5144 if (SWIG_arg_fail(1)) SWIG_fail;
5145 {
5146 PyThreadState* __tstate = wxPyBeginAllowThreads();
5147 result = (int)((wxRect const *)arg1)->GetHeight();
5148
5149 wxPyEndAllowThreads(__tstate);
5150 if (PyErr_Occurred()) SWIG_fail;
5151 }
5152 {
5153 resultobj = SWIG_From_int((int)(result));
5154 }
5155 return resultobj;
5156 fail:
5157 return NULL;
5158 }
5159
5160
5161 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5162 PyObject *resultobj;
5163 wxRect *arg1 = (wxRect *) 0 ;
5164 int arg2 ;
5165 PyObject * obj0 = 0 ;
5166 PyObject * obj1 = 0 ;
5167 char *kwnames[] = {
5168 (char *) "self",(char *) "h", NULL
5169 };
5170
5171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5173 if (SWIG_arg_fail(1)) SWIG_fail;
5174 {
5175 arg2 = (int)(SWIG_As_int(obj1));
5176 if (SWIG_arg_fail(2)) SWIG_fail;
5177 }
5178 {
5179 PyThreadState* __tstate = wxPyBeginAllowThreads();
5180 (arg1)->SetHeight(arg2);
5181
5182 wxPyEndAllowThreads(__tstate);
5183 if (PyErr_Occurred()) SWIG_fail;
5184 }
5185 Py_INCREF(Py_None); resultobj = Py_None;
5186 return resultobj;
5187 fail:
5188 return NULL;
5189 }
5190
5191
5192 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5193 PyObject *resultobj;
5194 wxRect *arg1 = (wxRect *) 0 ;
5195 wxPoint result;
5196 PyObject * obj0 = 0 ;
5197 char *kwnames[] = {
5198 (char *) "self", NULL
5199 };
5200
5201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5203 if (SWIG_arg_fail(1)) SWIG_fail;
5204 {
5205 PyThreadState* __tstate = wxPyBeginAllowThreads();
5206 result = ((wxRect const *)arg1)->GetPosition();
5207
5208 wxPyEndAllowThreads(__tstate);
5209 if (PyErr_Occurred()) SWIG_fail;
5210 }
5211 {
5212 wxPoint * resultptr;
5213 resultptr = new wxPoint((wxPoint &)(result));
5214 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5215 }
5216 return resultobj;
5217 fail:
5218 return NULL;
5219 }
5220
5221
5222 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5223 PyObject *resultobj;
5224 wxRect *arg1 = (wxRect *) 0 ;
5225 wxPoint *arg2 = 0 ;
5226 wxPoint temp2 ;
5227 PyObject * obj0 = 0 ;
5228 PyObject * obj1 = 0 ;
5229 char *kwnames[] = {
5230 (char *) "self",(char *) "p", NULL
5231 };
5232
5233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5235 if (SWIG_arg_fail(1)) SWIG_fail;
5236 {
5237 arg2 = &temp2;
5238 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5239 }
5240 {
5241 PyThreadState* __tstate = wxPyBeginAllowThreads();
5242 (arg1)->SetPosition((wxPoint const &)*arg2);
5243
5244 wxPyEndAllowThreads(__tstate);
5245 if (PyErr_Occurred()) SWIG_fail;
5246 }
5247 Py_INCREF(Py_None); resultobj = Py_None;
5248 return resultobj;
5249 fail:
5250 return NULL;
5251 }
5252
5253
5254 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5255 PyObject *resultobj;
5256 wxRect *arg1 = (wxRect *) 0 ;
5257 wxSize result;
5258 PyObject * obj0 = 0 ;
5259 char *kwnames[] = {
5260 (char *) "self", NULL
5261 };
5262
5263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5265 if (SWIG_arg_fail(1)) SWIG_fail;
5266 {
5267 PyThreadState* __tstate = wxPyBeginAllowThreads();
5268 result = ((wxRect const *)arg1)->GetSize();
5269
5270 wxPyEndAllowThreads(__tstate);
5271 if (PyErr_Occurred()) SWIG_fail;
5272 }
5273 {
5274 wxSize * resultptr;
5275 resultptr = new wxSize((wxSize &)(result));
5276 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5277 }
5278 return resultobj;
5279 fail:
5280 return NULL;
5281 }
5282
5283
5284 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5285 PyObject *resultobj;
5286 wxRect *arg1 = (wxRect *) 0 ;
5287 wxSize *arg2 = 0 ;
5288 wxSize temp2 ;
5289 PyObject * obj0 = 0 ;
5290 PyObject * obj1 = 0 ;
5291 char *kwnames[] = {
5292 (char *) "self",(char *) "s", NULL
5293 };
5294
5295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5297 if (SWIG_arg_fail(1)) SWIG_fail;
5298 {
5299 arg2 = &temp2;
5300 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5301 }
5302 {
5303 PyThreadState* __tstate = wxPyBeginAllowThreads();
5304 (arg1)->SetSize((wxSize const &)*arg2);
5305
5306 wxPyEndAllowThreads(__tstate);
5307 if (PyErr_Occurred()) SWIG_fail;
5308 }
5309 Py_INCREF(Py_None); resultobj = Py_None;
5310 return resultobj;
5311 fail:
5312 return NULL;
5313 }
5314
5315
5316 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5317 PyObject *resultobj;
5318 wxRect *arg1 = (wxRect *) 0 ;
5319 bool result;
5320 PyObject * obj0 = 0 ;
5321 char *kwnames[] = {
5322 (char *) "self", NULL
5323 };
5324
5325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5327 if (SWIG_arg_fail(1)) SWIG_fail;
5328 {
5329 PyThreadState* __tstate = wxPyBeginAllowThreads();
5330 result = (bool)((wxRect const *)arg1)->IsEmpty();
5331
5332 wxPyEndAllowThreads(__tstate);
5333 if (PyErr_Occurred()) SWIG_fail;
5334 }
5335 {
5336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5337 }
5338 return resultobj;
5339 fail:
5340 return NULL;
5341 }
5342
5343
5344 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5345 PyObject *resultobj;
5346 wxRect *arg1 = (wxRect *) 0 ;
5347 wxPoint result;
5348 PyObject * obj0 = 0 ;
5349 char *kwnames[] = {
5350 (char *) "self", NULL
5351 };
5352
5353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5355 if (SWIG_arg_fail(1)) SWIG_fail;
5356 {
5357 PyThreadState* __tstate = wxPyBeginAllowThreads();
5358 result = ((wxRect const *)arg1)->GetTopLeft();
5359
5360 wxPyEndAllowThreads(__tstate);
5361 if (PyErr_Occurred()) SWIG_fail;
5362 }
5363 {
5364 wxPoint * resultptr;
5365 resultptr = new wxPoint((wxPoint &)(result));
5366 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5367 }
5368 return resultobj;
5369 fail:
5370 return NULL;
5371 }
5372
5373
5374 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5375 PyObject *resultobj;
5376 wxRect *arg1 = (wxRect *) 0 ;
5377 wxPoint *arg2 = 0 ;
5378 wxPoint temp2 ;
5379 PyObject * obj0 = 0 ;
5380 PyObject * obj1 = 0 ;
5381 char *kwnames[] = {
5382 (char *) "self",(char *) "p", NULL
5383 };
5384
5385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5387 if (SWIG_arg_fail(1)) SWIG_fail;
5388 {
5389 arg2 = &temp2;
5390 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5391 }
5392 {
5393 PyThreadState* __tstate = wxPyBeginAllowThreads();
5394 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5395
5396 wxPyEndAllowThreads(__tstate);
5397 if (PyErr_Occurred()) SWIG_fail;
5398 }
5399 Py_INCREF(Py_None); resultobj = Py_None;
5400 return resultobj;
5401 fail:
5402 return NULL;
5403 }
5404
5405
5406 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5407 PyObject *resultobj;
5408 wxRect *arg1 = (wxRect *) 0 ;
5409 wxPoint result;
5410 PyObject * obj0 = 0 ;
5411 char *kwnames[] = {
5412 (char *) "self", NULL
5413 };
5414
5415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5417 if (SWIG_arg_fail(1)) SWIG_fail;
5418 {
5419 PyThreadState* __tstate = wxPyBeginAllowThreads();
5420 result = ((wxRect const *)arg1)->GetBottomRight();
5421
5422 wxPyEndAllowThreads(__tstate);
5423 if (PyErr_Occurred()) SWIG_fail;
5424 }
5425 {
5426 wxPoint * resultptr;
5427 resultptr = new wxPoint((wxPoint &)(result));
5428 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5429 }
5430 return resultobj;
5431 fail:
5432 return NULL;
5433 }
5434
5435
5436 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5437 PyObject *resultobj;
5438 wxRect *arg1 = (wxRect *) 0 ;
5439 wxPoint *arg2 = 0 ;
5440 wxPoint temp2 ;
5441 PyObject * obj0 = 0 ;
5442 PyObject * obj1 = 0 ;
5443 char *kwnames[] = {
5444 (char *) "self",(char *) "p", NULL
5445 };
5446
5447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5449 if (SWIG_arg_fail(1)) SWIG_fail;
5450 {
5451 arg2 = &temp2;
5452 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5453 }
5454 {
5455 PyThreadState* __tstate = wxPyBeginAllowThreads();
5456 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5457
5458 wxPyEndAllowThreads(__tstate);
5459 if (PyErr_Occurred()) SWIG_fail;
5460 }
5461 Py_INCREF(Py_None); resultobj = Py_None;
5462 return resultobj;
5463 fail:
5464 return NULL;
5465 }
5466
5467
5468 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5469 PyObject *resultobj;
5470 wxRect *arg1 = (wxRect *) 0 ;
5471 int result;
5472 PyObject * obj0 = 0 ;
5473 char *kwnames[] = {
5474 (char *) "self", NULL
5475 };
5476
5477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5479 if (SWIG_arg_fail(1)) SWIG_fail;
5480 {
5481 PyThreadState* __tstate = wxPyBeginAllowThreads();
5482 result = (int)((wxRect const *)arg1)->GetLeft();
5483
5484 wxPyEndAllowThreads(__tstate);
5485 if (PyErr_Occurred()) SWIG_fail;
5486 }
5487 {
5488 resultobj = SWIG_From_int((int)(result));
5489 }
5490 return resultobj;
5491 fail:
5492 return NULL;
5493 }
5494
5495
5496 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5497 PyObject *resultobj;
5498 wxRect *arg1 = (wxRect *) 0 ;
5499 int result;
5500 PyObject * obj0 = 0 ;
5501 char *kwnames[] = {
5502 (char *) "self", NULL
5503 };
5504
5505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5507 if (SWIG_arg_fail(1)) SWIG_fail;
5508 {
5509 PyThreadState* __tstate = wxPyBeginAllowThreads();
5510 result = (int)((wxRect const *)arg1)->GetTop();
5511
5512 wxPyEndAllowThreads(__tstate);
5513 if (PyErr_Occurred()) SWIG_fail;
5514 }
5515 {
5516 resultobj = SWIG_From_int((int)(result));
5517 }
5518 return resultobj;
5519 fail:
5520 return NULL;
5521 }
5522
5523
5524 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5525 PyObject *resultobj;
5526 wxRect *arg1 = (wxRect *) 0 ;
5527 int result;
5528 PyObject * obj0 = 0 ;
5529 char *kwnames[] = {
5530 (char *) "self", NULL
5531 };
5532
5533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5535 if (SWIG_arg_fail(1)) SWIG_fail;
5536 {
5537 PyThreadState* __tstate = wxPyBeginAllowThreads();
5538 result = (int)((wxRect const *)arg1)->GetBottom();
5539
5540 wxPyEndAllowThreads(__tstate);
5541 if (PyErr_Occurred()) SWIG_fail;
5542 }
5543 {
5544 resultobj = SWIG_From_int((int)(result));
5545 }
5546 return resultobj;
5547 fail:
5548 return NULL;
5549 }
5550
5551
5552 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5553 PyObject *resultobj;
5554 wxRect *arg1 = (wxRect *) 0 ;
5555 int result;
5556 PyObject * obj0 = 0 ;
5557 char *kwnames[] = {
5558 (char *) "self", NULL
5559 };
5560
5561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5563 if (SWIG_arg_fail(1)) SWIG_fail;
5564 {
5565 PyThreadState* __tstate = wxPyBeginAllowThreads();
5566 result = (int)((wxRect const *)arg1)->GetRight();
5567
5568 wxPyEndAllowThreads(__tstate);
5569 if (PyErr_Occurred()) SWIG_fail;
5570 }
5571 {
5572 resultobj = SWIG_From_int((int)(result));
5573 }
5574 return resultobj;
5575 fail:
5576 return NULL;
5577 }
5578
5579
5580 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5581 PyObject *resultobj;
5582 wxRect *arg1 = (wxRect *) 0 ;
5583 int arg2 ;
5584 PyObject * obj0 = 0 ;
5585 PyObject * obj1 = 0 ;
5586 char *kwnames[] = {
5587 (char *) "self",(char *) "left", NULL
5588 };
5589
5590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5592 if (SWIG_arg_fail(1)) SWIG_fail;
5593 {
5594 arg2 = (int)(SWIG_As_int(obj1));
5595 if (SWIG_arg_fail(2)) SWIG_fail;
5596 }
5597 {
5598 PyThreadState* __tstate = wxPyBeginAllowThreads();
5599 (arg1)->SetLeft(arg2);
5600
5601 wxPyEndAllowThreads(__tstate);
5602 if (PyErr_Occurred()) SWIG_fail;
5603 }
5604 Py_INCREF(Py_None); resultobj = Py_None;
5605 return resultobj;
5606 fail:
5607 return NULL;
5608 }
5609
5610
5611 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5612 PyObject *resultobj;
5613 wxRect *arg1 = (wxRect *) 0 ;
5614 int arg2 ;
5615 PyObject * obj0 = 0 ;
5616 PyObject * obj1 = 0 ;
5617 char *kwnames[] = {
5618 (char *) "self",(char *) "right", NULL
5619 };
5620
5621 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5622 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5623 if (SWIG_arg_fail(1)) SWIG_fail;
5624 {
5625 arg2 = (int)(SWIG_As_int(obj1));
5626 if (SWIG_arg_fail(2)) SWIG_fail;
5627 }
5628 {
5629 PyThreadState* __tstate = wxPyBeginAllowThreads();
5630 (arg1)->SetRight(arg2);
5631
5632 wxPyEndAllowThreads(__tstate);
5633 if (PyErr_Occurred()) SWIG_fail;
5634 }
5635 Py_INCREF(Py_None); resultobj = Py_None;
5636 return resultobj;
5637 fail:
5638 return NULL;
5639 }
5640
5641
5642 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5643 PyObject *resultobj;
5644 wxRect *arg1 = (wxRect *) 0 ;
5645 int arg2 ;
5646 PyObject * obj0 = 0 ;
5647 PyObject * obj1 = 0 ;
5648 char *kwnames[] = {
5649 (char *) "self",(char *) "top", NULL
5650 };
5651
5652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5654 if (SWIG_arg_fail(1)) SWIG_fail;
5655 {
5656 arg2 = (int)(SWIG_As_int(obj1));
5657 if (SWIG_arg_fail(2)) SWIG_fail;
5658 }
5659 {
5660 PyThreadState* __tstate = wxPyBeginAllowThreads();
5661 (arg1)->SetTop(arg2);
5662
5663 wxPyEndAllowThreads(__tstate);
5664 if (PyErr_Occurred()) SWIG_fail;
5665 }
5666 Py_INCREF(Py_None); resultobj = Py_None;
5667 return resultobj;
5668 fail:
5669 return NULL;
5670 }
5671
5672
5673 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5674 PyObject *resultobj;
5675 wxRect *arg1 = (wxRect *) 0 ;
5676 int arg2 ;
5677 PyObject * obj0 = 0 ;
5678 PyObject * obj1 = 0 ;
5679 char *kwnames[] = {
5680 (char *) "self",(char *) "bottom", NULL
5681 };
5682
5683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5685 if (SWIG_arg_fail(1)) SWIG_fail;
5686 {
5687 arg2 = (int)(SWIG_As_int(obj1));
5688 if (SWIG_arg_fail(2)) SWIG_fail;
5689 }
5690 {
5691 PyThreadState* __tstate = wxPyBeginAllowThreads();
5692 (arg1)->SetBottom(arg2);
5693
5694 wxPyEndAllowThreads(__tstate);
5695 if (PyErr_Occurred()) SWIG_fail;
5696 }
5697 Py_INCREF(Py_None); resultobj = Py_None;
5698 return resultobj;
5699 fail:
5700 return NULL;
5701 }
5702
5703
5704 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5705 PyObject *resultobj;
5706 wxRect *arg1 = (wxRect *) 0 ;
5707 int arg2 ;
5708 int arg3 ;
5709 wxRect *result;
5710 PyObject * obj0 = 0 ;
5711 PyObject * obj1 = 0 ;
5712 PyObject * obj2 = 0 ;
5713 char *kwnames[] = {
5714 (char *) "self",(char *) "dx",(char *) "dy", NULL
5715 };
5716
5717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5719 if (SWIG_arg_fail(1)) SWIG_fail;
5720 {
5721 arg2 = (int)(SWIG_As_int(obj1));
5722 if (SWIG_arg_fail(2)) SWIG_fail;
5723 }
5724 {
5725 arg3 = (int)(SWIG_As_int(obj2));
5726 if (SWIG_arg_fail(3)) SWIG_fail;
5727 }
5728 {
5729 PyThreadState* __tstate = wxPyBeginAllowThreads();
5730 {
5731 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5732 result = (wxRect *) &_result_ref;
5733 }
5734
5735 wxPyEndAllowThreads(__tstate);
5736 if (PyErr_Occurred()) SWIG_fail;
5737 }
5738 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5739 return resultobj;
5740 fail:
5741 return NULL;
5742 }
5743
5744
5745 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5746 PyObject *resultobj;
5747 wxRect *arg1 = (wxRect *) 0 ;
5748 int arg2 ;
5749 int arg3 ;
5750 wxRect *result;
5751 PyObject * obj0 = 0 ;
5752 PyObject * obj1 = 0 ;
5753 PyObject * obj2 = 0 ;
5754 char *kwnames[] = {
5755 (char *) "self",(char *) "dx",(char *) "dy", NULL
5756 };
5757
5758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5760 if (SWIG_arg_fail(1)) SWIG_fail;
5761 {
5762 arg2 = (int)(SWIG_As_int(obj1));
5763 if (SWIG_arg_fail(2)) SWIG_fail;
5764 }
5765 {
5766 arg3 = (int)(SWIG_As_int(obj2));
5767 if (SWIG_arg_fail(3)) SWIG_fail;
5768 }
5769 {
5770 PyThreadState* __tstate = wxPyBeginAllowThreads();
5771 {
5772 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5773 result = (wxRect *) &_result_ref;
5774 }
5775
5776 wxPyEndAllowThreads(__tstate);
5777 if (PyErr_Occurred()) SWIG_fail;
5778 }
5779 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5780 return resultobj;
5781 fail:
5782 return NULL;
5783 }
5784
5785
5786 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5787 PyObject *resultobj;
5788 wxRect *arg1 = (wxRect *) 0 ;
5789 int arg2 ;
5790 int arg3 ;
5791 PyObject * obj0 = 0 ;
5792 PyObject * obj1 = 0 ;
5793 PyObject * obj2 = 0 ;
5794 char *kwnames[] = {
5795 (char *) "self",(char *) "dx",(char *) "dy", NULL
5796 };
5797
5798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5800 if (SWIG_arg_fail(1)) SWIG_fail;
5801 {
5802 arg2 = (int)(SWIG_As_int(obj1));
5803 if (SWIG_arg_fail(2)) SWIG_fail;
5804 }
5805 {
5806 arg3 = (int)(SWIG_As_int(obj2));
5807 if (SWIG_arg_fail(3)) SWIG_fail;
5808 }
5809 {
5810 PyThreadState* __tstate = wxPyBeginAllowThreads();
5811 (arg1)->Offset(arg2,arg3);
5812
5813 wxPyEndAllowThreads(__tstate);
5814 if (PyErr_Occurred()) SWIG_fail;
5815 }
5816 Py_INCREF(Py_None); resultobj = Py_None;
5817 return resultobj;
5818 fail:
5819 return NULL;
5820 }
5821
5822
5823 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5824 PyObject *resultobj;
5825 wxRect *arg1 = (wxRect *) 0 ;
5826 wxPoint *arg2 = 0 ;
5827 wxPoint temp2 ;
5828 PyObject * obj0 = 0 ;
5829 PyObject * obj1 = 0 ;
5830 char *kwnames[] = {
5831 (char *) "self",(char *) "pt", NULL
5832 };
5833
5834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5836 if (SWIG_arg_fail(1)) SWIG_fail;
5837 {
5838 arg2 = &temp2;
5839 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5840 }
5841 {
5842 PyThreadState* __tstate = wxPyBeginAllowThreads();
5843 (arg1)->Offset((wxPoint const &)*arg2);
5844
5845 wxPyEndAllowThreads(__tstate);
5846 if (PyErr_Occurred()) SWIG_fail;
5847 }
5848 Py_INCREF(Py_None); resultobj = Py_None;
5849 return resultobj;
5850 fail:
5851 return NULL;
5852 }
5853
5854
5855 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5856 PyObject *resultobj;
5857 wxRect *arg1 = (wxRect *) 0 ;
5858 wxRect *arg2 = 0 ;
5859 wxRect result;
5860 wxRect temp2 ;
5861 PyObject * obj0 = 0 ;
5862 PyObject * obj1 = 0 ;
5863 char *kwnames[] = {
5864 (char *) "self",(char *) "rect", NULL
5865 };
5866
5867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5869 if (SWIG_arg_fail(1)) SWIG_fail;
5870 {
5871 arg2 = &temp2;
5872 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5873 }
5874 {
5875 PyThreadState* __tstate = wxPyBeginAllowThreads();
5876 result = (arg1)->Intersect((wxRect const &)*arg2);
5877
5878 wxPyEndAllowThreads(__tstate);
5879 if (PyErr_Occurred()) SWIG_fail;
5880 }
5881 {
5882 wxRect * resultptr;
5883 resultptr = new wxRect((wxRect &)(result));
5884 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5885 }
5886 return resultobj;
5887 fail:
5888 return NULL;
5889 }
5890
5891
5892 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5893 PyObject *resultobj;
5894 wxRect *arg1 = (wxRect *) 0 ;
5895 wxRect *arg2 = 0 ;
5896 wxRect result;
5897 wxRect temp2 ;
5898 PyObject * obj0 = 0 ;
5899 PyObject * obj1 = 0 ;
5900 char *kwnames[] = {
5901 (char *) "self",(char *) "rect", NULL
5902 };
5903
5904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5906 if (SWIG_arg_fail(1)) SWIG_fail;
5907 {
5908 arg2 = &temp2;
5909 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5910 }
5911 {
5912 PyThreadState* __tstate = wxPyBeginAllowThreads();
5913 result = (arg1)->Union((wxRect const &)*arg2);
5914
5915 wxPyEndAllowThreads(__tstate);
5916 if (PyErr_Occurred()) SWIG_fail;
5917 }
5918 {
5919 wxRect * resultptr;
5920 resultptr = new wxRect((wxRect &)(result));
5921 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5922 }
5923 return resultobj;
5924 fail:
5925 return NULL;
5926 }
5927
5928
5929 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5930 PyObject *resultobj;
5931 wxRect *arg1 = (wxRect *) 0 ;
5932 wxRect *arg2 = 0 ;
5933 wxRect result;
5934 wxRect temp2 ;
5935 PyObject * obj0 = 0 ;
5936 PyObject * obj1 = 0 ;
5937 char *kwnames[] = {
5938 (char *) "self",(char *) "rect", NULL
5939 };
5940
5941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5943 if (SWIG_arg_fail(1)) SWIG_fail;
5944 {
5945 arg2 = &temp2;
5946 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5947 }
5948 {
5949 PyThreadState* __tstate = wxPyBeginAllowThreads();
5950 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5951
5952 wxPyEndAllowThreads(__tstate);
5953 if (PyErr_Occurred()) SWIG_fail;
5954 }
5955 {
5956 wxRect * resultptr;
5957 resultptr = new wxRect((wxRect &)(result));
5958 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5959 }
5960 return resultobj;
5961 fail:
5962 return NULL;
5963 }
5964
5965
5966 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5967 PyObject *resultobj;
5968 wxRect *arg1 = (wxRect *) 0 ;
5969 wxRect *arg2 = 0 ;
5970 wxRect *result;
5971 wxRect temp2 ;
5972 PyObject * obj0 = 0 ;
5973 PyObject * obj1 = 0 ;
5974 char *kwnames[] = {
5975 (char *) "self",(char *) "rect", NULL
5976 };
5977
5978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5980 if (SWIG_arg_fail(1)) SWIG_fail;
5981 {
5982 arg2 = &temp2;
5983 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5984 }
5985 {
5986 PyThreadState* __tstate = wxPyBeginAllowThreads();
5987 {
5988 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5989 result = (wxRect *) &_result_ref;
5990 }
5991
5992 wxPyEndAllowThreads(__tstate);
5993 if (PyErr_Occurred()) SWIG_fail;
5994 }
5995 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5996 return resultobj;
5997 fail:
5998 return NULL;
5999 }
6000
6001
6002 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6003 PyObject *resultobj;
6004 wxRect *arg1 = (wxRect *) 0 ;
6005 wxRect *arg2 = 0 ;
6006 bool result;
6007 wxRect temp2 ;
6008 PyObject * obj0 = 0 ;
6009 PyObject * obj1 = 0 ;
6010 char *kwnames[] = {
6011 (char *) "self",(char *) "rect", NULL
6012 };
6013
6014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6016 if (SWIG_arg_fail(1)) SWIG_fail;
6017 {
6018 arg2 = &temp2;
6019 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6020 }
6021 {
6022 PyThreadState* __tstate = wxPyBeginAllowThreads();
6023 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6024
6025 wxPyEndAllowThreads(__tstate);
6026 if (PyErr_Occurred()) SWIG_fail;
6027 }
6028 {
6029 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6030 }
6031 return resultobj;
6032 fail:
6033 return NULL;
6034 }
6035
6036
6037 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6038 PyObject *resultobj;
6039 wxRect *arg1 = (wxRect *) 0 ;
6040 wxRect *arg2 = 0 ;
6041 bool result;
6042 wxRect temp2 ;
6043 PyObject * obj0 = 0 ;
6044 PyObject * obj1 = 0 ;
6045 char *kwnames[] = {
6046 (char *) "self",(char *) "rect", NULL
6047 };
6048
6049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6051 if (SWIG_arg_fail(1)) SWIG_fail;
6052 {
6053 arg2 = &temp2;
6054 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6055 }
6056 {
6057 PyThreadState* __tstate = wxPyBeginAllowThreads();
6058 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6059
6060 wxPyEndAllowThreads(__tstate);
6061 if (PyErr_Occurred()) SWIG_fail;
6062 }
6063 {
6064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6065 }
6066 return resultobj;
6067 fail:
6068 return NULL;
6069 }
6070
6071
6072 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6073 PyObject *resultobj;
6074 wxRect *arg1 = (wxRect *) 0 ;
6075 int arg2 ;
6076 int arg3 ;
6077 bool result;
6078 PyObject * obj0 = 0 ;
6079 PyObject * obj1 = 0 ;
6080 PyObject * obj2 = 0 ;
6081 char *kwnames[] = {
6082 (char *) "self",(char *) "x",(char *) "y", NULL
6083 };
6084
6085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6087 if (SWIG_arg_fail(1)) SWIG_fail;
6088 {
6089 arg2 = (int)(SWIG_As_int(obj1));
6090 if (SWIG_arg_fail(2)) SWIG_fail;
6091 }
6092 {
6093 arg3 = (int)(SWIG_As_int(obj2));
6094 if (SWIG_arg_fail(3)) SWIG_fail;
6095 }
6096 {
6097 PyThreadState* __tstate = wxPyBeginAllowThreads();
6098 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6099
6100 wxPyEndAllowThreads(__tstate);
6101 if (PyErr_Occurred()) SWIG_fail;
6102 }
6103 {
6104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6105 }
6106 return resultobj;
6107 fail:
6108 return NULL;
6109 }
6110
6111
6112 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6113 PyObject *resultobj;
6114 wxRect *arg1 = (wxRect *) 0 ;
6115 wxPoint *arg2 = 0 ;
6116 bool result;
6117 wxPoint temp2 ;
6118 PyObject * obj0 = 0 ;
6119 PyObject * obj1 = 0 ;
6120 char *kwnames[] = {
6121 (char *) "self",(char *) "pt", NULL
6122 };
6123
6124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6126 if (SWIG_arg_fail(1)) SWIG_fail;
6127 {
6128 arg2 = &temp2;
6129 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6130 }
6131 {
6132 PyThreadState* __tstate = wxPyBeginAllowThreads();
6133 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6134
6135 wxPyEndAllowThreads(__tstate);
6136 if (PyErr_Occurred()) SWIG_fail;
6137 }
6138 {
6139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6140 }
6141 return resultobj;
6142 fail:
6143 return NULL;
6144 }
6145
6146
6147 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6148 PyObject *resultobj;
6149 wxRect *arg1 = (wxRect *) 0 ;
6150 wxRect *arg2 = 0 ;
6151 bool result;
6152 wxRect temp2 ;
6153 PyObject * obj0 = 0 ;
6154 PyObject * obj1 = 0 ;
6155 char *kwnames[] = {
6156 (char *) "self",(char *) "rect", NULL
6157 };
6158
6159 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6160 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6161 if (SWIG_arg_fail(1)) SWIG_fail;
6162 {
6163 arg2 = &temp2;
6164 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6165 }
6166 {
6167 PyThreadState* __tstate = wxPyBeginAllowThreads();
6168 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6169
6170 wxPyEndAllowThreads(__tstate);
6171 if (PyErr_Occurred()) SWIG_fail;
6172 }
6173 {
6174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6175 }
6176 return resultobj;
6177 fail:
6178 return NULL;
6179 }
6180
6181
6182 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6183 PyObject *resultobj;
6184 wxRect *arg1 = (wxRect *) 0 ;
6185 int arg2 ;
6186 PyObject * obj0 = 0 ;
6187 PyObject * obj1 = 0 ;
6188 char *kwnames[] = {
6189 (char *) "self",(char *) "x", NULL
6190 };
6191
6192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6194 if (SWIG_arg_fail(1)) SWIG_fail;
6195 {
6196 arg2 = (int)(SWIG_As_int(obj1));
6197 if (SWIG_arg_fail(2)) SWIG_fail;
6198 }
6199 if (arg1) (arg1)->x = arg2;
6200
6201 Py_INCREF(Py_None); resultobj = Py_None;
6202 return resultobj;
6203 fail:
6204 return NULL;
6205 }
6206
6207
6208 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6209 PyObject *resultobj;
6210 wxRect *arg1 = (wxRect *) 0 ;
6211 int result;
6212 PyObject * obj0 = 0 ;
6213 char *kwnames[] = {
6214 (char *) "self", NULL
6215 };
6216
6217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6219 if (SWIG_arg_fail(1)) SWIG_fail;
6220 result = (int) ((arg1)->x);
6221
6222 {
6223 resultobj = SWIG_From_int((int)(result));
6224 }
6225 return resultobj;
6226 fail:
6227 return NULL;
6228 }
6229
6230
6231 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6232 PyObject *resultobj;
6233 wxRect *arg1 = (wxRect *) 0 ;
6234 int arg2 ;
6235 PyObject * obj0 = 0 ;
6236 PyObject * obj1 = 0 ;
6237 char *kwnames[] = {
6238 (char *) "self",(char *) "y", NULL
6239 };
6240
6241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6243 if (SWIG_arg_fail(1)) SWIG_fail;
6244 {
6245 arg2 = (int)(SWIG_As_int(obj1));
6246 if (SWIG_arg_fail(2)) SWIG_fail;
6247 }
6248 if (arg1) (arg1)->y = arg2;
6249
6250 Py_INCREF(Py_None); resultobj = Py_None;
6251 return resultobj;
6252 fail:
6253 return NULL;
6254 }
6255
6256
6257 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6258 PyObject *resultobj;
6259 wxRect *arg1 = (wxRect *) 0 ;
6260 int result;
6261 PyObject * obj0 = 0 ;
6262 char *kwnames[] = {
6263 (char *) "self", NULL
6264 };
6265
6266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6267 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6268 if (SWIG_arg_fail(1)) SWIG_fail;
6269 result = (int) ((arg1)->y);
6270
6271 {
6272 resultobj = SWIG_From_int((int)(result));
6273 }
6274 return resultobj;
6275 fail:
6276 return NULL;
6277 }
6278
6279
6280 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6281 PyObject *resultobj;
6282 wxRect *arg1 = (wxRect *) 0 ;
6283 int arg2 ;
6284 PyObject * obj0 = 0 ;
6285 PyObject * obj1 = 0 ;
6286 char *kwnames[] = {
6287 (char *) "self",(char *) "width", NULL
6288 };
6289
6290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6292 if (SWIG_arg_fail(1)) SWIG_fail;
6293 {
6294 arg2 = (int)(SWIG_As_int(obj1));
6295 if (SWIG_arg_fail(2)) SWIG_fail;
6296 }
6297 if (arg1) (arg1)->width = arg2;
6298
6299 Py_INCREF(Py_None); resultobj = Py_None;
6300 return resultobj;
6301 fail:
6302 return NULL;
6303 }
6304
6305
6306 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6307 PyObject *resultobj;
6308 wxRect *arg1 = (wxRect *) 0 ;
6309 int result;
6310 PyObject * obj0 = 0 ;
6311 char *kwnames[] = {
6312 (char *) "self", NULL
6313 };
6314
6315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6317 if (SWIG_arg_fail(1)) SWIG_fail;
6318 result = (int) ((arg1)->width);
6319
6320 {
6321 resultobj = SWIG_From_int((int)(result));
6322 }
6323 return resultobj;
6324 fail:
6325 return NULL;
6326 }
6327
6328
6329 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6330 PyObject *resultobj;
6331 wxRect *arg1 = (wxRect *) 0 ;
6332 int arg2 ;
6333 PyObject * obj0 = 0 ;
6334 PyObject * obj1 = 0 ;
6335 char *kwnames[] = {
6336 (char *) "self",(char *) "height", NULL
6337 };
6338
6339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6341 if (SWIG_arg_fail(1)) SWIG_fail;
6342 {
6343 arg2 = (int)(SWIG_As_int(obj1));
6344 if (SWIG_arg_fail(2)) SWIG_fail;
6345 }
6346 if (arg1) (arg1)->height = arg2;
6347
6348 Py_INCREF(Py_None); resultobj = Py_None;
6349 return resultobj;
6350 fail:
6351 return NULL;
6352 }
6353
6354
6355 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6356 PyObject *resultobj;
6357 wxRect *arg1 = (wxRect *) 0 ;
6358 int result;
6359 PyObject * obj0 = 0 ;
6360 char *kwnames[] = {
6361 (char *) "self", NULL
6362 };
6363
6364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6366 if (SWIG_arg_fail(1)) SWIG_fail;
6367 result = (int) ((arg1)->height);
6368
6369 {
6370 resultobj = SWIG_From_int((int)(result));
6371 }
6372 return resultobj;
6373 fail:
6374 return NULL;
6375 }
6376
6377
6378 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6379 PyObject *resultobj;
6380 wxRect *arg1 = (wxRect *) 0 ;
6381 int arg2 = (int) 0 ;
6382 int arg3 = (int) 0 ;
6383 int arg4 = (int) 0 ;
6384 int arg5 = (int) 0 ;
6385 PyObject * obj0 = 0 ;
6386 PyObject * obj1 = 0 ;
6387 PyObject * obj2 = 0 ;
6388 PyObject * obj3 = 0 ;
6389 PyObject * obj4 = 0 ;
6390 char *kwnames[] = {
6391 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6392 };
6393
6394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6396 if (SWIG_arg_fail(1)) SWIG_fail;
6397 if (obj1) {
6398 {
6399 arg2 = (int)(SWIG_As_int(obj1));
6400 if (SWIG_arg_fail(2)) SWIG_fail;
6401 }
6402 }
6403 if (obj2) {
6404 {
6405 arg3 = (int)(SWIG_As_int(obj2));
6406 if (SWIG_arg_fail(3)) SWIG_fail;
6407 }
6408 }
6409 if (obj3) {
6410 {
6411 arg4 = (int)(SWIG_As_int(obj3));
6412 if (SWIG_arg_fail(4)) SWIG_fail;
6413 }
6414 }
6415 if (obj4) {
6416 {
6417 arg5 = (int)(SWIG_As_int(obj4));
6418 if (SWIG_arg_fail(5)) SWIG_fail;
6419 }
6420 }
6421 {
6422 PyThreadState* __tstate = wxPyBeginAllowThreads();
6423 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6424
6425 wxPyEndAllowThreads(__tstate);
6426 if (PyErr_Occurred()) SWIG_fail;
6427 }
6428 Py_INCREF(Py_None); resultobj = Py_None;
6429 return resultobj;
6430 fail:
6431 return NULL;
6432 }
6433
6434
6435 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6436 PyObject *resultobj;
6437 wxRect *arg1 = (wxRect *) 0 ;
6438 PyObject *result;
6439 PyObject * obj0 = 0 ;
6440 char *kwnames[] = {
6441 (char *) "self", NULL
6442 };
6443
6444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6446 if (SWIG_arg_fail(1)) SWIG_fail;
6447 {
6448 PyThreadState* __tstate = wxPyBeginAllowThreads();
6449 result = (PyObject *)wxRect_Get(arg1);
6450
6451 wxPyEndAllowThreads(__tstate);
6452 if (PyErr_Occurred()) SWIG_fail;
6453 }
6454 resultobj = result;
6455 return resultobj;
6456 fail:
6457 return NULL;
6458 }
6459
6460
6461 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6462 PyObject *obj;
6463 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6464 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6465 Py_INCREF(obj);
6466 return Py_BuildValue((char *)"");
6467 }
6468 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6469 PyObject *resultobj;
6470 wxRect *arg1 = (wxRect *) 0 ;
6471 wxRect *arg2 = (wxRect *) 0 ;
6472 PyObject *result;
6473 PyObject * obj0 = 0 ;
6474 PyObject * obj1 = 0 ;
6475 char *kwnames[] = {
6476 (char *) "r1",(char *) "r2", NULL
6477 };
6478
6479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6481 if (SWIG_arg_fail(1)) SWIG_fail;
6482 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6483 if (SWIG_arg_fail(2)) SWIG_fail;
6484 {
6485 if (!wxPyCheckForApp()) SWIG_fail;
6486 PyThreadState* __tstate = wxPyBeginAllowThreads();
6487 result = (PyObject *)wxIntersectRect(arg1,arg2);
6488
6489 wxPyEndAllowThreads(__tstate);
6490 if (PyErr_Occurred()) SWIG_fail;
6491 }
6492 resultobj = result;
6493 return resultobj;
6494 fail:
6495 return NULL;
6496 }
6497
6498
6499 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6500 PyObject *resultobj;
6501 double arg1 = (double) 0.0 ;
6502 double arg2 = (double) 0.0 ;
6503 wxPoint2D *result;
6504 PyObject * obj0 = 0 ;
6505 PyObject * obj1 = 0 ;
6506 char *kwnames[] = {
6507 (char *) "x",(char *) "y", NULL
6508 };
6509
6510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6511 if (obj0) {
6512 {
6513 arg1 = (double)(SWIG_As_double(obj0));
6514 if (SWIG_arg_fail(1)) SWIG_fail;
6515 }
6516 }
6517 if (obj1) {
6518 {
6519 arg2 = (double)(SWIG_As_double(obj1));
6520 if (SWIG_arg_fail(2)) SWIG_fail;
6521 }
6522 }
6523 {
6524 PyThreadState* __tstate = wxPyBeginAllowThreads();
6525 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6526
6527 wxPyEndAllowThreads(__tstate);
6528 if (PyErr_Occurred()) SWIG_fail;
6529 }
6530 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6531 return resultobj;
6532 fail:
6533 return NULL;
6534 }
6535
6536
6537 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6538 PyObject *resultobj;
6539 wxPoint2D *arg1 = 0 ;
6540 wxPoint2D *result;
6541 wxPoint2D temp1 ;
6542 PyObject * obj0 = 0 ;
6543 char *kwnames[] = {
6544 (char *) "pt", NULL
6545 };
6546
6547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6548 {
6549 arg1 = &temp1;
6550 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6551 }
6552 {
6553 PyThreadState* __tstate = wxPyBeginAllowThreads();
6554 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6555
6556 wxPyEndAllowThreads(__tstate);
6557 if (PyErr_Occurred()) SWIG_fail;
6558 }
6559 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6560 return resultobj;
6561 fail:
6562 return NULL;
6563 }
6564
6565
6566 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6567 PyObject *resultobj;
6568 wxPoint *arg1 = 0 ;
6569 wxPoint2D *result;
6570 wxPoint temp1 ;
6571 PyObject * obj0 = 0 ;
6572 char *kwnames[] = {
6573 (char *) "pt", NULL
6574 };
6575
6576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6577 {
6578 arg1 = &temp1;
6579 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6580 }
6581 {
6582 PyThreadState* __tstate = wxPyBeginAllowThreads();
6583 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6584
6585 wxPyEndAllowThreads(__tstate);
6586 if (PyErr_Occurred()) SWIG_fail;
6587 }
6588 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6589 return resultobj;
6590 fail:
6591 return NULL;
6592 }
6593
6594
6595 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6596 PyObject *resultobj;
6597 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6598 int *arg2 = (int *) 0 ;
6599 int *arg3 = (int *) 0 ;
6600 int temp2 ;
6601 int res2 = 0 ;
6602 int temp3 ;
6603 int res3 = 0 ;
6604 PyObject * obj0 = 0 ;
6605 char *kwnames[] = {
6606 (char *) "self", NULL
6607 };
6608
6609 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6610 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6613 if (SWIG_arg_fail(1)) SWIG_fail;
6614 {
6615 PyThreadState* __tstate = wxPyBeginAllowThreads();
6616 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6617
6618 wxPyEndAllowThreads(__tstate);
6619 if (PyErr_Occurred()) SWIG_fail;
6620 }
6621 Py_INCREF(Py_None); resultobj = Py_None;
6622 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6623 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6624 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6625 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6626 return resultobj;
6627 fail:
6628 return NULL;
6629 }
6630
6631
6632 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6633 PyObject *resultobj;
6634 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6635 int *arg2 = (int *) 0 ;
6636 int *arg3 = (int *) 0 ;
6637 int temp2 ;
6638 int res2 = 0 ;
6639 int temp3 ;
6640 int res3 = 0 ;
6641 PyObject * obj0 = 0 ;
6642 char *kwnames[] = {
6643 (char *) "self", NULL
6644 };
6645
6646 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6647 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6650 if (SWIG_arg_fail(1)) SWIG_fail;
6651 {
6652 PyThreadState* __tstate = wxPyBeginAllowThreads();
6653 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6654
6655 wxPyEndAllowThreads(__tstate);
6656 if (PyErr_Occurred()) SWIG_fail;
6657 }
6658 Py_INCREF(Py_None); resultobj = Py_None;
6659 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6660 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6661 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6662 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6663 return resultobj;
6664 fail:
6665 return NULL;
6666 }
6667
6668
6669 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6670 PyObject *resultobj;
6671 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6672 double result;
6673 PyObject * obj0 = 0 ;
6674 char *kwnames[] = {
6675 (char *) "self", NULL
6676 };
6677
6678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6680 if (SWIG_arg_fail(1)) SWIG_fail;
6681 {
6682 PyThreadState* __tstate = wxPyBeginAllowThreads();
6683 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6684
6685 wxPyEndAllowThreads(__tstate);
6686 if (PyErr_Occurred()) SWIG_fail;
6687 }
6688 {
6689 resultobj = SWIG_From_double((double)(result));
6690 }
6691 return resultobj;
6692 fail:
6693 return NULL;
6694 }
6695
6696
6697 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6698 PyObject *resultobj;
6699 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6700 double result;
6701 PyObject * obj0 = 0 ;
6702 char *kwnames[] = {
6703 (char *) "self", NULL
6704 };
6705
6706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6708 if (SWIG_arg_fail(1)) SWIG_fail;
6709 {
6710 PyThreadState* __tstate = wxPyBeginAllowThreads();
6711 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6712
6713 wxPyEndAllowThreads(__tstate);
6714 if (PyErr_Occurred()) SWIG_fail;
6715 }
6716 {
6717 resultobj = SWIG_From_double((double)(result));
6718 }
6719 return resultobj;
6720 fail:
6721 return NULL;
6722 }
6723
6724
6725 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6726 PyObject *resultobj;
6727 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6728 double arg2 ;
6729 PyObject * obj0 = 0 ;
6730 PyObject * obj1 = 0 ;
6731 char *kwnames[] = {
6732 (char *) "self",(char *) "length", NULL
6733 };
6734
6735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",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 = (double)(SWIG_As_double(obj1));
6740 if (SWIG_arg_fail(2)) SWIG_fail;
6741 }
6742 {
6743 PyThreadState* __tstate = wxPyBeginAllowThreads();
6744 (arg1)->SetVectorLength(arg2);
6745
6746 wxPyEndAllowThreads(__tstate);
6747 if (PyErr_Occurred()) SWIG_fail;
6748 }
6749 Py_INCREF(Py_None); resultobj = Py_None;
6750 return resultobj;
6751 fail:
6752 return NULL;
6753 }
6754
6755
6756 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6757 PyObject *resultobj;
6758 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6759 double arg2 ;
6760 PyObject * obj0 = 0 ;
6761 PyObject * obj1 = 0 ;
6762 char *kwnames[] = {
6763 (char *) "self",(char *) "degrees", NULL
6764 };
6765
6766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6768 if (SWIG_arg_fail(1)) SWIG_fail;
6769 {
6770 arg2 = (double)(SWIG_As_double(obj1));
6771 if (SWIG_arg_fail(2)) SWIG_fail;
6772 }
6773 {
6774 PyThreadState* __tstate = wxPyBeginAllowThreads();
6775 (arg1)->SetVectorAngle(arg2);
6776
6777 wxPyEndAllowThreads(__tstate);
6778 if (PyErr_Occurred()) SWIG_fail;
6779 }
6780 Py_INCREF(Py_None); resultobj = Py_None;
6781 return resultobj;
6782 fail:
6783 return NULL;
6784 }
6785
6786
6787 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6788 PyObject *resultobj;
6789 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6790 wxPoint2D *arg2 = 0 ;
6791 double result;
6792 wxPoint2D temp2 ;
6793 PyObject * obj0 = 0 ;
6794 PyObject * obj1 = 0 ;
6795 char *kwnames[] = {
6796 (char *) "self",(char *) "pt", NULL
6797 };
6798
6799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6801 if (SWIG_arg_fail(1)) SWIG_fail;
6802 {
6803 arg2 = &temp2;
6804 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6805 }
6806 {
6807 PyThreadState* __tstate = wxPyBeginAllowThreads();
6808 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6809
6810 wxPyEndAllowThreads(__tstate);
6811 if (PyErr_Occurred()) SWIG_fail;
6812 }
6813 {
6814 resultobj = SWIG_From_double((double)(result));
6815 }
6816 return resultobj;
6817 fail:
6818 return NULL;
6819 }
6820
6821
6822 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6823 PyObject *resultobj;
6824 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6825 wxPoint2D *arg2 = 0 ;
6826 double result;
6827 wxPoint2D temp2 ;
6828 PyObject * obj0 = 0 ;
6829 PyObject * obj1 = 0 ;
6830 char *kwnames[] = {
6831 (char *) "self",(char *) "pt", NULL
6832 };
6833
6834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6836 if (SWIG_arg_fail(1)) SWIG_fail;
6837 {
6838 arg2 = &temp2;
6839 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6840 }
6841 {
6842 PyThreadState* __tstate = wxPyBeginAllowThreads();
6843 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6844
6845 wxPyEndAllowThreads(__tstate);
6846 if (PyErr_Occurred()) SWIG_fail;
6847 }
6848 {
6849 resultobj = SWIG_From_double((double)(result));
6850 }
6851 return resultobj;
6852 fail:
6853 return NULL;
6854 }
6855
6856
6857 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6858 PyObject *resultobj;
6859 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6860 wxPoint2D *arg2 = 0 ;
6861 double result;
6862 wxPoint2D temp2 ;
6863 PyObject * obj0 = 0 ;
6864 PyObject * obj1 = 0 ;
6865 char *kwnames[] = {
6866 (char *) "self",(char *) "vec", NULL
6867 };
6868
6869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6871 if (SWIG_arg_fail(1)) SWIG_fail;
6872 {
6873 arg2 = &temp2;
6874 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6875 }
6876 {
6877 PyThreadState* __tstate = wxPyBeginAllowThreads();
6878 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6879
6880 wxPyEndAllowThreads(__tstate);
6881 if (PyErr_Occurred()) SWIG_fail;
6882 }
6883 {
6884 resultobj = SWIG_From_double((double)(result));
6885 }
6886 return resultobj;
6887 fail:
6888 return NULL;
6889 }
6890
6891
6892 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6893 PyObject *resultobj;
6894 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6895 wxPoint2D *arg2 = 0 ;
6896 double result;
6897 wxPoint2D temp2 ;
6898 PyObject * obj0 = 0 ;
6899 PyObject * obj1 = 0 ;
6900 char *kwnames[] = {
6901 (char *) "self",(char *) "vec", NULL
6902 };
6903
6904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6906 if (SWIG_arg_fail(1)) SWIG_fail;
6907 {
6908 arg2 = &temp2;
6909 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6910 }
6911 {
6912 PyThreadState* __tstate = wxPyBeginAllowThreads();
6913 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6914
6915 wxPyEndAllowThreads(__tstate);
6916 if (PyErr_Occurred()) SWIG_fail;
6917 }
6918 {
6919 resultobj = SWIG_From_double((double)(result));
6920 }
6921 return resultobj;
6922 fail:
6923 return NULL;
6924 }
6925
6926
6927 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6928 PyObject *resultobj;
6929 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6930 wxPoint2D result;
6931 PyObject * obj0 = 0 ;
6932 char *kwnames[] = {
6933 (char *) "self", NULL
6934 };
6935
6936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6938 if (SWIG_arg_fail(1)) SWIG_fail;
6939 {
6940 PyThreadState* __tstate = wxPyBeginAllowThreads();
6941 result = (arg1)->operator -();
6942
6943 wxPyEndAllowThreads(__tstate);
6944 if (PyErr_Occurred()) SWIG_fail;
6945 }
6946 {
6947 wxPoint2D * resultptr;
6948 resultptr = new wxPoint2D((wxPoint2D &)(result));
6949 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6950 }
6951 return resultobj;
6952 fail:
6953 return NULL;
6954 }
6955
6956
6957 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6958 PyObject *resultobj;
6959 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6960 wxPoint2D *arg2 = 0 ;
6961 wxPoint2D *result;
6962 wxPoint2D temp2 ;
6963 PyObject * obj0 = 0 ;
6964 PyObject * obj1 = 0 ;
6965 char *kwnames[] = {
6966 (char *) "self",(char *) "pt", NULL
6967 };
6968
6969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6971 if (SWIG_arg_fail(1)) SWIG_fail;
6972 {
6973 arg2 = &temp2;
6974 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6975 }
6976 {
6977 PyThreadState* __tstate = wxPyBeginAllowThreads();
6978 {
6979 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6980 result = (wxPoint2D *) &_result_ref;
6981 }
6982
6983 wxPyEndAllowThreads(__tstate);
6984 if (PyErr_Occurred()) SWIG_fail;
6985 }
6986 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6987 return resultobj;
6988 fail:
6989 return NULL;
6990 }
6991
6992
6993 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6994 PyObject *resultobj;
6995 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6996 wxPoint2D *arg2 = 0 ;
6997 wxPoint2D *result;
6998 wxPoint2D temp2 ;
6999 PyObject * obj0 = 0 ;
7000 PyObject * obj1 = 0 ;
7001 char *kwnames[] = {
7002 (char *) "self",(char *) "pt", NULL
7003 };
7004
7005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7007 if (SWIG_arg_fail(1)) SWIG_fail;
7008 {
7009 arg2 = &temp2;
7010 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7011 }
7012 {
7013 PyThreadState* __tstate = wxPyBeginAllowThreads();
7014 {
7015 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7016 result = (wxPoint2D *) &_result_ref;
7017 }
7018
7019 wxPyEndAllowThreads(__tstate);
7020 if (PyErr_Occurred()) SWIG_fail;
7021 }
7022 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7023 return resultobj;
7024 fail:
7025 return NULL;
7026 }
7027
7028
7029 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7030 PyObject *resultobj;
7031 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7032 wxPoint2D *arg2 = 0 ;
7033 wxPoint2D *result;
7034 wxPoint2D temp2 ;
7035 PyObject * obj0 = 0 ;
7036 PyObject * obj1 = 0 ;
7037 char *kwnames[] = {
7038 (char *) "self",(char *) "pt", NULL
7039 };
7040
7041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7042 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7043 if (SWIG_arg_fail(1)) SWIG_fail;
7044 {
7045 arg2 = &temp2;
7046 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7047 }
7048 {
7049 PyThreadState* __tstate = wxPyBeginAllowThreads();
7050 {
7051 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7052 result = (wxPoint2D *) &_result_ref;
7053 }
7054
7055 wxPyEndAllowThreads(__tstate);
7056 if (PyErr_Occurred()) SWIG_fail;
7057 }
7058 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7059 return resultobj;
7060 fail:
7061 return NULL;
7062 }
7063
7064
7065 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7066 PyObject *resultobj;
7067 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7068 wxPoint2D *arg2 = 0 ;
7069 wxPoint2D *result;
7070 wxPoint2D temp2 ;
7071 PyObject * obj0 = 0 ;
7072 PyObject * obj1 = 0 ;
7073 char *kwnames[] = {
7074 (char *) "self",(char *) "pt", NULL
7075 };
7076
7077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7079 if (SWIG_arg_fail(1)) SWIG_fail;
7080 {
7081 arg2 = &temp2;
7082 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7083 }
7084 {
7085 PyThreadState* __tstate = wxPyBeginAllowThreads();
7086 {
7087 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7088 result = (wxPoint2D *) &_result_ref;
7089 }
7090
7091 wxPyEndAllowThreads(__tstate);
7092 if (PyErr_Occurred()) SWIG_fail;
7093 }
7094 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7095 return resultobj;
7096 fail:
7097 return NULL;
7098 }
7099
7100
7101 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7102 PyObject *resultobj;
7103 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7104 wxPoint2D *arg2 = 0 ;
7105 bool result;
7106 wxPoint2D temp2 ;
7107 PyObject * obj0 = 0 ;
7108 PyObject * obj1 = 0 ;
7109 char *kwnames[] = {
7110 (char *) "self",(char *) "pt", NULL
7111 };
7112
7113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7114 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7115 if (SWIG_arg_fail(1)) SWIG_fail;
7116 {
7117 arg2 = &temp2;
7118 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7119 }
7120 {
7121 PyThreadState* __tstate = wxPyBeginAllowThreads();
7122 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7123
7124 wxPyEndAllowThreads(__tstate);
7125 if (PyErr_Occurred()) SWIG_fail;
7126 }
7127 {
7128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7129 }
7130 return resultobj;
7131 fail:
7132 return NULL;
7133 }
7134
7135
7136 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7137 PyObject *resultobj;
7138 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7139 wxPoint2D *arg2 = 0 ;
7140 bool result;
7141 wxPoint2D temp2 ;
7142 PyObject * obj0 = 0 ;
7143 PyObject * obj1 = 0 ;
7144 char *kwnames[] = {
7145 (char *) "self",(char *) "pt", NULL
7146 };
7147
7148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7150 if (SWIG_arg_fail(1)) SWIG_fail;
7151 {
7152 arg2 = &temp2;
7153 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7154 }
7155 {
7156 PyThreadState* __tstate = wxPyBeginAllowThreads();
7157 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7158
7159 wxPyEndAllowThreads(__tstate);
7160 if (PyErr_Occurred()) SWIG_fail;
7161 }
7162 {
7163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7164 }
7165 return resultobj;
7166 fail:
7167 return NULL;
7168 }
7169
7170
7171 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7172 PyObject *resultobj;
7173 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7174 double arg2 ;
7175 PyObject * obj0 = 0 ;
7176 PyObject * obj1 = 0 ;
7177 char *kwnames[] = {
7178 (char *) "self",(char *) "m_x", NULL
7179 };
7180
7181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7183 if (SWIG_arg_fail(1)) SWIG_fail;
7184 {
7185 arg2 = (double)(SWIG_As_double(obj1));
7186 if (SWIG_arg_fail(2)) SWIG_fail;
7187 }
7188 if (arg1) (arg1)->m_x = arg2;
7189
7190 Py_INCREF(Py_None); resultobj = Py_None;
7191 return resultobj;
7192 fail:
7193 return NULL;
7194 }
7195
7196
7197 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7198 PyObject *resultobj;
7199 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7200 double result;
7201 PyObject * obj0 = 0 ;
7202 char *kwnames[] = {
7203 (char *) "self", NULL
7204 };
7205
7206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7208 if (SWIG_arg_fail(1)) SWIG_fail;
7209 result = (double) ((arg1)->m_x);
7210
7211 {
7212 resultobj = SWIG_From_double((double)(result));
7213 }
7214 return resultobj;
7215 fail:
7216 return NULL;
7217 }
7218
7219
7220 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7221 PyObject *resultobj;
7222 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7223 double arg2 ;
7224 PyObject * obj0 = 0 ;
7225 PyObject * obj1 = 0 ;
7226 char *kwnames[] = {
7227 (char *) "self",(char *) "m_y", NULL
7228 };
7229
7230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7232 if (SWIG_arg_fail(1)) SWIG_fail;
7233 {
7234 arg2 = (double)(SWIG_As_double(obj1));
7235 if (SWIG_arg_fail(2)) SWIG_fail;
7236 }
7237 if (arg1) (arg1)->m_y = arg2;
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_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7247 PyObject *resultobj;
7248 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7249 double result;
7250 PyObject * obj0 = 0 ;
7251 char *kwnames[] = {
7252 (char *) "self", NULL
7253 };
7254
7255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_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 result = (double) ((arg1)->m_y);
7259
7260 {
7261 resultobj = SWIG_From_double((double)(result));
7262 }
7263 return resultobj;
7264 fail:
7265 return NULL;
7266 }
7267
7268
7269 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7270 PyObject *resultobj;
7271 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7272 double arg2 = (double) 0 ;
7273 double arg3 = (double) 0 ;
7274 PyObject * obj0 = 0 ;
7275 PyObject * obj1 = 0 ;
7276 PyObject * obj2 = 0 ;
7277 char *kwnames[] = {
7278 (char *) "self",(char *) "x",(char *) "y", NULL
7279 };
7280
7281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7283 if (SWIG_arg_fail(1)) SWIG_fail;
7284 if (obj1) {
7285 {
7286 arg2 = (double)(SWIG_As_double(obj1));
7287 if (SWIG_arg_fail(2)) SWIG_fail;
7288 }
7289 }
7290 if (obj2) {
7291 {
7292 arg3 = (double)(SWIG_As_double(obj2));
7293 if (SWIG_arg_fail(3)) SWIG_fail;
7294 }
7295 }
7296 {
7297 PyThreadState* __tstate = wxPyBeginAllowThreads();
7298 wxPoint2D_Set(arg1,arg2,arg3);
7299
7300 wxPyEndAllowThreads(__tstate);
7301 if (PyErr_Occurred()) SWIG_fail;
7302 }
7303 Py_INCREF(Py_None); resultobj = Py_None;
7304 return resultobj;
7305 fail:
7306 return NULL;
7307 }
7308
7309
7310 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7311 PyObject *resultobj;
7312 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7313 PyObject *result;
7314 PyObject * obj0 = 0 ;
7315 char *kwnames[] = {
7316 (char *) "self", NULL
7317 };
7318
7319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7321 if (SWIG_arg_fail(1)) SWIG_fail;
7322 {
7323 PyThreadState* __tstate = wxPyBeginAllowThreads();
7324 result = (PyObject *)wxPoint2D_Get(arg1);
7325
7326 wxPyEndAllowThreads(__tstate);
7327 if (PyErr_Occurred()) SWIG_fail;
7328 }
7329 resultobj = result;
7330 return resultobj;
7331 fail:
7332 return NULL;
7333 }
7334
7335
7336 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7337 PyObject *obj;
7338 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7339 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7340 Py_INCREF(obj);
7341 return Py_BuildValue((char *)"");
7342 }
7343 static int _wrap_DefaultPosition_set(PyObject *) {
7344 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7345 return 1;
7346 }
7347
7348
7349 static PyObject *_wrap_DefaultPosition_get(void) {
7350 PyObject *pyobj;
7351
7352 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7353 return pyobj;
7354 }
7355
7356
7357 static int _wrap_DefaultSize_set(PyObject *) {
7358 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7359 return 1;
7360 }
7361
7362
7363 static PyObject *_wrap_DefaultSize_get(void) {
7364 PyObject *pyobj;
7365
7366 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7367 return pyobj;
7368 }
7369
7370
7371 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7372 PyObject *resultobj;
7373 PyObject *arg1 = (PyObject *) 0 ;
7374 wxPyInputStream *result;
7375 PyObject * obj0 = 0 ;
7376 char *kwnames[] = {
7377 (char *) "p", NULL
7378 };
7379
7380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7381 arg1 = obj0;
7382 {
7383 PyThreadState* __tstate = wxPyBeginAllowThreads();
7384 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7385
7386 wxPyEndAllowThreads(__tstate);
7387 if (PyErr_Occurred()) SWIG_fail;
7388 }
7389 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7390 return resultobj;
7391 fail:
7392 return NULL;
7393 }
7394
7395
7396 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7397 PyObject *resultobj;
7398 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7399 PyObject * obj0 = 0 ;
7400 char *kwnames[] = {
7401 (char *) "self", NULL
7402 };
7403
7404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7406 if (SWIG_arg_fail(1)) SWIG_fail;
7407 {
7408 PyThreadState* __tstate = wxPyBeginAllowThreads();
7409 delete arg1;
7410
7411 wxPyEndAllowThreads(__tstate);
7412 if (PyErr_Occurred()) SWIG_fail;
7413 }
7414 Py_INCREF(Py_None); resultobj = Py_None;
7415 return resultobj;
7416 fail:
7417 return NULL;
7418 }
7419
7420
7421 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7422 PyObject *resultobj;
7423 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7424 PyObject * obj0 = 0 ;
7425 char *kwnames[] = {
7426 (char *) "self", NULL
7427 };
7428
7429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7431 if (SWIG_arg_fail(1)) SWIG_fail;
7432 {
7433 PyThreadState* __tstate = wxPyBeginAllowThreads();
7434 (arg1)->close();
7435
7436 wxPyEndAllowThreads(__tstate);
7437 if (PyErr_Occurred()) SWIG_fail;
7438 }
7439 Py_INCREF(Py_None); resultobj = Py_None;
7440 return resultobj;
7441 fail:
7442 return NULL;
7443 }
7444
7445
7446 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7447 PyObject *resultobj;
7448 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7449 PyObject * obj0 = 0 ;
7450 char *kwnames[] = {
7451 (char *) "self", NULL
7452 };
7453
7454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7456 if (SWIG_arg_fail(1)) SWIG_fail;
7457 {
7458 PyThreadState* __tstate = wxPyBeginAllowThreads();
7459 (arg1)->flush();
7460
7461 wxPyEndAllowThreads(__tstate);
7462 if (PyErr_Occurred()) SWIG_fail;
7463 }
7464 Py_INCREF(Py_None); resultobj = Py_None;
7465 return resultobj;
7466 fail:
7467 return NULL;
7468 }
7469
7470
7471 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7472 PyObject *resultobj;
7473 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7474 bool result;
7475 PyObject * obj0 = 0 ;
7476 char *kwnames[] = {
7477 (char *) "self", NULL
7478 };
7479
7480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) 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 {
7484 PyThreadState* __tstate = wxPyBeginAllowThreads();
7485 result = (bool)(arg1)->eof();
7486
7487 wxPyEndAllowThreads(__tstate);
7488 if (PyErr_Occurred()) SWIG_fail;
7489 }
7490 {
7491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7492 }
7493 return resultobj;
7494 fail:
7495 return NULL;
7496 }
7497
7498
7499 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7500 PyObject *resultobj;
7501 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7502 int arg2 = (int) -1 ;
7503 PyObject *result;
7504 PyObject * obj0 = 0 ;
7505 PyObject * obj1 = 0 ;
7506 char *kwnames[] = {
7507 (char *) "self",(char *) "size", NULL
7508 };
7509
7510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7512 if (SWIG_arg_fail(1)) SWIG_fail;
7513 if (obj1) {
7514 {
7515 arg2 = (int)(SWIG_As_int(obj1));
7516 if (SWIG_arg_fail(2)) SWIG_fail;
7517 }
7518 }
7519 {
7520 PyThreadState* __tstate = wxPyBeginAllowThreads();
7521 result = (PyObject *)(arg1)->read(arg2);
7522
7523 wxPyEndAllowThreads(__tstate);
7524 if (PyErr_Occurred()) SWIG_fail;
7525 }
7526 resultobj = result;
7527 return resultobj;
7528 fail:
7529 return NULL;
7530 }
7531
7532
7533 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7534 PyObject *resultobj;
7535 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7536 int arg2 = (int) -1 ;
7537 PyObject *result;
7538 PyObject * obj0 = 0 ;
7539 PyObject * obj1 = 0 ;
7540 char *kwnames[] = {
7541 (char *) "self",(char *) "size", NULL
7542 };
7543
7544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7546 if (SWIG_arg_fail(1)) SWIG_fail;
7547 if (obj1) {
7548 {
7549 arg2 = (int)(SWIG_As_int(obj1));
7550 if (SWIG_arg_fail(2)) SWIG_fail;
7551 }
7552 }
7553 {
7554 PyThreadState* __tstate = wxPyBeginAllowThreads();
7555 result = (PyObject *)(arg1)->readline(arg2);
7556
7557 wxPyEndAllowThreads(__tstate);
7558 if (PyErr_Occurred()) SWIG_fail;
7559 }
7560 resultobj = result;
7561 return resultobj;
7562 fail:
7563 return NULL;
7564 }
7565
7566
7567 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7568 PyObject *resultobj;
7569 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7570 int arg2 = (int) -1 ;
7571 PyObject *result;
7572 PyObject * obj0 = 0 ;
7573 PyObject * obj1 = 0 ;
7574 char *kwnames[] = {
7575 (char *) "self",(char *) "sizehint", NULL
7576 };
7577
7578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7580 if (SWIG_arg_fail(1)) SWIG_fail;
7581 if (obj1) {
7582 {
7583 arg2 = (int)(SWIG_As_int(obj1));
7584 if (SWIG_arg_fail(2)) SWIG_fail;
7585 }
7586 }
7587 {
7588 PyThreadState* __tstate = wxPyBeginAllowThreads();
7589 result = (PyObject *)(arg1)->readlines(arg2);
7590
7591 wxPyEndAllowThreads(__tstate);
7592 if (PyErr_Occurred()) SWIG_fail;
7593 }
7594 resultobj = result;
7595 return resultobj;
7596 fail:
7597 return NULL;
7598 }
7599
7600
7601 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7602 PyObject *resultobj;
7603 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7604 int arg2 ;
7605 int arg3 = (int) 0 ;
7606 PyObject * obj0 = 0 ;
7607 PyObject * obj1 = 0 ;
7608 PyObject * obj2 = 0 ;
7609 char *kwnames[] = {
7610 (char *) "self",(char *) "offset",(char *) "whence", NULL
7611 };
7612
7613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) 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 arg2 = (int)(SWIG_As_int(obj1));
7618 if (SWIG_arg_fail(2)) SWIG_fail;
7619 }
7620 if (obj2) {
7621 {
7622 arg3 = (int)(SWIG_As_int(obj2));
7623 if (SWIG_arg_fail(3)) SWIG_fail;
7624 }
7625 }
7626 {
7627 PyThreadState* __tstate = wxPyBeginAllowThreads();
7628 (arg1)->seek(arg2,arg3);
7629
7630 wxPyEndAllowThreads(__tstate);
7631 if (PyErr_Occurred()) SWIG_fail;
7632 }
7633 Py_INCREF(Py_None); resultobj = Py_None;
7634 return resultobj;
7635 fail:
7636 return NULL;
7637 }
7638
7639
7640 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7641 PyObject *resultobj;
7642 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7643 int result;
7644 PyObject * obj0 = 0 ;
7645 char *kwnames[] = {
7646 (char *) "self", NULL
7647 };
7648
7649 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7650 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7651 if (SWIG_arg_fail(1)) SWIG_fail;
7652 {
7653 PyThreadState* __tstate = wxPyBeginAllowThreads();
7654 result = (int)(arg1)->tell();
7655
7656 wxPyEndAllowThreads(__tstate);
7657 if (PyErr_Occurred()) SWIG_fail;
7658 }
7659 {
7660 resultobj = SWIG_From_int((int)(result));
7661 }
7662 return resultobj;
7663 fail:
7664 return NULL;
7665 }
7666
7667
7668 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7669 PyObject *resultobj;
7670 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7671 char result;
7672 PyObject * obj0 = 0 ;
7673 char *kwnames[] = {
7674 (char *) "self", NULL
7675 };
7676
7677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7679 if (SWIG_arg_fail(1)) SWIG_fail;
7680 {
7681 PyThreadState* __tstate = wxPyBeginAllowThreads();
7682 result = (char)(arg1)->Peek();
7683
7684 wxPyEndAllowThreads(__tstate);
7685 if (PyErr_Occurred()) SWIG_fail;
7686 }
7687 {
7688 resultobj = SWIG_From_char((char)(result));
7689 }
7690 return resultobj;
7691 fail:
7692 return NULL;
7693 }
7694
7695
7696 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7697 PyObject *resultobj;
7698 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7699 char result;
7700 PyObject * obj0 = 0 ;
7701 char *kwnames[] = {
7702 (char *) "self", NULL
7703 };
7704
7705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7707 if (SWIG_arg_fail(1)) SWIG_fail;
7708 {
7709 PyThreadState* __tstate = wxPyBeginAllowThreads();
7710 result = (char)(arg1)->GetC();
7711
7712 wxPyEndAllowThreads(__tstate);
7713 if (PyErr_Occurred()) SWIG_fail;
7714 }
7715 {
7716 resultobj = SWIG_From_char((char)(result));
7717 }
7718 return resultobj;
7719 fail:
7720 return NULL;
7721 }
7722
7723
7724 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7725 PyObject *resultobj;
7726 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7727 size_t result;
7728 PyObject * obj0 = 0 ;
7729 char *kwnames[] = {
7730 (char *) "self", NULL
7731 };
7732
7733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7735 if (SWIG_arg_fail(1)) SWIG_fail;
7736 {
7737 PyThreadState* __tstate = wxPyBeginAllowThreads();
7738 result = (size_t)(arg1)->LastRead();
7739
7740 wxPyEndAllowThreads(__tstate);
7741 if (PyErr_Occurred()) SWIG_fail;
7742 }
7743 {
7744 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7745 }
7746 return resultobj;
7747 fail:
7748 return NULL;
7749 }
7750
7751
7752 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7753 PyObject *resultobj;
7754 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7755 bool result;
7756 PyObject * obj0 = 0 ;
7757 char *kwnames[] = {
7758 (char *) "self", NULL
7759 };
7760
7761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7763 if (SWIG_arg_fail(1)) SWIG_fail;
7764 {
7765 PyThreadState* __tstate = wxPyBeginAllowThreads();
7766 result = (bool)(arg1)->CanRead();
7767
7768 wxPyEndAllowThreads(__tstate);
7769 if (PyErr_Occurred()) SWIG_fail;
7770 }
7771 {
7772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7773 }
7774 return resultobj;
7775 fail:
7776 return NULL;
7777 }
7778
7779
7780 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7781 PyObject *resultobj;
7782 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7783 bool result;
7784 PyObject * obj0 = 0 ;
7785 char *kwnames[] = {
7786 (char *) "self", NULL
7787 };
7788
7789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7791 if (SWIG_arg_fail(1)) SWIG_fail;
7792 {
7793 PyThreadState* __tstate = wxPyBeginAllowThreads();
7794 result = (bool)(arg1)->Eof();
7795
7796 wxPyEndAllowThreads(__tstate);
7797 if (PyErr_Occurred()) SWIG_fail;
7798 }
7799 {
7800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7801 }
7802 return resultobj;
7803 fail:
7804 return NULL;
7805 }
7806
7807
7808 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7809 PyObject *resultobj;
7810 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7811 char arg2 ;
7812 bool result;
7813 PyObject * obj0 = 0 ;
7814 PyObject * obj1 = 0 ;
7815 char *kwnames[] = {
7816 (char *) "self",(char *) "c", NULL
7817 };
7818
7819 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7820 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7821 if (SWIG_arg_fail(1)) SWIG_fail;
7822 {
7823 arg2 = (char)(SWIG_As_char(obj1));
7824 if (SWIG_arg_fail(2)) SWIG_fail;
7825 }
7826 {
7827 PyThreadState* __tstate = wxPyBeginAllowThreads();
7828 result = (bool)(arg1)->Ungetch(arg2);
7829
7830 wxPyEndAllowThreads(__tstate);
7831 if (PyErr_Occurred()) SWIG_fail;
7832 }
7833 {
7834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7835 }
7836 return resultobj;
7837 fail:
7838 return NULL;
7839 }
7840
7841
7842 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7843 PyObject *resultobj;
7844 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7845 long arg2 ;
7846 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7847 long result;
7848 PyObject * obj0 = 0 ;
7849 PyObject * obj1 = 0 ;
7850 PyObject * obj2 = 0 ;
7851 char *kwnames[] = {
7852 (char *) "self",(char *) "pos",(char *) "mode", NULL
7853 };
7854
7855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7857 if (SWIG_arg_fail(1)) SWIG_fail;
7858 {
7859 arg2 = (long)(SWIG_As_long(obj1));
7860 if (SWIG_arg_fail(2)) SWIG_fail;
7861 }
7862 if (obj2) {
7863 {
7864 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7865 if (SWIG_arg_fail(3)) SWIG_fail;
7866 }
7867 }
7868 {
7869 PyThreadState* __tstate = wxPyBeginAllowThreads();
7870 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7871
7872 wxPyEndAllowThreads(__tstate);
7873 if (PyErr_Occurred()) SWIG_fail;
7874 }
7875 {
7876 resultobj = SWIG_From_long((long)(result));
7877 }
7878 return resultobj;
7879 fail:
7880 return NULL;
7881 }
7882
7883
7884 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7885 PyObject *resultobj;
7886 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7887 long result;
7888 PyObject * obj0 = 0 ;
7889 char *kwnames[] = {
7890 (char *) "self", NULL
7891 };
7892
7893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7895 if (SWIG_arg_fail(1)) SWIG_fail;
7896 {
7897 PyThreadState* __tstate = wxPyBeginAllowThreads();
7898 result = (long)(arg1)->TellI();
7899
7900 wxPyEndAllowThreads(__tstate);
7901 if (PyErr_Occurred()) SWIG_fail;
7902 }
7903 {
7904 resultobj = SWIG_From_long((long)(result));
7905 }
7906 return resultobj;
7907 fail:
7908 return NULL;
7909 }
7910
7911
7912 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7913 PyObject *obj;
7914 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7915 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7916 Py_INCREF(obj);
7917 return Py_BuildValue((char *)"");
7918 }
7919 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7920 PyObject *resultobj;
7921 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7922 PyObject *arg2 = (PyObject *) 0 ;
7923 PyObject * obj0 = 0 ;
7924 PyObject * obj1 = 0 ;
7925 char *kwnames[] = {
7926 (char *) "self",(char *) "obj", NULL
7927 };
7928
7929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7931 if (SWIG_arg_fail(1)) SWIG_fail;
7932 arg2 = obj1;
7933 {
7934 PyThreadState* __tstate = wxPyBeginAllowThreads();
7935 wxOutputStream_write(arg1,arg2);
7936
7937 wxPyEndAllowThreads(__tstate);
7938 if (PyErr_Occurred()) SWIG_fail;
7939 }
7940 Py_INCREF(Py_None); resultobj = Py_None;
7941 return resultobj;
7942 fail:
7943 return NULL;
7944 }
7945
7946
7947 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7948 PyObject *obj;
7949 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7950 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7951 Py_INCREF(obj);
7952 return Py_BuildValue((char *)"");
7953 }
7954 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7955 PyObject *resultobj;
7956 wxInputStream *arg1 = (wxInputStream *) 0 ;
7957 wxString *arg2 = 0 ;
7958 wxString *arg3 = 0 ;
7959 wxString *arg4 = 0 ;
7960 wxDateTime arg5 ;
7961 wxFSFile *result;
7962 wxPyInputStream *temp1 ;
7963 bool temp2 = false ;
7964 bool temp3 = false ;
7965 bool temp4 = false ;
7966 PyObject * obj0 = 0 ;
7967 PyObject * obj1 = 0 ;
7968 PyObject * obj2 = 0 ;
7969 PyObject * obj3 = 0 ;
7970 PyObject * obj4 = 0 ;
7971 char *kwnames[] = {
7972 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7973 };
7974
7975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7976 {
7977 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7978 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7979 } else {
7980 PyErr_Clear(); // clear the failure of the wxPyConvert above
7981 arg1 = wxPyCBInputStream_create(obj0, true);
7982 if (arg1 == NULL) {
7983 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7984 SWIG_fail;
7985 }
7986 }
7987 }
7988 {
7989 arg2 = wxString_in_helper(obj1);
7990 if (arg2 == NULL) SWIG_fail;
7991 temp2 = true;
7992 }
7993 {
7994 arg3 = wxString_in_helper(obj2);
7995 if (arg3 == NULL) SWIG_fail;
7996 temp3 = true;
7997 }
7998 {
7999 arg4 = wxString_in_helper(obj3);
8000 if (arg4 == NULL) SWIG_fail;
8001 temp4 = true;
8002 }
8003 {
8004 wxDateTime * argp;
8005 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8006 if (SWIG_arg_fail(5)) SWIG_fail;
8007 if (argp == NULL) {
8008 SWIG_null_ref("wxDateTime");
8009 }
8010 if (SWIG_arg_fail(5)) SWIG_fail;
8011 arg5 = *argp;
8012 }
8013 {
8014 PyThreadState* __tstate = wxPyBeginAllowThreads();
8015 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8016
8017 wxPyEndAllowThreads(__tstate);
8018 if (PyErr_Occurred()) SWIG_fail;
8019 }
8020 {
8021 resultobj = wxPyMake_wxObject(result, 1);
8022 }
8023 {
8024 if (temp2)
8025 delete arg2;
8026 }
8027 {
8028 if (temp3)
8029 delete arg3;
8030 }
8031 {
8032 if (temp4)
8033 delete arg4;
8034 }
8035 return resultobj;
8036 fail:
8037 {
8038 if (temp2)
8039 delete arg2;
8040 }
8041 {
8042 if (temp3)
8043 delete arg3;
8044 }
8045 {
8046 if (temp4)
8047 delete arg4;
8048 }
8049 return NULL;
8050 }
8051
8052
8053 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8054 PyObject *resultobj;
8055 wxFSFile *arg1 = (wxFSFile *) 0 ;
8056 PyObject * obj0 = 0 ;
8057 char *kwnames[] = {
8058 (char *) "self", NULL
8059 };
8060
8061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8063 if (SWIG_arg_fail(1)) SWIG_fail;
8064 {
8065 PyThreadState* __tstate = wxPyBeginAllowThreads();
8066 delete arg1;
8067
8068 wxPyEndAllowThreads(__tstate);
8069 if (PyErr_Occurred()) SWIG_fail;
8070 }
8071 Py_INCREF(Py_None); resultobj = Py_None;
8072 return resultobj;
8073 fail:
8074 return NULL;
8075 }
8076
8077
8078 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8079 PyObject *resultobj;
8080 wxFSFile *arg1 = (wxFSFile *) 0 ;
8081 wxInputStream *result;
8082 PyObject * obj0 = 0 ;
8083 char *kwnames[] = {
8084 (char *) "self", NULL
8085 };
8086
8087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8089 if (SWIG_arg_fail(1)) SWIG_fail;
8090 {
8091 PyThreadState* __tstate = wxPyBeginAllowThreads();
8092 result = (wxInputStream *)(arg1)->GetStream();
8093
8094 wxPyEndAllowThreads(__tstate);
8095 if (PyErr_Occurred()) SWIG_fail;
8096 }
8097 {
8098 wxPyInputStream * _ptr = NULL;
8099
8100 if (result) {
8101 _ptr = new wxPyInputStream(result);
8102 }
8103 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8104 }
8105 return resultobj;
8106 fail:
8107 return NULL;
8108 }
8109
8110
8111 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8112 PyObject *resultobj;
8113 wxFSFile *arg1 = (wxFSFile *) 0 ;
8114 wxString *result;
8115 PyObject * obj0 = 0 ;
8116 char *kwnames[] = {
8117 (char *) "self", NULL
8118 };
8119
8120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8122 if (SWIG_arg_fail(1)) SWIG_fail;
8123 {
8124 PyThreadState* __tstate = wxPyBeginAllowThreads();
8125 {
8126 wxString const &_result_ref = (arg1)->GetMimeType();
8127 result = (wxString *) &_result_ref;
8128 }
8129
8130 wxPyEndAllowThreads(__tstate);
8131 if (PyErr_Occurred()) SWIG_fail;
8132 }
8133 {
8134 #if wxUSE_UNICODE
8135 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8136 #else
8137 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8138 #endif
8139 }
8140 return resultobj;
8141 fail:
8142 return NULL;
8143 }
8144
8145
8146 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8147 PyObject *resultobj;
8148 wxFSFile *arg1 = (wxFSFile *) 0 ;
8149 wxString *result;
8150 PyObject * obj0 = 0 ;
8151 char *kwnames[] = {
8152 (char *) "self", NULL
8153 };
8154
8155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8157 if (SWIG_arg_fail(1)) SWIG_fail;
8158 {
8159 PyThreadState* __tstate = wxPyBeginAllowThreads();
8160 {
8161 wxString const &_result_ref = (arg1)->GetLocation();
8162 result = (wxString *) &_result_ref;
8163 }
8164
8165 wxPyEndAllowThreads(__tstate);
8166 if (PyErr_Occurred()) SWIG_fail;
8167 }
8168 {
8169 #if wxUSE_UNICODE
8170 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8171 #else
8172 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8173 #endif
8174 }
8175 return resultobj;
8176 fail:
8177 return NULL;
8178 }
8179
8180
8181 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8182 PyObject *resultobj;
8183 wxFSFile *arg1 = (wxFSFile *) 0 ;
8184 wxString *result;
8185 PyObject * obj0 = 0 ;
8186 char *kwnames[] = {
8187 (char *) "self", NULL
8188 };
8189
8190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8192 if (SWIG_arg_fail(1)) SWIG_fail;
8193 {
8194 PyThreadState* __tstate = wxPyBeginAllowThreads();
8195 {
8196 wxString const &_result_ref = (arg1)->GetAnchor();
8197 result = (wxString *) &_result_ref;
8198 }
8199
8200 wxPyEndAllowThreads(__tstate);
8201 if (PyErr_Occurred()) SWIG_fail;
8202 }
8203 {
8204 #if wxUSE_UNICODE
8205 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8206 #else
8207 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8208 #endif
8209 }
8210 return resultobj;
8211 fail:
8212 return NULL;
8213 }
8214
8215
8216 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8217 PyObject *resultobj;
8218 wxFSFile *arg1 = (wxFSFile *) 0 ;
8219 wxDateTime result;
8220 PyObject * obj0 = 0 ;
8221 char *kwnames[] = {
8222 (char *) "self", NULL
8223 };
8224
8225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8226 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8227 if (SWIG_arg_fail(1)) SWIG_fail;
8228 {
8229 PyThreadState* __tstate = wxPyBeginAllowThreads();
8230 result = (arg1)->GetModificationTime();
8231
8232 wxPyEndAllowThreads(__tstate);
8233 if (PyErr_Occurred()) SWIG_fail;
8234 }
8235 {
8236 wxDateTime * resultptr;
8237 resultptr = new wxDateTime((wxDateTime &)(result));
8238 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8239 }
8240 return resultobj;
8241 fail:
8242 return NULL;
8243 }
8244
8245
8246 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8247 PyObject *obj;
8248 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8249 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8250 Py_INCREF(obj);
8251 return Py_BuildValue((char *)"");
8252 }
8253 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8254 PyObject *obj;
8255 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8256 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8257 Py_INCREF(obj);
8258 return Py_BuildValue((char *)"");
8259 }
8260 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8261 PyObject *resultobj;
8262 wxPyFileSystemHandler *result;
8263 char *kwnames[] = {
8264 NULL
8265 };
8266
8267 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8268 {
8269 PyThreadState* __tstate = wxPyBeginAllowThreads();
8270 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8271
8272 wxPyEndAllowThreads(__tstate);
8273 if (PyErr_Occurred()) SWIG_fail;
8274 }
8275 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8276 return resultobj;
8277 fail:
8278 return NULL;
8279 }
8280
8281
8282 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8283 PyObject *resultobj;
8284 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8285 PyObject *arg2 = (PyObject *) 0 ;
8286 PyObject *arg3 = (PyObject *) 0 ;
8287 PyObject * obj0 = 0 ;
8288 PyObject * obj1 = 0 ;
8289 PyObject * obj2 = 0 ;
8290 char *kwnames[] = {
8291 (char *) "self",(char *) "self",(char *) "_class", NULL
8292 };
8293
8294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8296 if (SWIG_arg_fail(1)) SWIG_fail;
8297 arg2 = obj1;
8298 arg3 = obj2;
8299 {
8300 PyThreadState* __tstate = wxPyBeginAllowThreads();
8301 (arg1)->_setCallbackInfo(arg2,arg3);
8302
8303 wxPyEndAllowThreads(__tstate);
8304 if (PyErr_Occurred()) SWIG_fail;
8305 }
8306 Py_INCREF(Py_None); resultobj = Py_None;
8307 return resultobj;
8308 fail:
8309 return NULL;
8310 }
8311
8312
8313 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8314 PyObject *resultobj;
8315 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8316 wxString *arg2 = 0 ;
8317 bool result;
8318 bool temp2 = false ;
8319 PyObject * obj0 = 0 ;
8320 PyObject * obj1 = 0 ;
8321 char *kwnames[] = {
8322 (char *) "self",(char *) "location", NULL
8323 };
8324
8325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8327 if (SWIG_arg_fail(1)) SWIG_fail;
8328 {
8329 arg2 = wxString_in_helper(obj1);
8330 if (arg2 == NULL) SWIG_fail;
8331 temp2 = true;
8332 }
8333 {
8334 PyThreadState* __tstate = wxPyBeginAllowThreads();
8335 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8336
8337 wxPyEndAllowThreads(__tstate);
8338 if (PyErr_Occurred()) SWIG_fail;
8339 }
8340 {
8341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8342 }
8343 {
8344 if (temp2)
8345 delete arg2;
8346 }
8347 return resultobj;
8348 fail:
8349 {
8350 if (temp2)
8351 delete arg2;
8352 }
8353 return NULL;
8354 }
8355
8356
8357 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8358 PyObject *resultobj;
8359 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8360 wxFileSystem *arg2 = 0 ;
8361 wxString *arg3 = 0 ;
8362 wxFSFile *result;
8363 bool temp3 = false ;
8364 PyObject * obj0 = 0 ;
8365 PyObject * obj1 = 0 ;
8366 PyObject * obj2 = 0 ;
8367 char *kwnames[] = {
8368 (char *) "self",(char *) "fs",(char *) "location", NULL
8369 };
8370
8371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8373 if (SWIG_arg_fail(1)) SWIG_fail;
8374 {
8375 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8376 if (SWIG_arg_fail(2)) SWIG_fail;
8377 if (arg2 == NULL) {
8378 SWIG_null_ref("wxFileSystem");
8379 }
8380 if (SWIG_arg_fail(2)) SWIG_fail;
8381 }
8382 {
8383 arg3 = wxString_in_helper(obj2);
8384 if (arg3 == NULL) SWIG_fail;
8385 temp3 = true;
8386 }
8387 {
8388 PyThreadState* __tstate = wxPyBeginAllowThreads();
8389 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8390
8391 wxPyEndAllowThreads(__tstate);
8392 if (PyErr_Occurred()) SWIG_fail;
8393 }
8394 {
8395 resultobj = wxPyMake_wxObject(result, 1);
8396 }
8397 {
8398 if (temp3)
8399 delete arg3;
8400 }
8401 return resultobj;
8402 fail:
8403 {
8404 if (temp3)
8405 delete arg3;
8406 }
8407 return NULL;
8408 }
8409
8410
8411 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8412 PyObject *resultobj;
8413 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8414 wxString *arg2 = 0 ;
8415 int arg3 = (int) 0 ;
8416 wxString result;
8417 bool temp2 = false ;
8418 PyObject * obj0 = 0 ;
8419 PyObject * obj1 = 0 ;
8420 PyObject * obj2 = 0 ;
8421 char *kwnames[] = {
8422 (char *) "self",(char *) "spec",(char *) "flags", NULL
8423 };
8424
8425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8427 if (SWIG_arg_fail(1)) SWIG_fail;
8428 {
8429 arg2 = wxString_in_helper(obj1);
8430 if (arg2 == NULL) SWIG_fail;
8431 temp2 = true;
8432 }
8433 if (obj2) {
8434 {
8435 arg3 = (int)(SWIG_As_int(obj2));
8436 if (SWIG_arg_fail(3)) SWIG_fail;
8437 }
8438 }
8439 {
8440 PyThreadState* __tstate = wxPyBeginAllowThreads();
8441 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8442
8443 wxPyEndAllowThreads(__tstate);
8444 if (PyErr_Occurred()) SWIG_fail;
8445 }
8446 {
8447 #if wxUSE_UNICODE
8448 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8449 #else
8450 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8451 #endif
8452 }
8453 {
8454 if (temp2)
8455 delete arg2;
8456 }
8457 return resultobj;
8458 fail:
8459 {
8460 if (temp2)
8461 delete arg2;
8462 }
8463 return NULL;
8464 }
8465
8466
8467 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8468 PyObject *resultobj;
8469 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8470 wxString result;
8471 PyObject * obj0 = 0 ;
8472 char *kwnames[] = {
8473 (char *) "self", NULL
8474 };
8475
8476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8478 if (SWIG_arg_fail(1)) SWIG_fail;
8479 {
8480 PyThreadState* __tstate = wxPyBeginAllowThreads();
8481 result = (arg1)->FindNext();
8482
8483 wxPyEndAllowThreads(__tstate);
8484 if (PyErr_Occurred()) SWIG_fail;
8485 }
8486 {
8487 #if wxUSE_UNICODE
8488 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8489 #else
8490 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8491 #endif
8492 }
8493 return resultobj;
8494 fail:
8495 return NULL;
8496 }
8497
8498
8499 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8500 PyObject *resultobj;
8501 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8502 wxString *arg2 = 0 ;
8503 wxString result;
8504 bool temp2 = false ;
8505 PyObject * obj0 = 0 ;
8506 PyObject * obj1 = 0 ;
8507 char *kwnames[] = {
8508 (char *) "self",(char *) "location", NULL
8509 };
8510
8511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8513 if (SWIG_arg_fail(1)) SWIG_fail;
8514 {
8515 arg2 = wxString_in_helper(obj1);
8516 if (arg2 == NULL) SWIG_fail;
8517 temp2 = true;
8518 }
8519 {
8520 PyThreadState* __tstate = wxPyBeginAllowThreads();
8521 result = (arg1)->GetProtocol((wxString const &)*arg2);
8522
8523 wxPyEndAllowThreads(__tstate);
8524 if (PyErr_Occurred()) SWIG_fail;
8525 }
8526 {
8527 #if wxUSE_UNICODE
8528 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8529 #else
8530 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8531 #endif
8532 }
8533 {
8534 if (temp2)
8535 delete arg2;
8536 }
8537 return resultobj;
8538 fail:
8539 {
8540 if (temp2)
8541 delete arg2;
8542 }
8543 return NULL;
8544 }
8545
8546
8547 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8548 PyObject *resultobj;
8549 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8550 wxString *arg2 = 0 ;
8551 wxString result;
8552 bool temp2 = false ;
8553 PyObject * obj0 = 0 ;
8554 PyObject * obj1 = 0 ;
8555 char *kwnames[] = {
8556 (char *) "self",(char *) "location", NULL
8557 };
8558
8559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8561 if (SWIG_arg_fail(1)) SWIG_fail;
8562 {
8563 arg2 = wxString_in_helper(obj1);
8564 if (arg2 == NULL) SWIG_fail;
8565 temp2 = true;
8566 }
8567 {
8568 PyThreadState* __tstate = wxPyBeginAllowThreads();
8569 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8570
8571 wxPyEndAllowThreads(__tstate);
8572 if (PyErr_Occurred()) SWIG_fail;
8573 }
8574 {
8575 #if wxUSE_UNICODE
8576 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8577 #else
8578 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8579 #endif
8580 }
8581 {
8582 if (temp2)
8583 delete arg2;
8584 }
8585 return resultobj;
8586 fail:
8587 {
8588 if (temp2)
8589 delete arg2;
8590 }
8591 return NULL;
8592 }
8593
8594
8595 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8596 PyObject *resultobj;
8597 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8598 wxString *arg2 = 0 ;
8599 wxString result;
8600 bool temp2 = false ;
8601 PyObject * obj0 = 0 ;
8602 PyObject * obj1 = 0 ;
8603 char *kwnames[] = {
8604 (char *) "self",(char *) "location", NULL
8605 };
8606
8607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8609 if (SWIG_arg_fail(1)) SWIG_fail;
8610 {
8611 arg2 = wxString_in_helper(obj1);
8612 if (arg2 == NULL) SWIG_fail;
8613 temp2 = true;
8614 }
8615 {
8616 PyThreadState* __tstate = wxPyBeginAllowThreads();
8617 result = (arg1)->GetAnchor((wxString const &)*arg2);
8618
8619 wxPyEndAllowThreads(__tstate);
8620 if (PyErr_Occurred()) SWIG_fail;
8621 }
8622 {
8623 #if wxUSE_UNICODE
8624 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8625 #else
8626 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8627 #endif
8628 }
8629 {
8630 if (temp2)
8631 delete arg2;
8632 }
8633 return resultobj;
8634 fail:
8635 {
8636 if (temp2)
8637 delete arg2;
8638 }
8639 return NULL;
8640 }
8641
8642
8643 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8644 PyObject *resultobj;
8645 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8646 wxString *arg2 = 0 ;
8647 wxString result;
8648 bool temp2 = false ;
8649 PyObject * obj0 = 0 ;
8650 PyObject * obj1 = 0 ;
8651 char *kwnames[] = {
8652 (char *) "self",(char *) "location", NULL
8653 };
8654
8655 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8656 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8657 if (SWIG_arg_fail(1)) SWIG_fail;
8658 {
8659 arg2 = wxString_in_helper(obj1);
8660 if (arg2 == NULL) SWIG_fail;
8661 temp2 = true;
8662 }
8663 {
8664 PyThreadState* __tstate = wxPyBeginAllowThreads();
8665 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8666
8667 wxPyEndAllowThreads(__tstate);
8668 if (PyErr_Occurred()) SWIG_fail;
8669 }
8670 {
8671 #if wxUSE_UNICODE
8672 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8673 #else
8674 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8675 #endif
8676 }
8677 {
8678 if (temp2)
8679 delete arg2;
8680 }
8681 return resultobj;
8682 fail:
8683 {
8684 if (temp2)
8685 delete arg2;
8686 }
8687 return NULL;
8688 }
8689
8690
8691 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8692 PyObject *resultobj;
8693 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8694 wxString *arg2 = 0 ;
8695 wxString result;
8696 bool temp2 = false ;
8697 PyObject * obj0 = 0 ;
8698 PyObject * obj1 = 0 ;
8699 char *kwnames[] = {
8700 (char *) "self",(char *) "location", NULL
8701 };
8702
8703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8705 if (SWIG_arg_fail(1)) SWIG_fail;
8706 {
8707 arg2 = wxString_in_helper(obj1);
8708 if (arg2 == NULL) SWIG_fail;
8709 temp2 = true;
8710 }
8711 {
8712 PyThreadState* __tstate = wxPyBeginAllowThreads();
8713 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8714
8715 wxPyEndAllowThreads(__tstate);
8716 if (PyErr_Occurred()) SWIG_fail;
8717 }
8718 {
8719 #if wxUSE_UNICODE
8720 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8721 #else
8722 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8723 #endif
8724 }
8725 {
8726 if (temp2)
8727 delete arg2;
8728 }
8729 return resultobj;
8730 fail:
8731 {
8732 if (temp2)
8733 delete arg2;
8734 }
8735 return NULL;
8736 }
8737
8738
8739 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8740 PyObject *obj;
8741 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8742 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8743 Py_INCREF(obj);
8744 return Py_BuildValue((char *)"");
8745 }
8746 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8747 PyObject *resultobj;
8748 wxFileSystem *result;
8749 char *kwnames[] = {
8750 NULL
8751 };
8752
8753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8754 {
8755 PyThreadState* __tstate = wxPyBeginAllowThreads();
8756 result = (wxFileSystem *)new wxFileSystem();
8757
8758 wxPyEndAllowThreads(__tstate);
8759 if (PyErr_Occurred()) SWIG_fail;
8760 }
8761 {
8762 resultobj = wxPyMake_wxObject(result, 1);
8763 }
8764 return resultobj;
8765 fail:
8766 return NULL;
8767 }
8768
8769
8770 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8771 PyObject *resultobj;
8772 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8773 PyObject * obj0 = 0 ;
8774 char *kwnames[] = {
8775 (char *) "self", NULL
8776 };
8777
8778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8780 if (SWIG_arg_fail(1)) SWIG_fail;
8781 {
8782 PyThreadState* __tstate = wxPyBeginAllowThreads();
8783 delete arg1;
8784
8785 wxPyEndAllowThreads(__tstate);
8786 if (PyErr_Occurred()) SWIG_fail;
8787 }
8788 Py_INCREF(Py_None); resultobj = Py_None;
8789 return resultobj;
8790 fail:
8791 return NULL;
8792 }
8793
8794
8795 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8796 PyObject *resultobj;
8797 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8798 wxString *arg2 = 0 ;
8799 bool arg3 = (bool) false ;
8800 bool temp2 = false ;
8801 PyObject * obj0 = 0 ;
8802 PyObject * obj1 = 0 ;
8803 PyObject * obj2 = 0 ;
8804 char *kwnames[] = {
8805 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8806 };
8807
8808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8810 if (SWIG_arg_fail(1)) SWIG_fail;
8811 {
8812 arg2 = wxString_in_helper(obj1);
8813 if (arg2 == NULL) SWIG_fail;
8814 temp2 = true;
8815 }
8816 if (obj2) {
8817 {
8818 arg3 = (bool)(SWIG_As_bool(obj2));
8819 if (SWIG_arg_fail(3)) SWIG_fail;
8820 }
8821 }
8822 {
8823 PyThreadState* __tstate = wxPyBeginAllowThreads();
8824 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8825
8826 wxPyEndAllowThreads(__tstate);
8827 if (PyErr_Occurred()) SWIG_fail;
8828 }
8829 Py_INCREF(Py_None); resultobj = Py_None;
8830 {
8831 if (temp2)
8832 delete arg2;
8833 }
8834 return resultobj;
8835 fail:
8836 {
8837 if (temp2)
8838 delete arg2;
8839 }
8840 return NULL;
8841 }
8842
8843
8844 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8845 PyObject *resultobj;
8846 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8847 wxString result;
8848 PyObject * obj0 = 0 ;
8849 char *kwnames[] = {
8850 (char *) "self", NULL
8851 };
8852
8853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8855 if (SWIG_arg_fail(1)) SWIG_fail;
8856 {
8857 PyThreadState* __tstate = wxPyBeginAllowThreads();
8858 result = (arg1)->GetPath();
8859
8860 wxPyEndAllowThreads(__tstate);
8861 if (PyErr_Occurred()) SWIG_fail;
8862 }
8863 {
8864 #if wxUSE_UNICODE
8865 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8866 #else
8867 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8868 #endif
8869 }
8870 return resultobj;
8871 fail:
8872 return NULL;
8873 }
8874
8875
8876 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8877 PyObject *resultobj;
8878 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8879 wxString *arg2 = 0 ;
8880 wxFSFile *result;
8881 bool temp2 = false ;
8882 PyObject * obj0 = 0 ;
8883 PyObject * obj1 = 0 ;
8884 char *kwnames[] = {
8885 (char *) "self",(char *) "location", NULL
8886 };
8887
8888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8889 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8890 if (SWIG_arg_fail(1)) SWIG_fail;
8891 {
8892 arg2 = wxString_in_helper(obj1);
8893 if (arg2 == NULL) SWIG_fail;
8894 temp2 = true;
8895 }
8896 {
8897 PyThreadState* __tstate = wxPyBeginAllowThreads();
8898 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8899
8900 wxPyEndAllowThreads(__tstate);
8901 if (PyErr_Occurred()) SWIG_fail;
8902 }
8903 {
8904 resultobj = wxPyMake_wxObject(result, 1);
8905 }
8906 {
8907 if (temp2)
8908 delete arg2;
8909 }
8910 return resultobj;
8911 fail:
8912 {
8913 if (temp2)
8914 delete arg2;
8915 }
8916 return NULL;
8917 }
8918
8919
8920 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8921 PyObject *resultobj;
8922 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8923 wxString *arg2 = 0 ;
8924 int arg3 = (int) 0 ;
8925 wxString result;
8926 bool temp2 = false ;
8927 PyObject * obj0 = 0 ;
8928 PyObject * obj1 = 0 ;
8929 PyObject * obj2 = 0 ;
8930 char *kwnames[] = {
8931 (char *) "self",(char *) "spec",(char *) "flags", NULL
8932 };
8933
8934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8936 if (SWIG_arg_fail(1)) SWIG_fail;
8937 {
8938 arg2 = wxString_in_helper(obj1);
8939 if (arg2 == NULL) SWIG_fail;
8940 temp2 = true;
8941 }
8942 if (obj2) {
8943 {
8944 arg3 = (int)(SWIG_As_int(obj2));
8945 if (SWIG_arg_fail(3)) SWIG_fail;
8946 }
8947 }
8948 {
8949 PyThreadState* __tstate = wxPyBeginAllowThreads();
8950 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8951
8952 wxPyEndAllowThreads(__tstate);
8953 if (PyErr_Occurred()) SWIG_fail;
8954 }
8955 {
8956 #if wxUSE_UNICODE
8957 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8958 #else
8959 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8960 #endif
8961 }
8962 {
8963 if (temp2)
8964 delete arg2;
8965 }
8966 return resultobj;
8967 fail:
8968 {
8969 if (temp2)
8970 delete arg2;
8971 }
8972 return NULL;
8973 }
8974
8975
8976 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8977 PyObject *resultobj;
8978 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8979 wxString result;
8980 PyObject * obj0 = 0 ;
8981 char *kwnames[] = {
8982 (char *) "self", NULL
8983 };
8984
8985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8987 if (SWIG_arg_fail(1)) SWIG_fail;
8988 {
8989 PyThreadState* __tstate = wxPyBeginAllowThreads();
8990 result = (arg1)->FindNext();
8991
8992 wxPyEndAllowThreads(__tstate);
8993 if (PyErr_Occurred()) SWIG_fail;
8994 }
8995 {
8996 #if wxUSE_UNICODE
8997 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8998 #else
8999 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9000 #endif
9001 }
9002 return resultobj;
9003 fail:
9004 return NULL;
9005 }
9006
9007
9008 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9009 PyObject *resultobj;
9010 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9011 PyObject * obj0 = 0 ;
9012 char *kwnames[] = {
9013 (char *) "handler", NULL
9014 };
9015
9016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9018 if (SWIG_arg_fail(1)) SWIG_fail;
9019 {
9020 PyThreadState* __tstate = wxPyBeginAllowThreads();
9021 wxFileSystem::AddHandler(arg1);
9022
9023 wxPyEndAllowThreads(__tstate);
9024 if (PyErr_Occurred()) SWIG_fail;
9025 }
9026 Py_INCREF(Py_None); resultobj = Py_None;
9027 return resultobj;
9028 fail:
9029 return NULL;
9030 }
9031
9032
9033 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9034 PyObject *resultobj;
9035 char *kwnames[] = {
9036 NULL
9037 };
9038
9039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9040 {
9041 PyThreadState* __tstate = wxPyBeginAllowThreads();
9042 wxFileSystem::CleanUpHandlers();
9043
9044 wxPyEndAllowThreads(__tstate);
9045 if (PyErr_Occurred()) SWIG_fail;
9046 }
9047 Py_INCREF(Py_None); resultobj = Py_None;
9048 return resultobj;
9049 fail:
9050 return NULL;
9051 }
9052
9053
9054 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9055 PyObject *resultobj;
9056 wxString *arg1 = 0 ;
9057 wxString result;
9058 bool temp1 = false ;
9059 PyObject * obj0 = 0 ;
9060 char *kwnames[] = {
9061 (char *) "filename", NULL
9062 };
9063
9064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9065 {
9066 arg1 = wxString_in_helper(obj0);
9067 if (arg1 == NULL) SWIG_fail;
9068 temp1 = true;
9069 }
9070 {
9071 PyThreadState* __tstate = wxPyBeginAllowThreads();
9072 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9073
9074 wxPyEndAllowThreads(__tstate);
9075 if (PyErr_Occurred()) SWIG_fail;
9076 }
9077 {
9078 #if wxUSE_UNICODE
9079 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9080 #else
9081 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9082 #endif
9083 }
9084 {
9085 if (temp1)
9086 delete arg1;
9087 }
9088 return resultobj;
9089 fail:
9090 {
9091 if (temp1)
9092 delete arg1;
9093 }
9094 return NULL;
9095 }
9096
9097
9098 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9099 PyObject *resultobj;
9100 wxString *arg1 = 0 ;
9101 wxString result;
9102 bool temp1 = false ;
9103 PyObject * obj0 = 0 ;
9104 char *kwnames[] = {
9105 (char *) "url", NULL
9106 };
9107
9108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9109 {
9110 arg1 = wxString_in_helper(obj0);
9111 if (arg1 == NULL) SWIG_fail;
9112 temp1 = true;
9113 }
9114 {
9115 PyThreadState* __tstate = wxPyBeginAllowThreads();
9116 result = FileSystem_URLToFileName((wxString const &)*arg1);
9117
9118 wxPyEndAllowThreads(__tstate);
9119 if (PyErr_Occurred()) SWIG_fail;
9120 }
9121 {
9122 #if wxUSE_UNICODE
9123 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9124 #else
9125 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9126 #endif
9127 }
9128 {
9129 if (temp1)
9130 delete arg1;
9131 }
9132 return resultobj;
9133 fail:
9134 {
9135 if (temp1)
9136 delete arg1;
9137 }
9138 return NULL;
9139 }
9140
9141
9142 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9143 PyObject *obj;
9144 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9145 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9146 Py_INCREF(obj);
9147 return Py_BuildValue((char *)"");
9148 }
9149 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9150 PyObject *resultobj;
9151 wxInternetFSHandler *result;
9152 char *kwnames[] = {
9153 NULL
9154 };
9155
9156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9157 {
9158 PyThreadState* __tstate = wxPyBeginAllowThreads();
9159 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9160
9161 wxPyEndAllowThreads(__tstate);
9162 if (PyErr_Occurred()) SWIG_fail;
9163 }
9164 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9165 return resultobj;
9166 fail:
9167 return NULL;
9168 }
9169
9170
9171 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9172 PyObject *resultobj;
9173 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9174 wxString *arg2 = 0 ;
9175 bool result;
9176 bool temp2 = false ;
9177 PyObject * obj0 = 0 ;
9178 PyObject * obj1 = 0 ;
9179 char *kwnames[] = {
9180 (char *) "self",(char *) "location", NULL
9181 };
9182
9183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9185 if (SWIG_arg_fail(1)) SWIG_fail;
9186 {
9187 arg2 = wxString_in_helper(obj1);
9188 if (arg2 == NULL) SWIG_fail;
9189 temp2 = true;
9190 }
9191 {
9192 PyThreadState* __tstate = wxPyBeginAllowThreads();
9193 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9194
9195 wxPyEndAllowThreads(__tstate);
9196 if (PyErr_Occurred()) SWIG_fail;
9197 }
9198 {
9199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9200 }
9201 {
9202 if (temp2)
9203 delete arg2;
9204 }
9205 return resultobj;
9206 fail:
9207 {
9208 if (temp2)
9209 delete arg2;
9210 }
9211 return NULL;
9212 }
9213
9214
9215 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9216 PyObject *resultobj;
9217 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9218 wxFileSystem *arg2 = 0 ;
9219 wxString *arg3 = 0 ;
9220 wxFSFile *result;
9221 bool temp3 = false ;
9222 PyObject * obj0 = 0 ;
9223 PyObject * obj1 = 0 ;
9224 PyObject * obj2 = 0 ;
9225 char *kwnames[] = {
9226 (char *) "self",(char *) "fs",(char *) "location", NULL
9227 };
9228
9229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9231 if (SWIG_arg_fail(1)) SWIG_fail;
9232 {
9233 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9234 if (SWIG_arg_fail(2)) SWIG_fail;
9235 if (arg2 == NULL) {
9236 SWIG_null_ref("wxFileSystem");
9237 }
9238 if (SWIG_arg_fail(2)) SWIG_fail;
9239 }
9240 {
9241 arg3 = wxString_in_helper(obj2);
9242 if (arg3 == NULL) SWIG_fail;
9243 temp3 = true;
9244 }
9245 {
9246 PyThreadState* __tstate = wxPyBeginAllowThreads();
9247 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9248
9249 wxPyEndAllowThreads(__tstate);
9250 if (PyErr_Occurred()) SWIG_fail;
9251 }
9252 {
9253 resultobj = wxPyMake_wxObject(result, 1);
9254 }
9255 {
9256 if (temp3)
9257 delete arg3;
9258 }
9259 return resultobj;
9260 fail:
9261 {
9262 if (temp3)
9263 delete arg3;
9264 }
9265 return NULL;
9266 }
9267
9268
9269 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9270 PyObject *obj;
9271 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9272 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9273 Py_INCREF(obj);
9274 return Py_BuildValue((char *)"");
9275 }
9276 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9277 PyObject *resultobj;
9278 wxZipFSHandler *result;
9279 char *kwnames[] = {
9280 NULL
9281 };
9282
9283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9284 {
9285 PyThreadState* __tstate = wxPyBeginAllowThreads();
9286 result = (wxZipFSHandler *)new wxZipFSHandler();
9287
9288 wxPyEndAllowThreads(__tstate);
9289 if (PyErr_Occurred()) SWIG_fail;
9290 }
9291 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9292 return resultobj;
9293 fail:
9294 return NULL;
9295 }
9296
9297
9298 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9299 PyObject *resultobj;
9300 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9301 wxString *arg2 = 0 ;
9302 bool result;
9303 bool temp2 = false ;
9304 PyObject * obj0 = 0 ;
9305 PyObject * obj1 = 0 ;
9306 char *kwnames[] = {
9307 (char *) "self",(char *) "location", NULL
9308 };
9309
9310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9312 if (SWIG_arg_fail(1)) SWIG_fail;
9313 {
9314 arg2 = wxString_in_helper(obj1);
9315 if (arg2 == NULL) SWIG_fail;
9316 temp2 = true;
9317 }
9318 {
9319 PyThreadState* __tstate = wxPyBeginAllowThreads();
9320 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9321
9322 wxPyEndAllowThreads(__tstate);
9323 if (PyErr_Occurred()) SWIG_fail;
9324 }
9325 {
9326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9327 }
9328 {
9329 if (temp2)
9330 delete arg2;
9331 }
9332 return resultobj;
9333 fail:
9334 {
9335 if (temp2)
9336 delete arg2;
9337 }
9338 return NULL;
9339 }
9340
9341
9342 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9343 PyObject *resultobj;
9344 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9345 wxFileSystem *arg2 = 0 ;
9346 wxString *arg3 = 0 ;
9347 wxFSFile *result;
9348 bool temp3 = false ;
9349 PyObject * obj0 = 0 ;
9350 PyObject * obj1 = 0 ;
9351 PyObject * obj2 = 0 ;
9352 char *kwnames[] = {
9353 (char *) "self",(char *) "fs",(char *) "location", NULL
9354 };
9355
9356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9358 if (SWIG_arg_fail(1)) SWIG_fail;
9359 {
9360 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9361 if (SWIG_arg_fail(2)) SWIG_fail;
9362 if (arg2 == NULL) {
9363 SWIG_null_ref("wxFileSystem");
9364 }
9365 if (SWIG_arg_fail(2)) SWIG_fail;
9366 }
9367 {
9368 arg3 = wxString_in_helper(obj2);
9369 if (arg3 == NULL) SWIG_fail;
9370 temp3 = true;
9371 }
9372 {
9373 PyThreadState* __tstate = wxPyBeginAllowThreads();
9374 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9375
9376 wxPyEndAllowThreads(__tstate);
9377 if (PyErr_Occurred()) SWIG_fail;
9378 }
9379 {
9380 resultobj = wxPyMake_wxObject(result, 1);
9381 }
9382 {
9383 if (temp3)
9384 delete arg3;
9385 }
9386 return resultobj;
9387 fail:
9388 {
9389 if (temp3)
9390 delete arg3;
9391 }
9392 return NULL;
9393 }
9394
9395
9396 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9397 PyObject *resultobj;
9398 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9399 wxString *arg2 = 0 ;
9400 int arg3 = (int) 0 ;
9401 wxString result;
9402 bool temp2 = false ;
9403 PyObject * obj0 = 0 ;
9404 PyObject * obj1 = 0 ;
9405 PyObject * obj2 = 0 ;
9406 char *kwnames[] = {
9407 (char *) "self",(char *) "spec",(char *) "flags", NULL
9408 };
9409
9410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9412 if (SWIG_arg_fail(1)) SWIG_fail;
9413 {
9414 arg2 = wxString_in_helper(obj1);
9415 if (arg2 == NULL) SWIG_fail;
9416 temp2 = true;
9417 }
9418 if (obj2) {
9419 {
9420 arg3 = (int)(SWIG_As_int(obj2));
9421 if (SWIG_arg_fail(3)) SWIG_fail;
9422 }
9423 }
9424 {
9425 PyThreadState* __tstate = wxPyBeginAllowThreads();
9426 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9427
9428 wxPyEndAllowThreads(__tstate);
9429 if (PyErr_Occurred()) SWIG_fail;
9430 }
9431 {
9432 #if wxUSE_UNICODE
9433 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9434 #else
9435 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9436 #endif
9437 }
9438 {
9439 if (temp2)
9440 delete arg2;
9441 }
9442 return resultobj;
9443 fail:
9444 {
9445 if (temp2)
9446 delete arg2;
9447 }
9448 return NULL;
9449 }
9450
9451
9452 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9453 PyObject *resultobj;
9454 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9455 wxString result;
9456 PyObject * obj0 = 0 ;
9457 char *kwnames[] = {
9458 (char *) "self", NULL
9459 };
9460
9461 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9462 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9463 if (SWIG_arg_fail(1)) SWIG_fail;
9464 {
9465 PyThreadState* __tstate = wxPyBeginAllowThreads();
9466 result = (arg1)->FindNext();
9467
9468 wxPyEndAllowThreads(__tstate);
9469 if (PyErr_Occurred()) SWIG_fail;
9470 }
9471 {
9472 #if wxUSE_UNICODE
9473 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9474 #else
9475 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9476 #endif
9477 }
9478 return resultobj;
9479 fail:
9480 return NULL;
9481 }
9482
9483
9484 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9485 PyObject *obj;
9486 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9487 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9488 Py_INCREF(obj);
9489 return Py_BuildValue((char *)"");
9490 }
9491 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9492 PyObject *resultobj;
9493 wxString *arg1 = 0 ;
9494 wxImage *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 *) "image",(char *) "type", NULL
9502 };
9503
9504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",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_wxImage, SWIG_POINTER_EXCEPTION | 0);
9512 if (SWIG_arg_fail(2)) SWIG_fail;
9513 if (arg2 == NULL) {
9514 SWIG_null_ref("wxImage");
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_wxImage((wxString const &)*arg1,*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_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9545 PyObject *resultobj;
9546 wxString *arg1 = 0 ;
9547 wxBitmap *arg2 = 0 ;
9548 long arg3 ;
9549 bool temp1 = false ;
9550 PyObject * obj0 = 0 ;
9551 PyObject * obj1 = 0 ;
9552 PyObject * obj2 = 0 ;
9553 char *kwnames[] = {
9554 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9555 };
9556
9557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9558 {
9559 arg1 = wxString_in_helper(obj0);
9560 if (arg1 == NULL) SWIG_fail;
9561 temp1 = true;
9562 }
9563 {
9564 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9565 if (SWIG_arg_fail(2)) SWIG_fail;
9566 if (arg2 == NULL) {
9567 SWIG_null_ref("wxBitmap");
9568 }
9569 if (SWIG_arg_fail(2)) SWIG_fail;
9570 }
9571 {
9572 arg3 = (long)(SWIG_As_long(obj2));
9573 if (SWIG_arg_fail(3)) SWIG_fail;
9574 }
9575 {
9576 PyThreadState* __tstate = wxPyBeginAllowThreads();
9577 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9578
9579 wxPyEndAllowThreads(__tstate);
9580 if (PyErr_Occurred()) SWIG_fail;
9581 }
9582 Py_INCREF(Py_None); resultobj = Py_None;
9583 {
9584 if (temp1)
9585 delete arg1;
9586 }
9587 return resultobj;
9588 fail:
9589 {
9590 if (temp1)
9591 delete arg1;
9592 }
9593 return NULL;
9594 }
9595
9596
9597 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9598 PyObject *resultobj;
9599 wxString *arg1 = 0 ;
9600 PyObject *arg2 = (PyObject *) 0 ;
9601 bool temp1 = false ;
9602 PyObject * obj0 = 0 ;
9603 PyObject * obj1 = 0 ;
9604 char *kwnames[] = {
9605 (char *) "filename",(char *) "data", NULL
9606 };
9607
9608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9609 {
9610 arg1 = wxString_in_helper(obj0);
9611 if (arg1 == NULL) SWIG_fail;
9612 temp1 = true;
9613 }
9614 arg2 = obj1;
9615 {
9616 PyThreadState* __tstate = wxPyBeginAllowThreads();
9617 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9618
9619 wxPyEndAllowThreads(__tstate);
9620 if (PyErr_Occurred()) SWIG_fail;
9621 }
9622 Py_INCREF(Py_None); resultobj = Py_None;
9623 {
9624 if (temp1)
9625 delete arg1;
9626 }
9627 return resultobj;
9628 fail:
9629 {
9630 if (temp1)
9631 delete arg1;
9632 }
9633 return NULL;
9634 }
9635
9636
9637 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9638 PyObject *resultobj;
9639 wxMemoryFSHandler *result;
9640 char *kwnames[] = {
9641 NULL
9642 };
9643
9644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9645 {
9646 PyThreadState* __tstate = wxPyBeginAllowThreads();
9647 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9648
9649 wxPyEndAllowThreads(__tstate);
9650 if (PyErr_Occurred()) SWIG_fail;
9651 }
9652 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9653 return resultobj;
9654 fail:
9655 return NULL;
9656 }
9657
9658
9659 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9660 PyObject *resultobj;
9661 wxString *arg1 = 0 ;
9662 bool temp1 = false ;
9663 PyObject * obj0 = 0 ;
9664 char *kwnames[] = {
9665 (char *) "filename", NULL
9666 };
9667
9668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9669 {
9670 arg1 = wxString_in_helper(obj0);
9671 if (arg1 == NULL) SWIG_fail;
9672 temp1 = true;
9673 }
9674 {
9675 PyThreadState* __tstate = wxPyBeginAllowThreads();
9676 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9677
9678 wxPyEndAllowThreads(__tstate);
9679 if (PyErr_Occurred()) SWIG_fail;
9680 }
9681 Py_INCREF(Py_None); resultobj = Py_None;
9682 {
9683 if (temp1)
9684 delete arg1;
9685 }
9686 return resultobj;
9687 fail:
9688 {
9689 if (temp1)
9690 delete arg1;
9691 }
9692 return NULL;
9693 }
9694
9695
9696 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9697 PyObject *resultobj;
9698 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9699 wxString *arg2 = 0 ;
9700 bool result;
9701 bool temp2 = false ;
9702 PyObject * obj0 = 0 ;
9703 PyObject * obj1 = 0 ;
9704 char *kwnames[] = {
9705 (char *) "self",(char *) "location", NULL
9706 };
9707
9708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9710 if (SWIG_arg_fail(1)) SWIG_fail;
9711 {
9712 arg2 = wxString_in_helper(obj1);
9713 if (arg2 == NULL) SWIG_fail;
9714 temp2 = true;
9715 }
9716 {
9717 PyThreadState* __tstate = wxPyBeginAllowThreads();
9718 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9719
9720 wxPyEndAllowThreads(__tstate);
9721 if (PyErr_Occurred()) SWIG_fail;
9722 }
9723 {
9724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9725 }
9726 {
9727 if (temp2)
9728 delete arg2;
9729 }
9730 return resultobj;
9731 fail:
9732 {
9733 if (temp2)
9734 delete arg2;
9735 }
9736 return NULL;
9737 }
9738
9739
9740 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9741 PyObject *resultobj;
9742 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9743 wxFileSystem *arg2 = 0 ;
9744 wxString *arg3 = 0 ;
9745 wxFSFile *result;
9746 bool temp3 = false ;
9747 PyObject * obj0 = 0 ;
9748 PyObject * obj1 = 0 ;
9749 PyObject * obj2 = 0 ;
9750 char *kwnames[] = {
9751 (char *) "self",(char *) "fs",(char *) "location", NULL
9752 };
9753
9754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9756 if (SWIG_arg_fail(1)) SWIG_fail;
9757 {
9758 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9759 if (SWIG_arg_fail(2)) SWIG_fail;
9760 if (arg2 == NULL) {
9761 SWIG_null_ref("wxFileSystem");
9762 }
9763 if (SWIG_arg_fail(2)) SWIG_fail;
9764 }
9765 {
9766 arg3 = wxString_in_helper(obj2);
9767 if (arg3 == NULL) SWIG_fail;
9768 temp3 = true;
9769 }
9770 {
9771 PyThreadState* __tstate = wxPyBeginAllowThreads();
9772 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9773
9774 wxPyEndAllowThreads(__tstate);
9775 if (PyErr_Occurred()) SWIG_fail;
9776 }
9777 {
9778 resultobj = wxPyMake_wxObject(result, 1);
9779 }
9780 {
9781 if (temp3)
9782 delete arg3;
9783 }
9784 return resultobj;
9785 fail:
9786 {
9787 if (temp3)
9788 delete arg3;
9789 }
9790 return NULL;
9791 }
9792
9793
9794 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9795 PyObject *resultobj;
9796 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9797 wxString *arg2 = 0 ;
9798 int arg3 = (int) 0 ;
9799 wxString result;
9800 bool temp2 = false ;
9801 PyObject * obj0 = 0 ;
9802 PyObject * obj1 = 0 ;
9803 PyObject * obj2 = 0 ;
9804 char *kwnames[] = {
9805 (char *) "self",(char *) "spec",(char *) "flags", NULL
9806 };
9807
9808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9810 if (SWIG_arg_fail(1)) SWIG_fail;
9811 {
9812 arg2 = wxString_in_helper(obj1);
9813 if (arg2 == NULL) SWIG_fail;
9814 temp2 = true;
9815 }
9816 if (obj2) {
9817 {
9818 arg3 = (int)(SWIG_As_int(obj2));
9819 if (SWIG_arg_fail(3)) SWIG_fail;
9820 }
9821 }
9822 {
9823 PyThreadState* __tstate = wxPyBeginAllowThreads();
9824 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9825
9826 wxPyEndAllowThreads(__tstate);
9827 if (PyErr_Occurred()) SWIG_fail;
9828 }
9829 {
9830 #if wxUSE_UNICODE
9831 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9832 #else
9833 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9834 #endif
9835 }
9836 {
9837 if (temp2)
9838 delete arg2;
9839 }
9840 return resultobj;
9841 fail:
9842 {
9843 if (temp2)
9844 delete arg2;
9845 }
9846 return NULL;
9847 }
9848
9849
9850 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9851 PyObject *resultobj;
9852 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9853 wxString result;
9854 PyObject * obj0 = 0 ;
9855 char *kwnames[] = {
9856 (char *) "self", NULL
9857 };
9858
9859 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9860 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9861 if (SWIG_arg_fail(1)) SWIG_fail;
9862 {
9863 PyThreadState* __tstate = wxPyBeginAllowThreads();
9864 result = (arg1)->FindNext();
9865
9866 wxPyEndAllowThreads(__tstate);
9867 if (PyErr_Occurred()) SWIG_fail;
9868 }
9869 {
9870 #if wxUSE_UNICODE
9871 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9872 #else
9873 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9874 #endif
9875 }
9876 return resultobj;
9877 fail:
9878 return NULL;
9879 }
9880
9881
9882 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9883 PyObject *obj;
9884 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9885 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9886 Py_INCREF(obj);
9887 return Py_BuildValue((char *)"");
9888 }
9889 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9890 PyObject *resultobj;
9891 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9892 wxString result;
9893 PyObject * obj0 = 0 ;
9894 char *kwnames[] = {
9895 (char *) "self", NULL
9896 };
9897
9898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9900 if (SWIG_arg_fail(1)) SWIG_fail;
9901 {
9902 PyThreadState* __tstate = wxPyBeginAllowThreads();
9903 result = (arg1)->GetName();
9904
9905 wxPyEndAllowThreads(__tstate);
9906 if (PyErr_Occurred()) SWIG_fail;
9907 }
9908 {
9909 #if wxUSE_UNICODE
9910 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9911 #else
9912 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9913 #endif
9914 }
9915 return resultobj;
9916 fail:
9917 return NULL;
9918 }
9919
9920
9921 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9922 PyObject *resultobj;
9923 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9924 wxString result;
9925 PyObject * obj0 = 0 ;
9926 char *kwnames[] = {
9927 (char *) "self", NULL
9928 };
9929
9930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9932 if (SWIG_arg_fail(1)) SWIG_fail;
9933 {
9934 PyThreadState* __tstate = wxPyBeginAllowThreads();
9935 result = (arg1)->GetExtension();
9936
9937 wxPyEndAllowThreads(__tstate);
9938 if (PyErr_Occurred()) SWIG_fail;
9939 }
9940 {
9941 #if wxUSE_UNICODE
9942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9943 #else
9944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9945 #endif
9946 }
9947 return resultobj;
9948 fail:
9949 return NULL;
9950 }
9951
9952
9953 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9954 PyObject *resultobj;
9955 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9956 long result;
9957 PyObject * obj0 = 0 ;
9958 char *kwnames[] = {
9959 (char *) "self", NULL
9960 };
9961
9962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9964 if (SWIG_arg_fail(1)) SWIG_fail;
9965 {
9966 PyThreadState* __tstate = wxPyBeginAllowThreads();
9967 result = (long)(arg1)->GetType();
9968
9969 wxPyEndAllowThreads(__tstate);
9970 if (PyErr_Occurred()) SWIG_fail;
9971 }
9972 {
9973 resultobj = SWIG_From_long((long)(result));
9974 }
9975 return resultobj;
9976 fail:
9977 return NULL;
9978 }
9979
9980
9981 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9982 PyObject *resultobj;
9983 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9984 wxString result;
9985 PyObject * obj0 = 0 ;
9986 char *kwnames[] = {
9987 (char *) "self", NULL
9988 };
9989
9990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9992 if (SWIG_arg_fail(1)) SWIG_fail;
9993 {
9994 PyThreadState* __tstate = wxPyBeginAllowThreads();
9995 result = (arg1)->GetMimeType();
9996
9997 wxPyEndAllowThreads(__tstate);
9998 if (PyErr_Occurred()) SWIG_fail;
9999 }
10000 {
10001 #if wxUSE_UNICODE
10002 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10003 #else
10004 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10005 #endif
10006 }
10007 return resultobj;
10008 fail:
10009 return NULL;
10010 }
10011
10012
10013 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10014 PyObject *resultobj;
10015 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10016 wxString *arg2 = 0 ;
10017 bool result;
10018 bool temp2 = false ;
10019 PyObject * obj0 = 0 ;
10020 PyObject * obj1 = 0 ;
10021 char *kwnames[] = {
10022 (char *) "self",(char *) "name", NULL
10023 };
10024
10025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10027 if (SWIG_arg_fail(1)) SWIG_fail;
10028 {
10029 arg2 = wxString_in_helper(obj1);
10030 if (arg2 == NULL) SWIG_fail;
10031 temp2 = true;
10032 }
10033 {
10034 PyThreadState* __tstate = wxPyBeginAllowThreads();
10035 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10036
10037 wxPyEndAllowThreads(__tstate);
10038 if (PyErr_Occurred()) SWIG_fail;
10039 }
10040 {
10041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10042 }
10043 {
10044 if (temp2)
10045 delete arg2;
10046 }
10047 return resultobj;
10048 fail:
10049 {
10050 if (temp2)
10051 delete arg2;
10052 }
10053 return NULL;
10054 }
10055
10056
10057 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10058 PyObject *resultobj;
10059 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10060 wxString *arg2 = 0 ;
10061 bool temp2 = false ;
10062 PyObject * obj0 = 0 ;
10063 PyObject * obj1 = 0 ;
10064 char *kwnames[] = {
10065 (char *) "self",(char *) "name", NULL
10066 };
10067
10068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10070 if (SWIG_arg_fail(1)) SWIG_fail;
10071 {
10072 arg2 = wxString_in_helper(obj1);
10073 if (arg2 == NULL) SWIG_fail;
10074 temp2 = true;
10075 }
10076 {
10077 PyThreadState* __tstate = wxPyBeginAllowThreads();
10078 (arg1)->SetName((wxString const &)*arg2);
10079
10080 wxPyEndAllowThreads(__tstate);
10081 if (PyErr_Occurred()) SWIG_fail;
10082 }
10083 Py_INCREF(Py_None); resultobj = Py_None;
10084 {
10085 if (temp2)
10086 delete arg2;
10087 }
10088 return resultobj;
10089 fail:
10090 {
10091 if (temp2)
10092 delete arg2;
10093 }
10094 return NULL;
10095 }
10096
10097
10098 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10099 PyObject *resultobj;
10100 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10101 wxString *arg2 = 0 ;
10102 bool temp2 = false ;
10103 PyObject * obj0 = 0 ;
10104 PyObject * obj1 = 0 ;
10105 char *kwnames[] = {
10106 (char *) "self",(char *) "extension", NULL
10107 };
10108
10109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10111 if (SWIG_arg_fail(1)) SWIG_fail;
10112 {
10113 arg2 = wxString_in_helper(obj1);
10114 if (arg2 == NULL) SWIG_fail;
10115 temp2 = true;
10116 }
10117 {
10118 PyThreadState* __tstate = wxPyBeginAllowThreads();
10119 (arg1)->SetExtension((wxString const &)*arg2);
10120
10121 wxPyEndAllowThreads(__tstate);
10122 if (PyErr_Occurred()) SWIG_fail;
10123 }
10124 Py_INCREF(Py_None); resultobj = Py_None;
10125 {
10126 if (temp2)
10127 delete arg2;
10128 }
10129 return resultobj;
10130 fail:
10131 {
10132 if (temp2)
10133 delete arg2;
10134 }
10135 return NULL;
10136 }
10137
10138
10139 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10140 PyObject *resultobj;
10141 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10142 long arg2 ;
10143 PyObject * obj0 = 0 ;
10144 PyObject * obj1 = 0 ;
10145 char *kwnames[] = {
10146 (char *) "self",(char *) "type", NULL
10147 };
10148
10149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10151 if (SWIG_arg_fail(1)) SWIG_fail;
10152 {
10153 arg2 = (long)(SWIG_As_long(obj1));
10154 if (SWIG_arg_fail(2)) SWIG_fail;
10155 }
10156 {
10157 PyThreadState* __tstate = wxPyBeginAllowThreads();
10158 (arg1)->SetType(arg2);
10159
10160 wxPyEndAllowThreads(__tstate);
10161 if (PyErr_Occurred()) SWIG_fail;
10162 }
10163 Py_INCREF(Py_None); resultobj = Py_None;
10164 return resultobj;
10165 fail:
10166 return NULL;
10167 }
10168
10169
10170 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10171 PyObject *resultobj;
10172 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10173 wxString *arg2 = 0 ;
10174 bool temp2 = false ;
10175 PyObject * obj0 = 0 ;
10176 PyObject * obj1 = 0 ;
10177 char *kwnames[] = {
10178 (char *) "self",(char *) "mimetype", NULL
10179 };
10180
10181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10183 if (SWIG_arg_fail(1)) SWIG_fail;
10184 {
10185 arg2 = wxString_in_helper(obj1);
10186 if (arg2 == NULL) SWIG_fail;
10187 temp2 = true;
10188 }
10189 {
10190 PyThreadState* __tstate = wxPyBeginAllowThreads();
10191 (arg1)->SetMimeType((wxString const &)*arg2);
10192
10193 wxPyEndAllowThreads(__tstate);
10194 if (PyErr_Occurred()) SWIG_fail;
10195 }
10196 Py_INCREF(Py_None); resultobj = Py_None;
10197 {
10198 if (temp2)
10199 delete arg2;
10200 }
10201 return resultobj;
10202 fail:
10203 {
10204 if (temp2)
10205 delete arg2;
10206 }
10207 return NULL;
10208 }
10209
10210
10211 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10212 PyObject *obj;
10213 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10214 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10215 Py_INCREF(obj);
10216 return Py_BuildValue((char *)"");
10217 }
10218 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10219 PyObject *resultobj;
10220 wxImageHistogram *result;
10221 char *kwnames[] = {
10222 NULL
10223 };
10224
10225 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10226 {
10227 PyThreadState* __tstate = wxPyBeginAllowThreads();
10228 result = (wxImageHistogram *)new wxImageHistogram();
10229
10230 wxPyEndAllowThreads(__tstate);
10231 if (PyErr_Occurred()) SWIG_fail;
10232 }
10233 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10234 return resultobj;
10235 fail:
10236 return NULL;
10237 }
10238
10239
10240 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10241 PyObject *resultobj;
10242 byte arg1 ;
10243 byte arg2 ;
10244 byte arg3 ;
10245 unsigned long result;
10246 PyObject * obj0 = 0 ;
10247 PyObject * obj1 = 0 ;
10248 PyObject * obj2 = 0 ;
10249 char *kwnames[] = {
10250 (char *) "r",(char *) "g",(char *) "b", NULL
10251 };
10252
10253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10254 {
10255 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
10256 if (SWIG_arg_fail(1)) SWIG_fail;
10257 }
10258 {
10259 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10260 if (SWIG_arg_fail(2)) SWIG_fail;
10261 }
10262 {
10263 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10264 if (SWIG_arg_fail(3)) SWIG_fail;
10265 }
10266 {
10267 PyThreadState* __tstate = wxPyBeginAllowThreads();
10268 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10269
10270 wxPyEndAllowThreads(__tstate);
10271 if (PyErr_Occurred()) SWIG_fail;
10272 }
10273 {
10274 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10275 }
10276 return resultobj;
10277 fail:
10278 return NULL;
10279 }
10280
10281
10282 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10283 PyObject *resultobj;
10284 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10285 byte *arg2 = (byte *) 0 ;
10286 byte *arg3 = (byte *) 0 ;
10287 byte *arg4 = (byte *) 0 ;
10288 byte arg5 = (byte) 1 ;
10289 byte arg6 = (byte) 0 ;
10290 byte arg7 = (byte) 0 ;
10291 bool result;
10292 byte temp2 ;
10293 int res2 = 0 ;
10294 byte temp3 ;
10295 int res3 = 0 ;
10296 byte temp4 ;
10297 int res4 = 0 ;
10298 PyObject * obj0 = 0 ;
10299 PyObject * obj1 = 0 ;
10300 PyObject * obj2 = 0 ;
10301 PyObject * obj3 = 0 ;
10302 char *kwnames[] = {
10303 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10304 };
10305
10306 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10307 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10308 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10311 if (SWIG_arg_fail(1)) SWIG_fail;
10312 if (obj1) {
10313 {
10314 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10315 if (SWIG_arg_fail(5)) SWIG_fail;
10316 }
10317 }
10318 if (obj2) {
10319 {
10320 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10321 if (SWIG_arg_fail(6)) SWIG_fail;
10322 }
10323 }
10324 if (obj3) {
10325 {
10326 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10327 if (SWIG_arg_fail(7)) SWIG_fail;
10328 }
10329 }
10330 {
10331 PyThreadState* __tstate = wxPyBeginAllowThreads();
10332 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10333
10334 wxPyEndAllowThreads(__tstate);
10335 if (PyErr_Occurred()) SWIG_fail;
10336 }
10337 {
10338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10339 }
10340 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10341 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10342 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10343 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10344 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10345 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10346 return resultobj;
10347 fail:
10348 return NULL;
10349 }
10350
10351
10352 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10353 PyObject *resultobj;
10354 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10355 unsigned long arg2 ;
10356 unsigned long result;
10357 PyObject * obj0 = 0 ;
10358 PyObject * obj1 = 0 ;
10359 char *kwnames[] = {
10360 (char *) "self",(char *) "key", NULL
10361 };
10362
10363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10365 if (SWIG_arg_fail(1)) SWIG_fail;
10366 {
10367 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10368 if (SWIG_arg_fail(2)) SWIG_fail;
10369 }
10370 {
10371 PyThreadState* __tstate = wxPyBeginAllowThreads();
10372 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10373
10374 wxPyEndAllowThreads(__tstate);
10375 if (PyErr_Occurred()) SWIG_fail;
10376 }
10377 {
10378 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10379 }
10380 return resultobj;
10381 fail:
10382 return NULL;
10383 }
10384
10385
10386 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10387 PyObject *resultobj;
10388 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10389 byte arg2 ;
10390 byte arg3 ;
10391 byte arg4 ;
10392 unsigned long result;
10393 PyObject * obj0 = 0 ;
10394 PyObject * obj1 = 0 ;
10395 PyObject * obj2 = 0 ;
10396 PyObject * obj3 = 0 ;
10397 char *kwnames[] = {
10398 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10399 };
10400
10401 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10402 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10403 if (SWIG_arg_fail(1)) SWIG_fail;
10404 {
10405 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10406 if (SWIG_arg_fail(2)) SWIG_fail;
10407 }
10408 {
10409 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10410 if (SWIG_arg_fail(3)) SWIG_fail;
10411 }
10412 {
10413 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
10414 if (SWIG_arg_fail(4)) SWIG_fail;
10415 }
10416 {
10417 PyThreadState* __tstate = wxPyBeginAllowThreads();
10418 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10419
10420 wxPyEndAllowThreads(__tstate);
10421 if (PyErr_Occurred()) SWIG_fail;
10422 }
10423 {
10424 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10425 }
10426 return resultobj;
10427 fail:
10428 return NULL;
10429 }
10430
10431
10432 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10433 PyObject *resultobj;
10434 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10435 wxColour *arg2 = 0 ;
10436 unsigned long result;
10437 wxColour temp2 ;
10438 PyObject * obj0 = 0 ;
10439 PyObject * obj1 = 0 ;
10440 char *kwnames[] = {
10441 (char *) "self",(char *) "colour", NULL
10442 };
10443
10444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10446 if (SWIG_arg_fail(1)) SWIG_fail;
10447 {
10448 arg2 = &temp2;
10449 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10450 }
10451 {
10452 PyThreadState* __tstate = wxPyBeginAllowThreads();
10453 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10454
10455 wxPyEndAllowThreads(__tstate);
10456 if (PyErr_Occurred()) SWIG_fail;
10457 }
10458 {
10459 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10460 }
10461 return resultobj;
10462 fail:
10463 return NULL;
10464 }
10465
10466
10467 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10468 PyObject *obj;
10469 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10470 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10471 Py_INCREF(obj);
10472 return Py_BuildValue((char *)"");
10473 }
10474 static PyObject *_wrap_new_Image_RGBValue(PyObject *, PyObject *args, PyObject *kwargs) {
10475 PyObject *resultobj;
10476 byte arg1 = (byte) 0 ;
10477 byte arg2 = (byte) 0 ;
10478 byte arg3 = (byte) 0 ;
10479 wxImage_RGBValue *result;
10480 PyObject * obj0 = 0 ;
10481 PyObject * obj1 = 0 ;
10482 PyObject * obj2 = 0 ;
10483 char *kwnames[] = {
10484 (char *) "r",(char *) "g",(char *) "b", NULL
10485 };
10486
10487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10488 if (obj0) {
10489 {
10490 arg1 = (byte)(SWIG_As_unsigned_SS_char(obj0));
10491 if (SWIG_arg_fail(1)) SWIG_fail;
10492 }
10493 }
10494 if (obj1) {
10495 {
10496 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10497 if (SWIG_arg_fail(2)) SWIG_fail;
10498 }
10499 }
10500 if (obj2) {
10501 {
10502 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
10503 if (SWIG_arg_fail(3)) SWIG_fail;
10504 }
10505 }
10506 {
10507 PyThreadState* __tstate = wxPyBeginAllowThreads();
10508 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
10509
10510 wxPyEndAllowThreads(__tstate);
10511 if (PyErr_Occurred()) SWIG_fail;
10512 }
10513 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_RGBValue, 1);
10514 return resultobj;
10515 fail:
10516 return NULL;
10517 }
10518
10519
10520 static PyObject *_wrap_Image_RGBValue_red_set(PyObject *, PyObject *args, PyObject *kwargs) {
10521 PyObject *resultobj;
10522 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10523 byte arg2 ;
10524 PyObject * obj0 = 0 ;
10525 PyObject * obj1 = 0 ;
10526 char *kwnames[] = {
10527 (char *) "self",(char *) "red", NULL
10528 };
10529
10530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_red_set",kwnames,&obj0,&obj1)) goto fail;
10531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10532 if (SWIG_arg_fail(1)) SWIG_fail;
10533 {
10534 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10535 if (SWIG_arg_fail(2)) SWIG_fail;
10536 }
10537 if (arg1) (arg1)->red = arg2;
10538
10539 Py_INCREF(Py_None); resultobj = Py_None;
10540 return resultobj;
10541 fail:
10542 return NULL;
10543 }
10544
10545
10546 static PyObject *_wrap_Image_RGBValue_red_get(PyObject *, PyObject *args, PyObject *kwargs) {
10547 PyObject *resultobj;
10548 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10549 byte result;
10550 PyObject * obj0 = 0 ;
10551 char *kwnames[] = {
10552 (char *) "self", NULL
10553 };
10554
10555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_red_get",kwnames,&obj0)) goto fail;
10556 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10557 if (SWIG_arg_fail(1)) SWIG_fail;
10558 result = (byte) ((arg1)->red);
10559
10560 {
10561 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
10562 }
10563 return resultobj;
10564 fail:
10565 return NULL;
10566 }
10567
10568
10569 static PyObject *_wrap_Image_RGBValue_green_set(PyObject *, PyObject *args, PyObject *kwargs) {
10570 PyObject *resultobj;
10571 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10572 byte arg2 ;
10573 PyObject * obj0 = 0 ;
10574 PyObject * obj1 = 0 ;
10575 char *kwnames[] = {
10576 (char *) "self",(char *) "green", NULL
10577 };
10578
10579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_green_set",kwnames,&obj0,&obj1)) goto fail;
10580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10581 if (SWIG_arg_fail(1)) SWIG_fail;
10582 {
10583 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10584 if (SWIG_arg_fail(2)) SWIG_fail;
10585 }
10586 if (arg1) (arg1)->green = arg2;
10587
10588 Py_INCREF(Py_None); resultobj = Py_None;
10589 return resultobj;
10590 fail:
10591 return NULL;
10592 }
10593
10594
10595 static PyObject *_wrap_Image_RGBValue_green_get(PyObject *, PyObject *args, PyObject *kwargs) {
10596 PyObject *resultobj;
10597 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10598 byte result;
10599 PyObject * obj0 = 0 ;
10600 char *kwnames[] = {
10601 (char *) "self", NULL
10602 };
10603
10604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_green_get",kwnames,&obj0)) goto fail;
10605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10606 if (SWIG_arg_fail(1)) SWIG_fail;
10607 result = (byte) ((arg1)->green);
10608
10609 {
10610 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
10611 }
10612 return resultobj;
10613 fail:
10614 return NULL;
10615 }
10616
10617
10618 static PyObject *_wrap_Image_RGBValue_blue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10619 PyObject *resultobj;
10620 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10621 byte arg2 ;
10622 PyObject * obj0 = 0 ;
10623 PyObject * obj1 = 0 ;
10624 char *kwnames[] = {
10625 (char *) "self",(char *) "blue", NULL
10626 };
10627
10628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RGBValue_blue_set",kwnames,&obj0,&obj1)) goto fail;
10629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10630 if (SWIG_arg_fail(1)) SWIG_fail;
10631 {
10632 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
10633 if (SWIG_arg_fail(2)) SWIG_fail;
10634 }
10635 if (arg1) (arg1)->blue = arg2;
10636
10637 Py_INCREF(Py_None); resultobj = Py_None;
10638 return resultobj;
10639 fail:
10640 return NULL;
10641 }
10642
10643
10644 static PyObject *_wrap_Image_RGBValue_blue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10645 PyObject *resultobj;
10646 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
10647 byte result;
10648 PyObject * obj0 = 0 ;
10649 char *kwnames[] = {
10650 (char *) "self", NULL
10651 };
10652
10653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBValue_blue_get",kwnames,&obj0)) goto fail;
10654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION | 0);
10655 if (SWIG_arg_fail(1)) SWIG_fail;
10656 result = (byte) ((arg1)->blue);
10657
10658 {
10659 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
10660 }
10661 return resultobj;
10662 fail:
10663 return NULL;
10664 }
10665
10666
10667 static PyObject * Image_RGBValue_swigregister(PyObject *, PyObject *args) {
10668 PyObject *obj;
10669 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10670 SWIG_TypeClientData(SWIGTYPE_p_wxImage_RGBValue, obj);
10671 Py_INCREF(obj);
10672 return Py_BuildValue((char *)"");
10673 }
10674 static PyObject *_wrap_new_Image_HSVValue(PyObject *, PyObject *args, PyObject *kwargs) {
10675 PyObject *resultobj;
10676 double arg1 = (double) 0.0 ;
10677 double arg2 = (double) 0.0 ;
10678 double arg3 = (double) 0.0 ;
10679 wxImage_HSVValue *result;
10680 PyObject * obj0 = 0 ;
10681 PyObject * obj1 = 0 ;
10682 PyObject * obj2 = 0 ;
10683 char *kwnames[] = {
10684 (char *) "h",(char *) "s",(char *) "v", NULL
10685 };
10686
10687 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) goto fail;
10688 if (obj0) {
10689 {
10690 arg1 = (double)(SWIG_As_double(obj0));
10691 if (SWIG_arg_fail(1)) SWIG_fail;
10692 }
10693 }
10694 if (obj1) {
10695 {
10696 arg2 = (double)(SWIG_As_double(obj1));
10697 if (SWIG_arg_fail(2)) SWIG_fail;
10698 }
10699 }
10700 if (obj2) {
10701 {
10702 arg3 = (double)(SWIG_As_double(obj2));
10703 if (SWIG_arg_fail(3)) SWIG_fail;
10704 }
10705 }
10706 {
10707 PyThreadState* __tstate = wxPyBeginAllowThreads();
10708 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
10709
10710 wxPyEndAllowThreads(__tstate);
10711 if (PyErr_Occurred()) SWIG_fail;
10712 }
10713 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage_HSVValue, 1);
10714 return resultobj;
10715 fail:
10716 return NULL;
10717 }
10718
10719
10720 static PyObject *_wrap_Image_HSVValue_hue_set(PyObject *, PyObject *args, PyObject *kwargs) {
10721 PyObject *resultobj;
10722 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10723 double arg2 ;
10724 PyObject * obj0 = 0 ;
10725 PyObject * obj1 = 0 ;
10726 char *kwnames[] = {
10727 (char *) "self",(char *) "hue", NULL
10728 };
10729
10730 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_hue_set",kwnames,&obj0,&obj1)) goto fail;
10731 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10732 if (SWIG_arg_fail(1)) SWIG_fail;
10733 {
10734 arg2 = (double)(SWIG_As_double(obj1));
10735 if (SWIG_arg_fail(2)) SWIG_fail;
10736 }
10737 if (arg1) (arg1)->hue = arg2;
10738
10739 Py_INCREF(Py_None); resultobj = Py_None;
10740 return resultobj;
10741 fail:
10742 return NULL;
10743 }
10744
10745
10746 static PyObject *_wrap_Image_HSVValue_hue_get(PyObject *, PyObject *args, PyObject *kwargs) {
10747 PyObject *resultobj;
10748 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10749 double result;
10750 PyObject * obj0 = 0 ;
10751 char *kwnames[] = {
10752 (char *) "self", NULL
10753 };
10754
10755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_hue_get",kwnames,&obj0)) goto fail;
10756 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10757 if (SWIG_arg_fail(1)) SWIG_fail;
10758 result = (double) ((arg1)->hue);
10759
10760 {
10761 resultobj = SWIG_From_double((double)(result));
10762 }
10763 return resultobj;
10764 fail:
10765 return NULL;
10766 }
10767
10768
10769 static PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *, PyObject *args, PyObject *kwargs) {
10770 PyObject *resultobj;
10771 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10772 double arg2 ;
10773 PyObject * obj0 = 0 ;
10774 PyObject * obj1 = 0 ;
10775 char *kwnames[] = {
10776 (char *) "self",(char *) "saturation", NULL
10777 };
10778
10779 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_saturation_set",kwnames,&obj0,&obj1)) goto fail;
10780 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10781 if (SWIG_arg_fail(1)) SWIG_fail;
10782 {
10783 arg2 = (double)(SWIG_As_double(obj1));
10784 if (SWIG_arg_fail(2)) SWIG_fail;
10785 }
10786 if (arg1) (arg1)->saturation = arg2;
10787
10788 Py_INCREF(Py_None); resultobj = Py_None;
10789 return resultobj;
10790 fail:
10791 return NULL;
10792 }
10793
10794
10795 static PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *, PyObject *args, PyObject *kwargs) {
10796 PyObject *resultobj;
10797 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10798 double result;
10799 PyObject * obj0 = 0 ;
10800 char *kwnames[] = {
10801 (char *) "self", NULL
10802 };
10803
10804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_saturation_get",kwnames,&obj0)) goto fail;
10805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10806 if (SWIG_arg_fail(1)) SWIG_fail;
10807 result = (double) ((arg1)->saturation);
10808
10809 {
10810 resultobj = SWIG_From_double((double)(result));
10811 }
10812 return resultobj;
10813 fail:
10814 return NULL;
10815 }
10816
10817
10818 static PyObject *_wrap_Image_HSVValue_value_set(PyObject *, PyObject *args, PyObject *kwargs) {
10819 PyObject *resultobj;
10820 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10821 double arg2 ;
10822 PyObject * obj0 = 0 ;
10823 PyObject * obj1 = 0 ;
10824 char *kwnames[] = {
10825 (char *) "self",(char *) "value", NULL
10826 };
10827
10828 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HSVValue_value_set",kwnames,&obj0,&obj1)) goto fail;
10829 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10830 if (SWIG_arg_fail(1)) SWIG_fail;
10831 {
10832 arg2 = (double)(SWIG_As_double(obj1));
10833 if (SWIG_arg_fail(2)) SWIG_fail;
10834 }
10835 if (arg1) (arg1)->value = arg2;
10836
10837 Py_INCREF(Py_None); resultobj = Py_None;
10838 return resultobj;
10839 fail:
10840 return NULL;
10841 }
10842
10843
10844 static PyObject *_wrap_Image_HSVValue_value_get(PyObject *, PyObject *args, PyObject *kwargs) {
10845 PyObject *resultobj;
10846 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
10847 double result;
10848 PyObject * obj0 = 0 ;
10849 char *kwnames[] = {
10850 (char *) "self", NULL
10851 };
10852
10853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVValue_value_get",kwnames,&obj0)) goto fail;
10854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION | 0);
10855 if (SWIG_arg_fail(1)) SWIG_fail;
10856 result = (double) ((arg1)->value);
10857
10858 {
10859 resultobj = SWIG_From_double((double)(result));
10860 }
10861 return resultobj;
10862 fail:
10863 return NULL;
10864 }
10865
10866
10867 static PyObject * Image_HSVValue_swigregister(PyObject *, PyObject *args) {
10868 PyObject *obj;
10869 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10870 SWIG_TypeClientData(SWIGTYPE_p_wxImage_HSVValue, obj);
10871 Py_INCREF(obj);
10872 return Py_BuildValue((char *)"");
10873 }
10874 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10875 PyObject *resultobj;
10876 wxString *arg1 = 0 ;
10877 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10878 int arg3 = (int) -1 ;
10879 wxImage *result;
10880 bool temp1 = false ;
10881 PyObject * obj0 = 0 ;
10882 PyObject * obj1 = 0 ;
10883 PyObject * obj2 = 0 ;
10884 char *kwnames[] = {
10885 (char *) "name",(char *) "type",(char *) "index", NULL
10886 };
10887
10888 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10889 {
10890 arg1 = wxString_in_helper(obj0);
10891 if (arg1 == NULL) SWIG_fail;
10892 temp1 = true;
10893 }
10894 if (obj1) {
10895 {
10896 arg2 = (long)(SWIG_As_long(obj1));
10897 if (SWIG_arg_fail(2)) SWIG_fail;
10898 }
10899 }
10900 if (obj2) {
10901 {
10902 arg3 = (int)(SWIG_As_int(obj2));
10903 if (SWIG_arg_fail(3)) SWIG_fail;
10904 }
10905 }
10906 {
10907 PyThreadState* __tstate = wxPyBeginAllowThreads();
10908 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10909
10910 wxPyEndAllowThreads(__tstate);
10911 if (PyErr_Occurred()) SWIG_fail;
10912 }
10913 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10914 {
10915 if (temp1)
10916 delete arg1;
10917 }
10918 return resultobj;
10919 fail:
10920 {
10921 if (temp1)
10922 delete arg1;
10923 }
10924 return NULL;
10925 }
10926
10927
10928 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10929 PyObject *resultobj;
10930 wxImage *arg1 = (wxImage *) 0 ;
10931 PyObject * obj0 = 0 ;
10932 char *kwnames[] = {
10933 (char *) "self", NULL
10934 };
10935
10936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10938 if (SWIG_arg_fail(1)) SWIG_fail;
10939 {
10940 PyThreadState* __tstate = wxPyBeginAllowThreads();
10941 delete arg1;
10942
10943 wxPyEndAllowThreads(__tstate);
10944 if (PyErr_Occurred()) SWIG_fail;
10945 }
10946 Py_INCREF(Py_None); resultobj = Py_None;
10947 return resultobj;
10948 fail:
10949 return NULL;
10950 }
10951
10952
10953 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10954 PyObject *resultobj;
10955 wxString *arg1 = 0 ;
10956 wxString *arg2 = 0 ;
10957 int arg3 = (int) -1 ;
10958 wxImage *result;
10959 bool temp1 = false ;
10960 bool temp2 = false ;
10961 PyObject * obj0 = 0 ;
10962 PyObject * obj1 = 0 ;
10963 PyObject * obj2 = 0 ;
10964 char *kwnames[] = {
10965 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10966 };
10967
10968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10969 {
10970 arg1 = wxString_in_helper(obj0);
10971 if (arg1 == NULL) SWIG_fail;
10972 temp1 = true;
10973 }
10974 {
10975 arg2 = wxString_in_helper(obj1);
10976 if (arg2 == NULL) SWIG_fail;
10977 temp2 = true;
10978 }
10979 if (obj2) {
10980 {
10981 arg3 = (int)(SWIG_As_int(obj2));
10982 if (SWIG_arg_fail(3)) SWIG_fail;
10983 }
10984 }
10985 {
10986 PyThreadState* __tstate = wxPyBeginAllowThreads();
10987 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10988
10989 wxPyEndAllowThreads(__tstate);
10990 if (PyErr_Occurred()) SWIG_fail;
10991 }
10992 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10993 {
10994 if (temp1)
10995 delete arg1;
10996 }
10997 {
10998 if (temp2)
10999 delete arg2;
11000 }
11001 return resultobj;
11002 fail:
11003 {
11004 if (temp1)
11005 delete arg1;
11006 }
11007 {
11008 if (temp2)
11009 delete arg2;
11010 }
11011 return NULL;
11012 }
11013
11014
11015 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
11016 PyObject *resultobj;
11017 wxInputStream *arg1 = 0 ;
11018 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11019 int arg3 = (int) -1 ;
11020 wxImage *result;
11021 wxPyInputStream *temp1 ;
11022 bool created1 ;
11023 PyObject * obj0 = 0 ;
11024 PyObject * obj1 = 0 ;
11025 PyObject * obj2 = 0 ;
11026 char *kwnames[] = {
11027 (char *) "stream",(char *) "type",(char *) "index", NULL
11028 };
11029
11030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
11031 {
11032 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11033 arg1 = temp1->m_wxis;
11034 created1 = false;
11035 } else {
11036 PyErr_Clear(); // clear the failure of the wxPyConvert above
11037 arg1 = wxPyCBInputStream_create(obj0, false);
11038 if (arg1 == NULL) {
11039 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11040 SWIG_fail;
11041 }
11042 created1 = true;
11043 }
11044 }
11045 if (obj1) {
11046 {
11047 arg2 = (long)(SWIG_As_long(obj1));
11048 if (SWIG_arg_fail(2)) SWIG_fail;
11049 }
11050 }
11051 if (obj2) {
11052 {
11053 arg3 = (int)(SWIG_As_int(obj2));
11054 if (SWIG_arg_fail(3)) SWIG_fail;
11055 }
11056 }
11057 {
11058 PyThreadState* __tstate = wxPyBeginAllowThreads();
11059 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
11060
11061 wxPyEndAllowThreads(__tstate);
11062 if (PyErr_Occurred()) SWIG_fail;
11063 }
11064 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11065 {
11066 if (created1) delete arg1;
11067 }
11068 return resultobj;
11069 fail:
11070 {
11071 if (created1) delete arg1;
11072 }
11073 return NULL;
11074 }
11075
11076
11077 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
11078 PyObject *resultobj;
11079 wxInputStream *arg1 = 0 ;
11080 wxString *arg2 = 0 ;
11081 int arg3 = (int) -1 ;
11082 wxImage *result;
11083 wxPyInputStream *temp1 ;
11084 bool created1 ;
11085 bool temp2 = false ;
11086 PyObject * obj0 = 0 ;
11087 PyObject * obj1 = 0 ;
11088 PyObject * obj2 = 0 ;
11089 char *kwnames[] = {
11090 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
11091 };
11092
11093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
11094 {
11095 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
11096 arg1 = temp1->m_wxis;
11097 created1 = false;
11098 } else {
11099 PyErr_Clear(); // clear the failure of the wxPyConvert above
11100 arg1 = wxPyCBInputStream_create(obj0, false);
11101 if (arg1 == NULL) {
11102 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11103 SWIG_fail;
11104 }
11105 created1 = true;
11106 }
11107 }
11108 {
11109 arg2 = wxString_in_helper(obj1);
11110 if (arg2 == NULL) SWIG_fail;
11111 temp2 = true;
11112 }
11113 if (obj2) {
11114 {
11115 arg3 = (int)(SWIG_As_int(obj2));
11116 if (SWIG_arg_fail(3)) SWIG_fail;
11117 }
11118 }
11119 {
11120 PyThreadState* __tstate = wxPyBeginAllowThreads();
11121 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
11122
11123 wxPyEndAllowThreads(__tstate);
11124 if (PyErr_Occurred()) SWIG_fail;
11125 }
11126 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11127 {
11128 if (created1) delete arg1;
11129 }
11130 {
11131 if (temp2)
11132 delete arg2;
11133 }
11134 return resultobj;
11135 fail:
11136 {
11137 if (created1) delete arg1;
11138 }
11139 {
11140 if (temp2)
11141 delete arg2;
11142 }
11143 return NULL;
11144 }
11145
11146
11147 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
11148 PyObject *resultobj;
11149 int arg1 = (int) 0 ;
11150 int arg2 = (int) 0 ;
11151 bool arg3 = (bool) true ;
11152 wxImage *result;
11153 PyObject * obj0 = 0 ;
11154 PyObject * obj1 = 0 ;
11155 PyObject * obj2 = 0 ;
11156 char *kwnames[] = {
11157 (char *) "width",(char *) "height",(char *) "clear", NULL
11158 };
11159
11160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
11161 if (obj0) {
11162 {
11163 arg1 = (int)(SWIG_As_int(obj0));
11164 if (SWIG_arg_fail(1)) SWIG_fail;
11165 }
11166 }
11167 if (obj1) {
11168 {
11169 arg2 = (int)(SWIG_As_int(obj1));
11170 if (SWIG_arg_fail(2)) SWIG_fail;
11171 }
11172 }
11173 if (obj2) {
11174 {
11175 arg3 = (bool)(SWIG_As_bool(obj2));
11176 if (SWIG_arg_fail(3)) SWIG_fail;
11177 }
11178 }
11179 {
11180 PyThreadState* __tstate = wxPyBeginAllowThreads();
11181 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
11182
11183 wxPyEndAllowThreads(__tstate);
11184 if (PyErr_Occurred()) SWIG_fail;
11185 }
11186 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11187 return resultobj;
11188 fail:
11189 return NULL;
11190 }
11191
11192
11193 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
11194 PyObject *resultobj;
11195 wxBitmap *arg1 = 0 ;
11196 wxImage *result;
11197 PyObject * obj0 = 0 ;
11198 char *kwnames[] = {
11199 (char *) "bitmap", NULL
11200 };
11201
11202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
11203 {
11204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
11205 if (SWIG_arg_fail(1)) SWIG_fail;
11206 if (arg1 == NULL) {
11207 SWIG_null_ref("wxBitmap");
11208 }
11209 if (SWIG_arg_fail(1)) SWIG_fail;
11210 }
11211 {
11212 if (!wxPyCheckForApp()) SWIG_fail;
11213 PyThreadState* __tstate = wxPyBeginAllowThreads();
11214 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
11215
11216 wxPyEndAllowThreads(__tstate);
11217 if (PyErr_Occurred()) SWIG_fail;
11218 }
11219 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11220 return resultobj;
11221 fail:
11222 return NULL;
11223 }
11224
11225
11226 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
11227 PyObject *resultobj;
11228 int arg1 ;
11229 int arg2 ;
11230 buffer arg3 ;
11231 int arg4 ;
11232 wxImage *result;
11233 PyObject * obj0 = 0 ;
11234 PyObject * obj1 = 0 ;
11235 PyObject * obj2 = 0 ;
11236 char *kwnames[] = {
11237 (char *) "width",(char *) "height",(char *) "data", NULL
11238 };
11239
11240 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
11241 {
11242 arg1 = (int)(SWIG_As_int(obj0));
11243 if (SWIG_arg_fail(1)) SWIG_fail;
11244 }
11245 {
11246 arg2 = (int)(SWIG_As_int(obj1));
11247 if (SWIG_arg_fail(2)) SWIG_fail;
11248 }
11249 {
11250 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11251 }
11252 {
11253 PyThreadState* __tstate = wxPyBeginAllowThreads();
11254 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
11255
11256 wxPyEndAllowThreads(__tstate);
11257 if (PyErr_Occurred()) SWIG_fail;
11258 }
11259 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11260 return resultobj;
11261 fail:
11262 return NULL;
11263 }
11264
11265
11266 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11267 PyObject *resultobj;
11268 int arg1 ;
11269 int arg2 ;
11270 buffer arg3 ;
11271 int arg4 ;
11272 buffer arg5 ;
11273 int arg6 ;
11274 wxImage *result;
11275 PyObject * obj0 = 0 ;
11276 PyObject * obj1 = 0 ;
11277 PyObject * obj2 = 0 ;
11278 PyObject * obj3 = 0 ;
11279 char *kwnames[] = {
11280 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
11281 };
11282
11283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11284 {
11285 arg1 = (int)(SWIG_As_int(obj0));
11286 if (SWIG_arg_fail(1)) SWIG_fail;
11287 }
11288 {
11289 arg2 = (int)(SWIG_As_int(obj1));
11290 if (SWIG_arg_fail(2)) SWIG_fail;
11291 }
11292 {
11293 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
11294 }
11295 {
11296 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
11297 }
11298 {
11299 PyThreadState* __tstate = wxPyBeginAllowThreads();
11300 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
11301
11302 wxPyEndAllowThreads(__tstate);
11303 if (PyErr_Occurred()) SWIG_fail;
11304 }
11305 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
11306 return resultobj;
11307 fail:
11308 return NULL;
11309 }
11310
11311
11312 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
11313 PyObject *resultobj;
11314 wxImage *arg1 = (wxImage *) 0 ;
11315 int arg2 ;
11316 int arg3 ;
11317 bool arg4 = (bool) true ;
11318 PyObject * obj0 = 0 ;
11319 PyObject * obj1 = 0 ;
11320 PyObject * obj2 = 0 ;
11321 PyObject * obj3 = 0 ;
11322 char *kwnames[] = {
11323 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
11324 };
11325
11326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11328 if (SWIG_arg_fail(1)) SWIG_fail;
11329 {
11330 arg2 = (int)(SWIG_As_int(obj1));
11331 if (SWIG_arg_fail(2)) SWIG_fail;
11332 }
11333 {
11334 arg3 = (int)(SWIG_As_int(obj2));
11335 if (SWIG_arg_fail(3)) SWIG_fail;
11336 }
11337 if (obj3) {
11338 {
11339 arg4 = (bool)(SWIG_As_bool(obj3));
11340 if (SWIG_arg_fail(4)) SWIG_fail;
11341 }
11342 }
11343 {
11344 PyThreadState* __tstate = wxPyBeginAllowThreads();
11345 (arg1)->Create(arg2,arg3,arg4);
11346
11347 wxPyEndAllowThreads(__tstate);
11348 if (PyErr_Occurred()) SWIG_fail;
11349 }
11350 Py_INCREF(Py_None); resultobj = Py_None;
11351 return resultobj;
11352 fail:
11353 return NULL;
11354 }
11355
11356
11357 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
11358 PyObject *resultobj;
11359 wxImage *arg1 = (wxImage *) 0 ;
11360 PyObject * obj0 = 0 ;
11361 char *kwnames[] = {
11362 (char *) "self", NULL
11363 };
11364
11365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
11366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11367 if (SWIG_arg_fail(1)) SWIG_fail;
11368 {
11369 PyThreadState* __tstate = wxPyBeginAllowThreads();
11370 (arg1)->Destroy();
11371
11372 wxPyEndAllowThreads(__tstate);
11373 if (PyErr_Occurred()) SWIG_fail;
11374 }
11375 Py_INCREF(Py_None); resultobj = Py_None;
11376 return resultobj;
11377 fail:
11378 return NULL;
11379 }
11380
11381
11382 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
11383 PyObject *resultobj;
11384 wxImage *arg1 = (wxImage *) 0 ;
11385 int arg2 ;
11386 int arg3 ;
11387 SwigValueWrapper<wxImage > result;
11388 PyObject * obj0 = 0 ;
11389 PyObject * obj1 = 0 ;
11390 PyObject * obj2 = 0 ;
11391 char *kwnames[] = {
11392 (char *) "self",(char *) "width",(char *) "height", NULL
11393 };
11394
11395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11397 if (SWIG_arg_fail(1)) SWIG_fail;
11398 {
11399 arg2 = (int)(SWIG_As_int(obj1));
11400 if (SWIG_arg_fail(2)) SWIG_fail;
11401 }
11402 {
11403 arg3 = (int)(SWIG_As_int(obj2));
11404 if (SWIG_arg_fail(3)) SWIG_fail;
11405 }
11406 {
11407 PyThreadState* __tstate = wxPyBeginAllowThreads();
11408 result = (arg1)->Scale(arg2,arg3);
11409
11410 wxPyEndAllowThreads(__tstate);
11411 if (PyErr_Occurred()) SWIG_fail;
11412 }
11413 {
11414 wxImage * resultptr;
11415 resultptr = new wxImage((wxImage &)(result));
11416 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11417 }
11418 return resultobj;
11419 fail:
11420 return NULL;
11421 }
11422
11423
11424 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11425 PyObject *resultobj;
11426 wxImage *arg1 = (wxImage *) 0 ;
11427 int arg2 ;
11428 int arg3 ;
11429 SwigValueWrapper<wxImage > result;
11430 PyObject * obj0 = 0 ;
11431 PyObject * obj1 = 0 ;
11432 PyObject * obj2 = 0 ;
11433 char *kwnames[] = {
11434 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11435 };
11436
11437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11439 if (SWIG_arg_fail(1)) SWIG_fail;
11440 {
11441 arg2 = (int)(SWIG_As_int(obj1));
11442 if (SWIG_arg_fail(2)) SWIG_fail;
11443 }
11444 {
11445 arg3 = (int)(SWIG_As_int(obj2));
11446 if (SWIG_arg_fail(3)) SWIG_fail;
11447 }
11448 {
11449 PyThreadState* __tstate = wxPyBeginAllowThreads();
11450 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11451
11452 wxPyEndAllowThreads(__tstate);
11453 if (PyErr_Occurred()) SWIG_fail;
11454 }
11455 {
11456 wxImage * resultptr;
11457 resultptr = new wxImage((wxImage &)(result));
11458 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11459 }
11460 return resultobj;
11461 fail:
11462 return NULL;
11463 }
11464
11465
11466 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11467 PyObject *resultobj;
11468 wxImage *arg1 = (wxImage *) 0 ;
11469 int arg2 ;
11470 int arg3 ;
11471 wxImage *result;
11472 PyObject * obj0 = 0 ;
11473 PyObject * obj1 = 0 ;
11474 PyObject * obj2 = 0 ;
11475 char *kwnames[] = {
11476 (char *) "self",(char *) "width",(char *) "height", NULL
11477 };
11478
11479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11481 if (SWIG_arg_fail(1)) SWIG_fail;
11482 {
11483 arg2 = (int)(SWIG_As_int(obj1));
11484 if (SWIG_arg_fail(2)) SWIG_fail;
11485 }
11486 {
11487 arg3 = (int)(SWIG_As_int(obj2));
11488 if (SWIG_arg_fail(3)) SWIG_fail;
11489 }
11490 {
11491 PyThreadState* __tstate = wxPyBeginAllowThreads();
11492 {
11493 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11494 result = (wxImage *) &_result_ref;
11495 }
11496
11497 wxPyEndAllowThreads(__tstate);
11498 if (PyErr_Occurred()) SWIG_fail;
11499 }
11500 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11501 return resultobj;
11502 fail:
11503 return NULL;
11504 }
11505
11506
11507 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11508 PyObject *resultobj;
11509 wxImage *arg1 = (wxImage *) 0 ;
11510 wxSize *arg2 = 0 ;
11511 wxPoint *arg3 = 0 ;
11512 int arg4 = (int) -1 ;
11513 int arg5 = (int) -1 ;
11514 int arg6 = (int) -1 ;
11515 wxImage *result;
11516 wxSize temp2 ;
11517 wxPoint temp3 ;
11518 PyObject * obj0 = 0 ;
11519 PyObject * obj1 = 0 ;
11520 PyObject * obj2 = 0 ;
11521 PyObject * obj3 = 0 ;
11522 PyObject * obj4 = 0 ;
11523 PyObject * obj5 = 0 ;
11524 char *kwnames[] = {
11525 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11526 };
11527
11528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11529 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11530 if (SWIG_arg_fail(1)) SWIG_fail;
11531 {
11532 arg2 = &temp2;
11533 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11534 }
11535 {
11536 arg3 = &temp3;
11537 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11538 }
11539 if (obj3) {
11540 {
11541 arg4 = (int)(SWIG_As_int(obj3));
11542 if (SWIG_arg_fail(4)) SWIG_fail;
11543 }
11544 }
11545 if (obj4) {
11546 {
11547 arg5 = (int)(SWIG_As_int(obj4));
11548 if (SWIG_arg_fail(5)) SWIG_fail;
11549 }
11550 }
11551 if (obj5) {
11552 {
11553 arg6 = (int)(SWIG_As_int(obj5));
11554 if (SWIG_arg_fail(6)) SWIG_fail;
11555 }
11556 }
11557 {
11558 PyThreadState* __tstate = wxPyBeginAllowThreads();
11559 {
11560 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11561 result = (wxImage *) &_result_ref;
11562 }
11563
11564 wxPyEndAllowThreads(__tstate);
11565 if (PyErr_Occurred()) SWIG_fail;
11566 }
11567 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11568 return resultobj;
11569 fail:
11570 return NULL;
11571 }
11572
11573
11574 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11575 PyObject *resultobj;
11576 wxImage *arg1 = (wxImage *) 0 ;
11577 int arg2 ;
11578 int arg3 ;
11579 byte arg4 ;
11580 byte arg5 ;
11581 byte arg6 ;
11582 PyObject * obj0 = 0 ;
11583 PyObject * obj1 = 0 ;
11584 PyObject * obj2 = 0 ;
11585 PyObject * obj3 = 0 ;
11586 PyObject * obj4 = 0 ;
11587 PyObject * obj5 = 0 ;
11588 char *kwnames[] = {
11589 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11590 };
11591
11592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11594 if (SWIG_arg_fail(1)) SWIG_fail;
11595 {
11596 arg2 = (int)(SWIG_As_int(obj1));
11597 if (SWIG_arg_fail(2)) SWIG_fail;
11598 }
11599 {
11600 arg3 = (int)(SWIG_As_int(obj2));
11601 if (SWIG_arg_fail(3)) SWIG_fail;
11602 }
11603 {
11604 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11605 if (SWIG_arg_fail(4)) SWIG_fail;
11606 }
11607 {
11608 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11609 if (SWIG_arg_fail(5)) SWIG_fail;
11610 }
11611 {
11612 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
11613 if (SWIG_arg_fail(6)) SWIG_fail;
11614 }
11615 {
11616 PyThreadState* __tstate = wxPyBeginAllowThreads();
11617 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11618
11619 wxPyEndAllowThreads(__tstate);
11620 if (PyErr_Occurred()) SWIG_fail;
11621 }
11622 Py_INCREF(Py_None); resultobj = Py_None;
11623 return resultobj;
11624 fail:
11625 return NULL;
11626 }
11627
11628
11629 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11630 PyObject *resultobj;
11631 wxImage *arg1 = (wxImage *) 0 ;
11632 wxRect *arg2 = 0 ;
11633 byte arg3 ;
11634 byte arg4 ;
11635 byte arg5 ;
11636 wxRect temp2 ;
11637 PyObject * obj0 = 0 ;
11638 PyObject * obj1 = 0 ;
11639 PyObject * obj2 = 0 ;
11640 PyObject * obj3 = 0 ;
11641 PyObject * obj4 = 0 ;
11642 char *kwnames[] = {
11643 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11644 };
11645
11646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11648 if (SWIG_arg_fail(1)) SWIG_fail;
11649 {
11650 arg2 = &temp2;
11651 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11652 }
11653 {
11654 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11655 if (SWIG_arg_fail(3)) SWIG_fail;
11656 }
11657 {
11658 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11659 if (SWIG_arg_fail(4)) SWIG_fail;
11660 }
11661 {
11662 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11663 if (SWIG_arg_fail(5)) SWIG_fail;
11664 }
11665 {
11666 PyThreadState* __tstate = wxPyBeginAllowThreads();
11667 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11668
11669 wxPyEndAllowThreads(__tstate);
11670 if (PyErr_Occurred()) SWIG_fail;
11671 }
11672 Py_INCREF(Py_None); resultobj = Py_None;
11673 return resultobj;
11674 fail:
11675 return NULL;
11676 }
11677
11678
11679 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11680 PyObject *resultobj;
11681 wxImage *arg1 = (wxImage *) 0 ;
11682 int arg2 ;
11683 int arg3 ;
11684 byte result;
11685 PyObject * obj0 = 0 ;
11686 PyObject * obj1 = 0 ;
11687 PyObject * obj2 = 0 ;
11688 char *kwnames[] = {
11689 (char *) "self",(char *) "x",(char *) "y", NULL
11690 };
11691
11692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11694 if (SWIG_arg_fail(1)) SWIG_fail;
11695 {
11696 arg2 = (int)(SWIG_As_int(obj1));
11697 if (SWIG_arg_fail(2)) SWIG_fail;
11698 }
11699 {
11700 arg3 = (int)(SWIG_As_int(obj2));
11701 if (SWIG_arg_fail(3)) SWIG_fail;
11702 }
11703 {
11704 PyThreadState* __tstate = wxPyBeginAllowThreads();
11705 result = (byte)(arg1)->GetRed(arg2,arg3);
11706
11707 wxPyEndAllowThreads(__tstate);
11708 if (PyErr_Occurred()) SWIG_fail;
11709 }
11710 {
11711 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11712 }
11713 return resultobj;
11714 fail:
11715 return NULL;
11716 }
11717
11718
11719 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11720 PyObject *resultobj;
11721 wxImage *arg1 = (wxImage *) 0 ;
11722 int arg2 ;
11723 int arg3 ;
11724 byte result;
11725 PyObject * obj0 = 0 ;
11726 PyObject * obj1 = 0 ;
11727 PyObject * obj2 = 0 ;
11728 char *kwnames[] = {
11729 (char *) "self",(char *) "x",(char *) "y", NULL
11730 };
11731
11732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11734 if (SWIG_arg_fail(1)) SWIG_fail;
11735 {
11736 arg2 = (int)(SWIG_As_int(obj1));
11737 if (SWIG_arg_fail(2)) SWIG_fail;
11738 }
11739 {
11740 arg3 = (int)(SWIG_As_int(obj2));
11741 if (SWIG_arg_fail(3)) SWIG_fail;
11742 }
11743 {
11744 PyThreadState* __tstate = wxPyBeginAllowThreads();
11745 result = (byte)(arg1)->GetGreen(arg2,arg3);
11746
11747 wxPyEndAllowThreads(__tstate);
11748 if (PyErr_Occurred()) SWIG_fail;
11749 }
11750 {
11751 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11752 }
11753 return resultobj;
11754 fail:
11755 return NULL;
11756 }
11757
11758
11759 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11760 PyObject *resultobj;
11761 wxImage *arg1 = (wxImage *) 0 ;
11762 int arg2 ;
11763 int arg3 ;
11764 byte result;
11765 PyObject * obj0 = 0 ;
11766 PyObject * obj1 = 0 ;
11767 PyObject * obj2 = 0 ;
11768 char *kwnames[] = {
11769 (char *) "self",(char *) "x",(char *) "y", NULL
11770 };
11771
11772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11774 if (SWIG_arg_fail(1)) SWIG_fail;
11775 {
11776 arg2 = (int)(SWIG_As_int(obj1));
11777 if (SWIG_arg_fail(2)) SWIG_fail;
11778 }
11779 {
11780 arg3 = (int)(SWIG_As_int(obj2));
11781 if (SWIG_arg_fail(3)) SWIG_fail;
11782 }
11783 {
11784 PyThreadState* __tstate = wxPyBeginAllowThreads();
11785 result = (byte)(arg1)->GetBlue(arg2,arg3);
11786
11787 wxPyEndAllowThreads(__tstate);
11788 if (PyErr_Occurred()) SWIG_fail;
11789 }
11790 {
11791 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11792 }
11793 return resultobj;
11794 fail:
11795 return NULL;
11796 }
11797
11798
11799 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11800 PyObject *resultobj;
11801 wxImage *arg1 = (wxImage *) 0 ;
11802 int arg2 ;
11803 int arg3 ;
11804 byte arg4 ;
11805 PyObject * obj0 = 0 ;
11806 PyObject * obj1 = 0 ;
11807 PyObject * obj2 = 0 ;
11808 PyObject * obj3 = 0 ;
11809 char *kwnames[] = {
11810 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11811 };
11812
11813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11815 if (SWIG_arg_fail(1)) SWIG_fail;
11816 {
11817 arg2 = (int)(SWIG_As_int(obj1));
11818 if (SWIG_arg_fail(2)) SWIG_fail;
11819 }
11820 {
11821 arg3 = (int)(SWIG_As_int(obj2));
11822 if (SWIG_arg_fail(3)) SWIG_fail;
11823 }
11824 {
11825 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11826 if (SWIG_arg_fail(4)) SWIG_fail;
11827 }
11828 {
11829 PyThreadState* __tstate = wxPyBeginAllowThreads();
11830 (arg1)->SetAlpha(arg2,arg3,arg4);
11831
11832 wxPyEndAllowThreads(__tstate);
11833 if (PyErr_Occurred()) SWIG_fail;
11834 }
11835 Py_INCREF(Py_None); resultobj = Py_None;
11836 return resultobj;
11837 fail:
11838 return NULL;
11839 }
11840
11841
11842 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11843 PyObject *resultobj;
11844 wxImage *arg1 = (wxImage *) 0 ;
11845 int arg2 ;
11846 int arg3 ;
11847 byte result;
11848 PyObject * obj0 = 0 ;
11849 PyObject * obj1 = 0 ;
11850 PyObject * obj2 = 0 ;
11851 char *kwnames[] = {
11852 (char *) "self",(char *) "x",(char *) "y", NULL
11853 };
11854
11855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11857 if (SWIG_arg_fail(1)) SWIG_fail;
11858 {
11859 arg2 = (int)(SWIG_As_int(obj1));
11860 if (SWIG_arg_fail(2)) SWIG_fail;
11861 }
11862 {
11863 arg3 = (int)(SWIG_As_int(obj2));
11864 if (SWIG_arg_fail(3)) SWIG_fail;
11865 }
11866 {
11867 PyThreadState* __tstate = wxPyBeginAllowThreads();
11868 result = (byte)(arg1)->GetAlpha(arg2,arg3);
11869
11870 wxPyEndAllowThreads(__tstate);
11871 if (PyErr_Occurred()) SWIG_fail;
11872 }
11873 {
11874 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11875 }
11876 return resultobj;
11877 fail:
11878 return NULL;
11879 }
11880
11881
11882 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11883 PyObject *resultobj;
11884 wxImage *arg1 = (wxImage *) 0 ;
11885 bool result;
11886 PyObject * obj0 = 0 ;
11887 char *kwnames[] = {
11888 (char *) "self", NULL
11889 };
11890
11891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11893 if (SWIG_arg_fail(1)) SWIG_fail;
11894 {
11895 PyThreadState* __tstate = wxPyBeginAllowThreads();
11896 result = (bool)(arg1)->HasAlpha();
11897
11898 wxPyEndAllowThreads(__tstate);
11899 if (PyErr_Occurred()) SWIG_fail;
11900 }
11901 {
11902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11903 }
11904 return resultobj;
11905 fail:
11906 return NULL;
11907 }
11908
11909
11910 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11911 PyObject *resultobj;
11912 wxImage *arg1 = (wxImage *) 0 ;
11913 PyObject * obj0 = 0 ;
11914 char *kwnames[] = {
11915 (char *) "self", NULL
11916 };
11917
11918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11920 if (SWIG_arg_fail(1)) SWIG_fail;
11921 {
11922 PyThreadState* __tstate = wxPyBeginAllowThreads();
11923 (arg1)->InitAlpha();
11924
11925 wxPyEndAllowThreads(__tstate);
11926 if (PyErr_Occurred()) SWIG_fail;
11927 }
11928 Py_INCREF(Py_None); resultobj = Py_None;
11929 return resultobj;
11930 fail:
11931 return NULL;
11932 }
11933
11934
11935 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
11936 PyObject *resultobj;
11937 wxImage *arg1 = (wxImage *) 0 ;
11938 int arg2 ;
11939 int arg3 ;
11940 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
11941 bool result;
11942 PyObject * obj0 = 0 ;
11943 PyObject * obj1 = 0 ;
11944 PyObject * obj2 = 0 ;
11945 PyObject * obj3 = 0 ;
11946 char *kwnames[] = {
11947 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
11948 };
11949
11950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11952 if (SWIG_arg_fail(1)) SWIG_fail;
11953 {
11954 arg2 = (int)(SWIG_As_int(obj1));
11955 if (SWIG_arg_fail(2)) SWIG_fail;
11956 }
11957 {
11958 arg3 = (int)(SWIG_As_int(obj2));
11959 if (SWIG_arg_fail(3)) SWIG_fail;
11960 }
11961 if (obj3) {
11962 {
11963 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11964 if (SWIG_arg_fail(4)) SWIG_fail;
11965 }
11966 }
11967 {
11968 PyThreadState* __tstate = wxPyBeginAllowThreads();
11969 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
11970
11971 wxPyEndAllowThreads(__tstate);
11972 if (PyErr_Occurred()) SWIG_fail;
11973 }
11974 {
11975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11976 }
11977 return resultobj;
11978 fail:
11979 return NULL;
11980 }
11981
11982
11983 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11984 PyObject *resultobj;
11985 wxImage *arg1 = (wxImage *) 0 ;
11986 byte *arg2 = (byte *) 0 ;
11987 byte *arg3 = (byte *) 0 ;
11988 byte *arg4 = (byte *) 0 ;
11989 byte arg5 = (byte) 0 ;
11990 byte arg6 = (byte) 0 ;
11991 byte arg7 = (byte) 0 ;
11992 bool result;
11993 byte temp2 ;
11994 int res2 = 0 ;
11995 byte temp3 ;
11996 int res3 = 0 ;
11997 byte temp4 ;
11998 int res4 = 0 ;
11999 PyObject * obj0 = 0 ;
12000 PyObject * obj1 = 0 ;
12001 PyObject * obj2 = 0 ;
12002 PyObject * obj3 = 0 ;
12003 char *kwnames[] = {
12004 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12005 };
12006
12007 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12008 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12009 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12012 if (SWIG_arg_fail(1)) SWIG_fail;
12013 if (obj1) {
12014 {
12015 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
12016 if (SWIG_arg_fail(5)) SWIG_fail;
12017 }
12018 }
12019 if (obj2) {
12020 {
12021 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
12022 if (SWIG_arg_fail(6)) SWIG_fail;
12023 }
12024 }
12025 if (obj3) {
12026 {
12027 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12028 if (SWIG_arg_fail(7)) SWIG_fail;
12029 }
12030 }
12031 {
12032 PyThreadState* __tstate = wxPyBeginAllowThreads();
12033 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12034
12035 wxPyEndAllowThreads(__tstate);
12036 if (PyErr_Occurred()) SWIG_fail;
12037 }
12038 {
12039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12040 }
12041 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12042 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12043 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12044 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12045 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12046 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12047 return resultobj;
12048 fail:
12049 return NULL;
12050 }
12051
12052
12053 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
12054 PyObject *resultobj;
12055 wxImage *arg1 = (wxImage *) 0 ;
12056 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
12057 bool result;
12058 PyObject * obj0 = 0 ;
12059 PyObject * obj1 = 0 ;
12060 char *kwnames[] = {
12061 (char *) "self",(char *) "threshold", NULL
12062 };
12063
12064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
12065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12066 if (SWIG_arg_fail(1)) SWIG_fail;
12067 if (obj1) {
12068 {
12069 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
12070 if (SWIG_arg_fail(2)) SWIG_fail;
12071 }
12072 }
12073 {
12074 PyThreadState* __tstate = wxPyBeginAllowThreads();
12075 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
12076
12077 wxPyEndAllowThreads(__tstate);
12078 if (PyErr_Occurred()) SWIG_fail;
12079 }
12080 {
12081 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12082 }
12083 return resultobj;
12084 fail:
12085 return NULL;
12086 }
12087
12088
12089 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
12090 PyObject *resultobj;
12091 wxImage *arg1 = (wxImage *) 0 ;
12092 byte arg2 ;
12093 byte arg3 ;
12094 byte arg4 ;
12095 bool result;
12096 PyObject * obj0 = 0 ;
12097 PyObject * obj1 = 0 ;
12098 PyObject * obj2 = 0 ;
12099 PyObject * obj3 = 0 ;
12100 char *kwnames[] = {
12101 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12102 };
12103
12104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12106 if (SWIG_arg_fail(1)) SWIG_fail;
12107 {
12108 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
12109 if (SWIG_arg_fail(2)) SWIG_fail;
12110 }
12111 {
12112 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
12113 if (SWIG_arg_fail(3)) SWIG_fail;
12114 }
12115 {
12116 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12117 if (SWIG_arg_fail(4)) SWIG_fail;
12118 }
12119 {
12120 PyThreadState* __tstate = wxPyBeginAllowThreads();
12121 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
12122
12123 wxPyEndAllowThreads(__tstate);
12124 if (PyErr_Occurred()) SWIG_fail;
12125 }
12126 {
12127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12128 }
12129 return resultobj;
12130 fail:
12131 return NULL;
12132 }
12133
12134
12135 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
12136 PyObject *resultobj;
12137 wxImage *arg1 = (wxImage *) 0 ;
12138 wxImage *arg2 = 0 ;
12139 byte arg3 ;
12140 byte arg4 ;
12141 byte arg5 ;
12142 bool result;
12143 PyObject * obj0 = 0 ;
12144 PyObject * obj1 = 0 ;
12145 PyObject * obj2 = 0 ;
12146 PyObject * obj3 = 0 ;
12147 PyObject * obj4 = 0 ;
12148 char *kwnames[] = {
12149 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
12150 };
12151
12152 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
12153 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12154 if (SWIG_arg_fail(1)) SWIG_fail;
12155 {
12156 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12157 if (SWIG_arg_fail(2)) SWIG_fail;
12158 if (arg2 == NULL) {
12159 SWIG_null_ref("wxImage");
12160 }
12161 if (SWIG_arg_fail(2)) SWIG_fail;
12162 }
12163 {
12164 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
12165 if (SWIG_arg_fail(3)) SWIG_fail;
12166 }
12167 {
12168 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
12169 if (SWIG_arg_fail(4)) SWIG_fail;
12170 }
12171 {
12172 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
12173 if (SWIG_arg_fail(5)) SWIG_fail;
12174 }
12175 {
12176 PyThreadState* __tstate = wxPyBeginAllowThreads();
12177 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
12178
12179 wxPyEndAllowThreads(__tstate);
12180 if (PyErr_Occurred()) SWIG_fail;
12181 }
12182 {
12183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12184 }
12185 return resultobj;
12186 fail:
12187 return NULL;
12188 }
12189
12190
12191 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
12192 PyObject *resultobj;
12193 wxString *arg1 = 0 ;
12194 bool result;
12195 bool temp1 = false ;
12196 PyObject * obj0 = 0 ;
12197 char *kwnames[] = {
12198 (char *) "filename", NULL
12199 };
12200
12201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
12202 {
12203 arg1 = wxString_in_helper(obj0);
12204 if (arg1 == NULL) SWIG_fail;
12205 temp1 = true;
12206 }
12207 {
12208 PyThreadState* __tstate = wxPyBeginAllowThreads();
12209 result = (bool)wxImage::CanRead((wxString const &)*arg1);
12210
12211 wxPyEndAllowThreads(__tstate);
12212 if (PyErr_Occurred()) SWIG_fail;
12213 }
12214 {
12215 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12216 }
12217 {
12218 if (temp1)
12219 delete arg1;
12220 }
12221 return resultobj;
12222 fail:
12223 {
12224 if (temp1)
12225 delete arg1;
12226 }
12227 return NULL;
12228 }
12229
12230
12231 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
12232 PyObject *resultobj;
12233 wxString *arg1 = 0 ;
12234 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12235 int result;
12236 bool temp1 = false ;
12237 PyObject * obj0 = 0 ;
12238 PyObject * obj1 = 0 ;
12239 char *kwnames[] = {
12240 (char *) "filename",(char *) "type", NULL
12241 };
12242
12243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
12244 {
12245 arg1 = wxString_in_helper(obj0);
12246 if (arg1 == NULL) SWIG_fail;
12247 temp1 = true;
12248 }
12249 if (obj1) {
12250 {
12251 arg2 = (long)(SWIG_As_long(obj1));
12252 if (SWIG_arg_fail(2)) SWIG_fail;
12253 }
12254 }
12255 {
12256 PyThreadState* __tstate = wxPyBeginAllowThreads();
12257 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
12258
12259 wxPyEndAllowThreads(__tstate);
12260 if (PyErr_Occurred()) SWIG_fail;
12261 }
12262 {
12263 resultobj = SWIG_From_int((int)(result));
12264 }
12265 {
12266 if (temp1)
12267 delete arg1;
12268 }
12269 return resultobj;
12270 fail:
12271 {
12272 if (temp1)
12273 delete arg1;
12274 }
12275 return NULL;
12276 }
12277
12278
12279 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
12280 PyObject *resultobj;
12281 wxImage *arg1 = (wxImage *) 0 ;
12282 wxString *arg2 = 0 ;
12283 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12284 int arg4 = (int) -1 ;
12285 bool result;
12286 bool temp2 = false ;
12287 PyObject * obj0 = 0 ;
12288 PyObject * obj1 = 0 ;
12289 PyObject * obj2 = 0 ;
12290 PyObject * obj3 = 0 ;
12291 char *kwnames[] = {
12292 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
12293 };
12294
12295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12297 if (SWIG_arg_fail(1)) SWIG_fail;
12298 {
12299 arg2 = wxString_in_helper(obj1);
12300 if (arg2 == NULL) SWIG_fail;
12301 temp2 = true;
12302 }
12303 if (obj2) {
12304 {
12305 arg3 = (long)(SWIG_As_long(obj2));
12306 if (SWIG_arg_fail(3)) SWIG_fail;
12307 }
12308 }
12309 if (obj3) {
12310 {
12311 arg4 = (int)(SWIG_As_int(obj3));
12312 if (SWIG_arg_fail(4)) SWIG_fail;
12313 }
12314 }
12315 {
12316 PyThreadState* __tstate = wxPyBeginAllowThreads();
12317 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
12318
12319 wxPyEndAllowThreads(__tstate);
12320 if (PyErr_Occurred()) SWIG_fail;
12321 }
12322 {
12323 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12324 }
12325 {
12326 if (temp2)
12327 delete arg2;
12328 }
12329 return resultobj;
12330 fail:
12331 {
12332 if (temp2)
12333 delete arg2;
12334 }
12335 return NULL;
12336 }
12337
12338
12339 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12340 PyObject *resultobj;
12341 wxImage *arg1 = (wxImage *) 0 ;
12342 wxString *arg2 = 0 ;
12343 wxString *arg3 = 0 ;
12344 int arg4 = (int) -1 ;
12345 bool result;
12346 bool temp2 = false ;
12347 bool temp3 = false ;
12348 PyObject * obj0 = 0 ;
12349 PyObject * obj1 = 0 ;
12350 PyObject * obj2 = 0 ;
12351 PyObject * obj3 = 0 ;
12352 char *kwnames[] = {
12353 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
12354 };
12355
12356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12358 if (SWIG_arg_fail(1)) SWIG_fail;
12359 {
12360 arg2 = wxString_in_helper(obj1);
12361 if (arg2 == NULL) SWIG_fail;
12362 temp2 = true;
12363 }
12364 {
12365 arg3 = wxString_in_helper(obj2);
12366 if (arg3 == NULL) SWIG_fail;
12367 temp3 = true;
12368 }
12369 if (obj3) {
12370 {
12371 arg4 = (int)(SWIG_As_int(obj3));
12372 if (SWIG_arg_fail(4)) SWIG_fail;
12373 }
12374 }
12375 {
12376 PyThreadState* __tstate = wxPyBeginAllowThreads();
12377 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
12378
12379 wxPyEndAllowThreads(__tstate);
12380 if (PyErr_Occurred()) SWIG_fail;
12381 }
12382 {
12383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12384 }
12385 {
12386 if (temp2)
12387 delete arg2;
12388 }
12389 {
12390 if (temp3)
12391 delete arg3;
12392 }
12393 return resultobj;
12394 fail:
12395 {
12396 if (temp2)
12397 delete arg2;
12398 }
12399 {
12400 if (temp3)
12401 delete arg3;
12402 }
12403 return NULL;
12404 }
12405
12406
12407 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
12408 PyObject *resultobj;
12409 wxImage *arg1 = (wxImage *) 0 ;
12410 wxString *arg2 = 0 ;
12411 int arg3 ;
12412 bool result;
12413 bool temp2 = false ;
12414 PyObject * obj0 = 0 ;
12415 PyObject * obj1 = 0 ;
12416 PyObject * obj2 = 0 ;
12417 char *kwnames[] = {
12418 (char *) "self",(char *) "name",(char *) "type", NULL
12419 };
12420
12421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12423 if (SWIG_arg_fail(1)) SWIG_fail;
12424 {
12425 arg2 = wxString_in_helper(obj1);
12426 if (arg2 == NULL) SWIG_fail;
12427 temp2 = true;
12428 }
12429 {
12430 arg3 = (int)(SWIG_As_int(obj2));
12431 if (SWIG_arg_fail(3)) SWIG_fail;
12432 }
12433 {
12434 PyThreadState* __tstate = wxPyBeginAllowThreads();
12435 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12436
12437 wxPyEndAllowThreads(__tstate);
12438 if (PyErr_Occurred()) SWIG_fail;
12439 }
12440 {
12441 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12442 }
12443 {
12444 if (temp2)
12445 delete arg2;
12446 }
12447 return resultobj;
12448 fail:
12449 {
12450 if (temp2)
12451 delete arg2;
12452 }
12453 return NULL;
12454 }
12455
12456
12457 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12458 PyObject *resultobj;
12459 wxImage *arg1 = (wxImage *) 0 ;
12460 wxString *arg2 = 0 ;
12461 wxString *arg3 = 0 ;
12462 bool result;
12463 bool temp2 = false ;
12464 bool temp3 = false ;
12465 PyObject * obj0 = 0 ;
12466 PyObject * obj1 = 0 ;
12467 PyObject * obj2 = 0 ;
12468 char *kwnames[] = {
12469 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12470 };
12471
12472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12474 if (SWIG_arg_fail(1)) SWIG_fail;
12475 {
12476 arg2 = wxString_in_helper(obj1);
12477 if (arg2 == NULL) SWIG_fail;
12478 temp2 = true;
12479 }
12480 {
12481 arg3 = wxString_in_helper(obj2);
12482 if (arg3 == NULL) SWIG_fail;
12483 temp3 = true;
12484 }
12485 {
12486 PyThreadState* __tstate = wxPyBeginAllowThreads();
12487 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12488
12489 wxPyEndAllowThreads(__tstate);
12490 if (PyErr_Occurred()) SWIG_fail;
12491 }
12492 {
12493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12494 }
12495 {
12496 if (temp2)
12497 delete arg2;
12498 }
12499 {
12500 if (temp3)
12501 delete arg3;
12502 }
12503 return resultobj;
12504 fail:
12505 {
12506 if (temp2)
12507 delete arg2;
12508 }
12509 {
12510 if (temp3)
12511 delete arg3;
12512 }
12513 return NULL;
12514 }
12515
12516
12517 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12518 PyObject *resultobj;
12519 wxInputStream *arg1 = 0 ;
12520 bool result;
12521 wxPyInputStream *temp1 ;
12522 bool created1 ;
12523 PyObject * obj0 = 0 ;
12524 char *kwnames[] = {
12525 (char *) "stream", NULL
12526 };
12527
12528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12529 {
12530 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12531 arg1 = temp1->m_wxis;
12532 created1 = false;
12533 } else {
12534 PyErr_Clear(); // clear the failure of the wxPyConvert above
12535 arg1 = wxPyCBInputStream_create(obj0, false);
12536 if (arg1 == NULL) {
12537 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12538 SWIG_fail;
12539 }
12540 created1 = true;
12541 }
12542 }
12543 {
12544 PyThreadState* __tstate = wxPyBeginAllowThreads();
12545 result = (bool)wxImage::CanRead(*arg1);
12546
12547 wxPyEndAllowThreads(__tstate);
12548 if (PyErr_Occurred()) SWIG_fail;
12549 }
12550 {
12551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12552 }
12553 {
12554 if (created1) delete arg1;
12555 }
12556 return resultobj;
12557 fail:
12558 {
12559 if (created1) delete arg1;
12560 }
12561 return NULL;
12562 }
12563
12564
12565 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12566 PyObject *resultobj;
12567 wxImage *arg1 = (wxImage *) 0 ;
12568 wxInputStream *arg2 = 0 ;
12569 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12570 int arg4 = (int) -1 ;
12571 bool result;
12572 wxPyInputStream *temp2 ;
12573 bool created2 ;
12574 PyObject * obj0 = 0 ;
12575 PyObject * obj1 = 0 ;
12576 PyObject * obj2 = 0 ;
12577 PyObject * obj3 = 0 ;
12578 char *kwnames[] = {
12579 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12580 };
12581
12582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12584 if (SWIG_arg_fail(1)) SWIG_fail;
12585 {
12586 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12587 arg2 = temp2->m_wxis;
12588 created2 = false;
12589 } else {
12590 PyErr_Clear(); // clear the failure of the wxPyConvert above
12591 arg2 = wxPyCBInputStream_create(obj1, false);
12592 if (arg2 == NULL) {
12593 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12594 SWIG_fail;
12595 }
12596 created2 = true;
12597 }
12598 }
12599 if (obj2) {
12600 {
12601 arg3 = (long)(SWIG_As_long(obj2));
12602 if (SWIG_arg_fail(3)) SWIG_fail;
12603 }
12604 }
12605 if (obj3) {
12606 {
12607 arg4 = (int)(SWIG_As_int(obj3));
12608 if (SWIG_arg_fail(4)) SWIG_fail;
12609 }
12610 }
12611 {
12612 PyThreadState* __tstate = wxPyBeginAllowThreads();
12613 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12614
12615 wxPyEndAllowThreads(__tstate);
12616 if (PyErr_Occurred()) SWIG_fail;
12617 }
12618 {
12619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12620 }
12621 {
12622 if (created2) delete arg2;
12623 }
12624 return resultobj;
12625 fail:
12626 {
12627 if (created2) delete arg2;
12628 }
12629 return NULL;
12630 }
12631
12632
12633 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12634 PyObject *resultobj;
12635 wxImage *arg1 = (wxImage *) 0 ;
12636 wxInputStream *arg2 = 0 ;
12637 wxString *arg3 = 0 ;
12638 int arg4 = (int) -1 ;
12639 bool result;
12640 wxPyInputStream *temp2 ;
12641 bool created2 ;
12642 bool temp3 = false ;
12643 PyObject * obj0 = 0 ;
12644 PyObject * obj1 = 0 ;
12645 PyObject * obj2 = 0 ;
12646 PyObject * obj3 = 0 ;
12647 char *kwnames[] = {
12648 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12649 };
12650
12651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12653 if (SWIG_arg_fail(1)) SWIG_fail;
12654 {
12655 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12656 arg2 = temp2->m_wxis;
12657 created2 = false;
12658 } else {
12659 PyErr_Clear(); // clear the failure of the wxPyConvert above
12660 arg2 = wxPyCBInputStream_create(obj1, false);
12661 if (arg2 == NULL) {
12662 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12663 SWIG_fail;
12664 }
12665 created2 = true;
12666 }
12667 }
12668 {
12669 arg3 = wxString_in_helper(obj2);
12670 if (arg3 == NULL) SWIG_fail;
12671 temp3 = true;
12672 }
12673 if (obj3) {
12674 {
12675 arg4 = (int)(SWIG_As_int(obj3));
12676 if (SWIG_arg_fail(4)) SWIG_fail;
12677 }
12678 }
12679 {
12680 PyThreadState* __tstate = wxPyBeginAllowThreads();
12681 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12682
12683 wxPyEndAllowThreads(__tstate);
12684 if (PyErr_Occurred()) SWIG_fail;
12685 }
12686 {
12687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12688 }
12689 {
12690 if (created2) delete arg2;
12691 }
12692 {
12693 if (temp3)
12694 delete arg3;
12695 }
12696 return resultobj;
12697 fail:
12698 {
12699 if (created2) delete arg2;
12700 }
12701 {
12702 if (temp3)
12703 delete arg3;
12704 }
12705 return NULL;
12706 }
12707
12708
12709 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12710 PyObject *resultobj;
12711 wxImage *arg1 = (wxImage *) 0 ;
12712 bool result;
12713 PyObject * obj0 = 0 ;
12714 char *kwnames[] = {
12715 (char *) "self", NULL
12716 };
12717
12718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12720 if (SWIG_arg_fail(1)) SWIG_fail;
12721 {
12722 PyThreadState* __tstate = wxPyBeginAllowThreads();
12723 result = (bool)(arg1)->Ok();
12724
12725 wxPyEndAllowThreads(__tstate);
12726 if (PyErr_Occurred()) SWIG_fail;
12727 }
12728 {
12729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12730 }
12731 return resultobj;
12732 fail:
12733 return NULL;
12734 }
12735
12736
12737 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12738 PyObject *resultobj;
12739 wxImage *arg1 = (wxImage *) 0 ;
12740 int result;
12741 PyObject * obj0 = 0 ;
12742 char *kwnames[] = {
12743 (char *) "self", NULL
12744 };
12745
12746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12748 if (SWIG_arg_fail(1)) SWIG_fail;
12749 {
12750 PyThreadState* __tstate = wxPyBeginAllowThreads();
12751 result = (int)(arg1)->GetWidth();
12752
12753 wxPyEndAllowThreads(__tstate);
12754 if (PyErr_Occurred()) SWIG_fail;
12755 }
12756 {
12757 resultobj = SWIG_From_int((int)(result));
12758 }
12759 return resultobj;
12760 fail:
12761 return NULL;
12762 }
12763
12764
12765 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12766 PyObject *resultobj;
12767 wxImage *arg1 = (wxImage *) 0 ;
12768 int result;
12769 PyObject * obj0 = 0 ;
12770 char *kwnames[] = {
12771 (char *) "self", NULL
12772 };
12773
12774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12776 if (SWIG_arg_fail(1)) SWIG_fail;
12777 {
12778 PyThreadState* __tstate = wxPyBeginAllowThreads();
12779 result = (int)(arg1)->GetHeight();
12780
12781 wxPyEndAllowThreads(__tstate);
12782 if (PyErr_Occurred()) SWIG_fail;
12783 }
12784 {
12785 resultobj = SWIG_From_int((int)(result));
12786 }
12787 return resultobj;
12788 fail:
12789 return NULL;
12790 }
12791
12792
12793 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12794 PyObject *resultobj;
12795 wxImage *arg1 = (wxImage *) 0 ;
12796 wxSize result;
12797 PyObject * obj0 = 0 ;
12798 char *kwnames[] = {
12799 (char *) "self", NULL
12800 };
12801
12802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12804 if (SWIG_arg_fail(1)) SWIG_fail;
12805 {
12806 PyThreadState* __tstate = wxPyBeginAllowThreads();
12807 result = wxImage_GetSize(arg1);
12808
12809 wxPyEndAllowThreads(__tstate);
12810 if (PyErr_Occurred()) SWIG_fail;
12811 }
12812 {
12813 wxSize * resultptr;
12814 resultptr = new wxSize((wxSize &)(result));
12815 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12816 }
12817 return resultobj;
12818 fail:
12819 return NULL;
12820 }
12821
12822
12823 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12824 PyObject *resultobj;
12825 wxImage *arg1 = (wxImage *) 0 ;
12826 wxRect *arg2 = 0 ;
12827 SwigValueWrapper<wxImage > result;
12828 wxRect temp2 ;
12829 PyObject * obj0 = 0 ;
12830 PyObject * obj1 = 0 ;
12831 char *kwnames[] = {
12832 (char *) "self",(char *) "rect", NULL
12833 };
12834
12835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) 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 = &temp2;
12840 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12841 }
12842 {
12843 PyThreadState* __tstate = wxPyBeginAllowThreads();
12844 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12845
12846 wxPyEndAllowThreads(__tstate);
12847 if (PyErr_Occurred()) SWIG_fail;
12848 }
12849 {
12850 wxImage * resultptr;
12851 resultptr = new wxImage((wxImage &)(result));
12852 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12853 }
12854 return resultobj;
12855 fail:
12856 return NULL;
12857 }
12858
12859
12860 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12861 PyObject *resultobj;
12862 wxImage *arg1 = (wxImage *) 0 ;
12863 wxSize *arg2 = 0 ;
12864 wxPoint *arg3 = 0 ;
12865 int arg4 = (int) -1 ;
12866 int arg5 = (int) -1 ;
12867 int arg6 = (int) -1 ;
12868 SwigValueWrapper<wxImage > result;
12869 wxSize temp2 ;
12870 wxPoint temp3 ;
12871 PyObject * obj0 = 0 ;
12872 PyObject * obj1 = 0 ;
12873 PyObject * obj2 = 0 ;
12874 PyObject * obj3 = 0 ;
12875 PyObject * obj4 = 0 ;
12876 PyObject * obj5 = 0 ;
12877 char *kwnames[] = {
12878 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12879 };
12880
12881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12883 if (SWIG_arg_fail(1)) SWIG_fail;
12884 {
12885 arg2 = &temp2;
12886 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12887 }
12888 {
12889 arg3 = &temp3;
12890 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12891 }
12892 if (obj3) {
12893 {
12894 arg4 = (int)(SWIG_As_int(obj3));
12895 if (SWIG_arg_fail(4)) SWIG_fail;
12896 }
12897 }
12898 if (obj4) {
12899 {
12900 arg5 = (int)(SWIG_As_int(obj4));
12901 if (SWIG_arg_fail(5)) SWIG_fail;
12902 }
12903 }
12904 if (obj5) {
12905 {
12906 arg6 = (int)(SWIG_As_int(obj5));
12907 if (SWIG_arg_fail(6)) SWIG_fail;
12908 }
12909 }
12910 {
12911 PyThreadState* __tstate = wxPyBeginAllowThreads();
12912 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12913
12914 wxPyEndAllowThreads(__tstate);
12915 if (PyErr_Occurred()) SWIG_fail;
12916 }
12917 {
12918 wxImage * resultptr;
12919 resultptr = new wxImage((wxImage &)(result));
12920 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12921 }
12922 return resultobj;
12923 fail:
12924 return NULL;
12925 }
12926
12927
12928 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12929 PyObject *resultobj;
12930 wxImage *arg1 = (wxImage *) 0 ;
12931 SwigValueWrapper<wxImage > result;
12932 PyObject * obj0 = 0 ;
12933 char *kwnames[] = {
12934 (char *) "self", NULL
12935 };
12936
12937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
12942 result = (arg1)->Copy();
12943
12944 wxPyEndAllowThreads(__tstate);
12945 if (PyErr_Occurred()) SWIG_fail;
12946 }
12947 {
12948 wxImage * resultptr;
12949 resultptr = new wxImage((wxImage &)(result));
12950 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12951 }
12952 return resultobj;
12953 fail:
12954 return NULL;
12955 }
12956
12957
12958 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12959 PyObject *resultobj;
12960 wxImage *arg1 = (wxImage *) 0 ;
12961 wxImage *arg2 = 0 ;
12962 int arg3 ;
12963 int arg4 ;
12964 PyObject * obj0 = 0 ;
12965 PyObject * obj1 = 0 ;
12966 PyObject * obj2 = 0 ;
12967 PyObject * obj3 = 0 ;
12968 char *kwnames[] = {
12969 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12970 };
12971
12972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12974 if (SWIG_arg_fail(1)) SWIG_fail;
12975 {
12976 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12977 if (SWIG_arg_fail(2)) SWIG_fail;
12978 if (arg2 == NULL) {
12979 SWIG_null_ref("wxImage");
12980 }
12981 if (SWIG_arg_fail(2)) SWIG_fail;
12982 }
12983 {
12984 arg3 = (int)(SWIG_As_int(obj2));
12985 if (SWIG_arg_fail(3)) SWIG_fail;
12986 }
12987 {
12988 arg4 = (int)(SWIG_As_int(obj3));
12989 if (SWIG_arg_fail(4)) SWIG_fail;
12990 }
12991 {
12992 PyThreadState* __tstate = wxPyBeginAllowThreads();
12993 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12994
12995 wxPyEndAllowThreads(__tstate);
12996 if (PyErr_Occurred()) SWIG_fail;
12997 }
12998 Py_INCREF(Py_None); resultobj = Py_None;
12999 return resultobj;
13000 fail:
13001 return NULL;
13002 }
13003
13004
13005 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
13006 PyObject *resultobj;
13007 wxImage *arg1 = (wxImage *) 0 ;
13008 PyObject *result;
13009 PyObject * obj0 = 0 ;
13010 char *kwnames[] = {
13011 (char *) "self", NULL
13012 };
13013
13014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
13015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13016 if (SWIG_arg_fail(1)) SWIG_fail;
13017 {
13018 PyThreadState* __tstate = wxPyBeginAllowThreads();
13019 result = (PyObject *)wxImage_GetData(arg1);
13020
13021 wxPyEndAllowThreads(__tstate);
13022 if (PyErr_Occurred()) SWIG_fail;
13023 }
13024 resultobj = result;
13025 return resultobj;
13026 fail:
13027 return NULL;
13028 }
13029
13030
13031 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
13032 PyObject *resultobj;
13033 wxImage *arg1 = (wxImage *) 0 ;
13034 buffer arg2 ;
13035 int arg3 ;
13036 PyObject * obj0 = 0 ;
13037 PyObject * obj1 = 0 ;
13038 char *kwnames[] = {
13039 (char *) "self",(char *) "data", NULL
13040 };
13041
13042 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
13043 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13044 if (SWIG_arg_fail(1)) SWIG_fail;
13045 {
13046 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13047 }
13048 {
13049 PyThreadState* __tstate = wxPyBeginAllowThreads();
13050 wxImage_SetData(arg1,arg2,arg3);
13051
13052 wxPyEndAllowThreads(__tstate);
13053 if (PyErr_Occurred()) SWIG_fail;
13054 }
13055 Py_INCREF(Py_None); resultobj = Py_None;
13056 return resultobj;
13057 fail:
13058 return NULL;
13059 }
13060
13061
13062 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13063 PyObject *resultobj;
13064 wxImage *arg1 = (wxImage *) 0 ;
13065 PyObject *result;
13066 PyObject * obj0 = 0 ;
13067 char *kwnames[] = {
13068 (char *) "self", NULL
13069 };
13070
13071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
13072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13073 if (SWIG_arg_fail(1)) SWIG_fail;
13074 {
13075 PyThreadState* __tstate = wxPyBeginAllowThreads();
13076 result = (PyObject *)wxImage_GetDataBuffer(arg1);
13077
13078 wxPyEndAllowThreads(__tstate);
13079 if (PyErr_Occurred()) SWIG_fail;
13080 }
13081 resultobj = result;
13082 return resultobj;
13083 fail:
13084 return NULL;
13085 }
13086
13087
13088 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13089 PyObject *resultobj;
13090 wxImage *arg1 = (wxImage *) 0 ;
13091 buffer arg2 ;
13092 int arg3 ;
13093 PyObject * obj0 = 0 ;
13094 PyObject * obj1 = 0 ;
13095 char *kwnames[] = {
13096 (char *) "self",(char *) "data", NULL
13097 };
13098
13099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
13100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13101 if (SWIG_arg_fail(1)) SWIG_fail;
13102 {
13103 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13104 }
13105 {
13106 PyThreadState* __tstate = wxPyBeginAllowThreads();
13107 wxImage_SetDataBuffer(arg1,arg2,arg3);
13108
13109 wxPyEndAllowThreads(__tstate);
13110 if (PyErr_Occurred()) SWIG_fail;
13111 }
13112 Py_INCREF(Py_None); resultobj = Py_None;
13113 return resultobj;
13114 fail:
13115 return NULL;
13116 }
13117
13118
13119 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13120 PyObject *resultobj;
13121 wxImage *arg1 = (wxImage *) 0 ;
13122 PyObject *result;
13123 PyObject * obj0 = 0 ;
13124 char *kwnames[] = {
13125 (char *) "self", NULL
13126 };
13127
13128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",kwnames,&obj0)) goto fail;
13129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13130 if (SWIG_arg_fail(1)) SWIG_fail;
13131 {
13132 PyThreadState* __tstate = wxPyBeginAllowThreads();
13133 result = (PyObject *)wxImage_GetAlphaData(arg1);
13134
13135 wxPyEndAllowThreads(__tstate);
13136 if (PyErr_Occurred()) SWIG_fail;
13137 }
13138 resultobj = result;
13139 return resultobj;
13140 fail:
13141 return NULL;
13142 }
13143
13144
13145 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
13146 PyObject *resultobj;
13147 wxImage *arg1 = (wxImage *) 0 ;
13148 buffer arg2 ;
13149 int arg3 ;
13150 PyObject * obj0 = 0 ;
13151 PyObject * obj1 = 0 ;
13152 char *kwnames[] = {
13153 (char *) "self",(char *) "alpha", NULL
13154 };
13155
13156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) goto fail;
13157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13158 if (SWIG_arg_fail(1)) SWIG_fail;
13159 {
13160 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13161 }
13162 {
13163 PyThreadState* __tstate = wxPyBeginAllowThreads();
13164 wxImage_SetAlphaData(arg1,arg2,arg3);
13165
13166 wxPyEndAllowThreads(__tstate);
13167 if (PyErr_Occurred()) SWIG_fail;
13168 }
13169 Py_INCREF(Py_None); resultobj = Py_None;
13170 return resultobj;
13171 fail:
13172 return NULL;
13173 }
13174
13175
13176 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13177 PyObject *resultobj;
13178 wxImage *arg1 = (wxImage *) 0 ;
13179 PyObject *result;
13180 PyObject * obj0 = 0 ;
13181 char *kwnames[] = {
13182 (char *) "self", NULL
13183 };
13184
13185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
13186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13187 if (SWIG_arg_fail(1)) SWIG_fail;
13188 {
13189 PyThreadState* __tstate = wxPyBeginAllowThreads();
13190 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
13191
13192 wxPyEndAllowThreads(__tstate);
13193 if (PyErr_Occurred()) SWIG_fail;
13194 }
13195 resultobj = result;
13196 return resultobj;
13197 fail:
13198 return NULL;
13199 }
13200
13201
13202 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
13203 PyObject *resultobj;
13204 wxImage *arg1 = (wxImage *) 0 ;
13205 buffer arg2 ;
13206 int arg3 ;
13207 PyObject * obj0 = 0 ;
13208 PyObject * obj1 = 0 ;
13209 char *kwnames[] = {
13210 (char *) "self",(char *) "alpha", NULL
13211 };
13212
13213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
13214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13215 if (SWIG_arg_fail(1)) SWIG_fail;
13216 {
13217 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
13218 }
13219 {
13220 PyThreadState* __tstate = wxPyBeginAllowThreads();
13221 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
13222
13223 wxPyEndAllowThreads(__tstate);
13224 if (PyErr_Occurred()) SWIG_fail;
13225 }
13226 Py_INCREF(Py_None); resultobj = Py_None;
13227 return resultobj;
13228 fail:
13229 return NULL;
13230 }
13231
13232
13233 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13234 PyObject *resultobj;
13235 wxImage *arg1 = (wxImage *) 0 ;
13236 byte arg2 ;
13237 byte arg3 ;
13238 byte arg4 ;
13239 PyObject * obj0 = 0 ;
13240 PyObject * obj1 = 0 ;
13241 PyObject * obj2 = 0 ;
13242 PyObject * obj3 = 0 ;
13243 char *kwnames[] = {
13244 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13245 };
13246
13247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13249 if (SWIG_arg_fail(1)) SWIG_fail;
13250 {
13251 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13252 if (SWIG_arg_fail(2)) SWIG_fail;
13253 }
13254 {
13255 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13256 if (SWIG_arg_fail(3)) SWIG_fail;
13257 }
13258 {
13259 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13260 if (SWIG_arg_fail(4)) SWIG_fail;
13261 }
13262 {
13263 PyThreadState* __tstate = wxPyBeginAllowThreads();
13264 (arg1)->SetMaskColour(arg2,arg3,arg4);
13265
13266 wxPyEndAllowThreads(__tstate);
13267 if (PyErr_Occurred()) SWIG_fail;
13268 }
13269 Py_INCREF(Py_None); resultobj = Py_None;
13270 return resultobj;
13271 fail:
13272 return NULL;
13273 }
13274
13275
13276 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
13277 PyObject *resultobj;
13278 wxImage *arg1 = (wxImage *) 0 ;
13279 byte *arg2 = (byte *) 0 ;
13280 byte *arg3 = (byte *) 0 ;
13281 byte *arg4 = (byte *) 0 ;
13282 byte temp2 ;
13283 int res2 = 0 ;
13284 byte temp3 ;
13285 int res3 = 0 ;
13286 byte temp4 ;
13287 int res4 = 0 ;
13288 PyObject * obj0 = 0 ;
13289 char *kwnames[] = {
13290 (char *) "self", NULL
13291 };
13292
13293 arg2 = &temp2; res2 = SWIG_NEWOBJ;
13294 arg3 = &temp3; res3 = SWIG_NEWOBJ;
13295 arg4 = &temp4; res4 = SWIG_NEWOBJ;
13296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
13297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13298 if (SWIG_arg_fail(1)) SWIG_fail;
13299 {
13300 PyThreadState* __tstate = wxPyBeginAllowThreads();
13301 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
13302
13303 wxPyEndAllowThreads(__tstate);
13304 if (PyErr_Occurred()) SWIG_fail;
13305 }
13306 Py_INCREF(Py_None); resultobj = Py_None;
13307 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
13308 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
13309 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
13310 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
13311 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
13312 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
13313 return resultobj;
13314 fail:
13315 return NULL;
13316 }
13317
13318
13319 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
13320 PyObject *resultobj;
13321 wxImage *arg1 = (wxImage *) 0 ;
13322 byte result;
13323 PyObject * obj0 = 0 ;
13324 char *kwnames[] = {
13325 (char *) "self", NULL
13326 };
13327
13328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
13329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13330 if (SWIG_arg_fail(1)) SWIG_fail;
13331 {
13332 PyThreadState* __tstate = wxPyBeginAllowThreads();
13333 result = (byte)(arg1)->GetMaskRed();
13334
13335 wxPyEndAllowThreads(__tstate);
13336 if (PyErr_Occurred()) SWIG_fail;
13337 }
13338 {
13339 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
13340 }
13341 return resultobj;
13342 fail:
13343 return NULL;
13344 }
13345
13346
13347 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
13348 PyObject *resultobj;
13349 wxImage *arg1 = (wxImage *) 0 ;
13350 byte result;
13351 PyObject * obj0 = 0 ;
13352 char *kwnames[] = {
13353 (char *) "self", NULL
13354 };
13355
13356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
13357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13358 if (SWIG_arg_fail(1)) SWIG_fail;
13359 {
13360 PyThreadState* __tstate = wxPyBeginAllowThreads();
13361 result = (byte)(arg1)->GetMaskGreen();
13362
13363 wxPyEndAllowThreads(__tstate);
13364 if (PyErr_Occurred()) SWIG_fail;
13365 }
13366 {
13367 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
13368 }
13369 return resultobj;
13370 fail:
13371 return NULL;
13372 }
13373
13374
13375 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
13376 PyObject *resultobj;
13377 wxImage *arg1 = (wxImage *) 0 ;
13378 byte result;
13379 PyObject * obj0 = 0 ;
13380 char *kwnames[] = {
13381 (char *) "self", NULL
13382 };
13383
13384 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
13385 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13386 if (SWIG_arg_fail(1)) SWIG_fail;
13387 {
13388 PyThreadState* __tstate = wxPyBeginAllowThreads();
13389 result = (byte)(arg1)->GetMaskBlue();
13390
13391 wxPyEndAllowThreads(__tstate);
13392 if (PyErr_Occurred()) SWIG_fail;
13393 }
13394 {
13395 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
13396 }
13397 return resultobj;
13398 fail:
13399 return NULL;
13400 }
13401
13402
13403 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
13404 PyObject *resultobj;
13405 wxImage *arg1 = (wxImage *) 0 ;
13406 bool arg2 = (bool) true ;
13407 PyObject * obj0 = 0 ;
13408 PyObject * obj1 = 0 ;
13409 char *kwnames[] = {
13410 (char *) "self",(char *) "mask", NULL
13411 };
13412
13413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13415 if (SWIG_arg_fail(1)) SWIG_fail;
13416 if (obj1) {
13417 {
13418 arg2 = (bool)(SWIG_As_bool(obj1));
13419 if (SWIG_arg_fail(2)) SWIG_fail;
13420 }
13421 }
13422 {
13423 PyThreadState* __tstate = wxPyBeginAllowThreads();
13424 (arg1)->SetMask(arg2);
13425
13426 wxPyEndAllowThreads(__tstate);
13427 if (PyErr_Occurred()) SWIG_fail;
13428 }
13429 Py_INCREF(Py_None); resultobj = Py_None;
13430 return resultobj;
13431 fail:
13432 return NULL;
13433 }
13434
13435
13436 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13437 PyObject *resultobj;
13438 wxImage *arg1 = (wxImage *) 0 ;
13439 bool result;
13440 PyObject * obj0 = 0 ;
13441 char *kwnames[] = {
13442 (char *) "self", NULL
13443 };
13444
13445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13447 if (SWIG_arg_fail(1)) SWIG_fail;
13448 {
13449 PyThreadState* __tstate = wxPyBeginAllowThreads();
13450 result = (bool)(arg1)->HasMask();
13451
13452 wxPyEndAllowThreads(__tstate);
13453 if (PyErr_Occurred()) SWIG_fail;
13454 }
13455 {
13456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13457 }
13458 return resultobj;
13459 fail:
13460 return NULL;
13461 }
13462
13463
13464 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13465 PyObject *resultobj;
13466 wxImage *arg1 = (wxImage *) 0 ;
13467 double arg2 ;
13468 wxPoint *arg3 = 0 ;
13469 bool arg4 = (bool) true ;
13470 wxPoint *arg5 = (wxPoint *) NULL ;
13471 SwigValueWrapper<wxImage > result;
13472 wxPoint temp3 ;
13473 PyObject * obj0 = 0 ;
13474 PyObject * obj1 = 0 ;
13475 PyObject * obj2 = 0 ;
13476 PyObject * obj3 = 0 ;
13477 PyObject * obj4 = 0 ;
13478 char *kwnames[] = {
13479 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13480 };
13481
13482 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13483 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13484 if (SWIG_arg_fail(1)) SWIG_fail;
13485 {
13486 arg2 = (double)(SWIG_As_double(obj1));
13487 if (SWIG_arg_fail(2)) SWIG_fail;
13488 }
13489 {
13490 arg3 = &temp3;
13491 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13492 }
13493 if (obj3) {
13494 {
13495 arg4 = (bool)(SWIG_As_bool(obj3));
13496 if (SWIG_arg_fail(4)) SWIG_fail;
13497 }
13498 }
13499 if (obj4) {
13500 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13501 if (SWIG_arg_fail(5)) SWIG_fail;
13502 }
13503 {
13504 PyThreadState* __tstate = wxPyBeginAllowThreads();
13505 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13506
13507 wxPyEndAllowThreads(__tstate);
13508 if (PyErr_Occurred()) SWIG_fail;
13509 }
13510 {
13511 wxImage * resultptr;
13512 resultptr = new wxImage((wxImage &)(result));
13513 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13514 }
13515 return resultobj;
13516 fail:
13517 return NULL;
13518 }
13519
13520
13521 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13522 PyObject *resultobj;
13523 wxImage *arg1 = (wxImage *) 0 ;
13524 bool arg2 = (bool) true ;
13525 SwigValueWrapper<wxImage > result;
13526 PyObject * obj0 = 0 ;
13527 PyObject * obj1 = 0 ;
13528 char *kwnames[] = {
13529 (char *) "self",(char *) "clockwise", NULL
13530 };
13531
13532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13534 if (SWIG_arg_fail(1)) SWIG_fail;
13535 if (obj1) {
13536 {
13537 arg2 = (bool)(SWIG_As_bool(obj1));
13538 if (SWIG_arg_fail(2)) SWIG_fail;
13539 }
13540 }
13541 {
13542 PyThreadState* __tstate = wxPyBeginAllowThreads();
13543 result = (arg1)->Rotate90(arg2);
13544
13545 wxPyEndAllowThreads(__tstate);
13546 if (PyErr_Occurred()) SWIG_fail;
13547 }
13548 {
13549 wxImage * resultptr;
13550 resultptr = new wxImage((wxImage &)(result));
13551 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13552 }
13553 return resultobj;
13554 fail:
13555 return NULL;
13556 }
13557
13558
13559 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13560 PyObject *resultobj;
13561 wxImage *arg1 = (wxImage *) 0 ;
13562 bool arg2 = (bool) true ;
13563 SwigValueWrapper<wxImage > result;
13564 PyObject * obj0 = 0 ;
13565 PyObject * obj1 = 0 ;
13566 char *kwnames[] = {
13567 (char *) "self",(char *) "horizontally", NULL
13568 };
13569
13570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13572 if (SWIG_arg_fail(1)) SWIG_fail;
13573 if (obj1) {
13574 {
13575 arg2 = (bool)(SWIG_As_bool(obj1));
13576 if (SWIG_arg_fail(2)) SWIG_fail;
13577 }
13578 }
13579 {
13580 PyThreadState* __tstate = wxPyBeginAllowThreads();
13581 result = (arg1)->Mirror(arg2);
13582
13583 wxPyEndAllowThreads(__tstate);
13584 if (PyErr_Occurred()) SWIG_fail;
13585 }
13586 {
13587 wxImage * resultptr;
13588 resultptr = new wxImage((wxImage &)(result));
13589 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13590 }
13591 return resultobj;
13592 fail:
13593 return NULL;
13594 }
13595
13596
13597 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13598 PyObject *resultobj;
13599 wxImage *arg1 = (wxImage *) 0 ;
13600 byte arg2 ;
13601 byte arg3 ;
13602 byte arg4 ;
13603 byte arg5 ;
13604 byte arg6 ;
13605 byte arg7 ;
13606 PyObject * obj0 = 0 ;
13607 PyObject * obj1 = 0 ;
13608 PyObject * obj2 = 0 ;
13609 PyObject * obj3 = 0 ;
13610 PyObject * obj4 = 0 ;
13611 PyObject * obj5 = 0 ;
13612 PyObject * obj6 = 0 ;
13613 char *kwnames[] = {
13614 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13615 };
13616
13617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13619 if (SWIG_arg_fail(1)) SWIG_fail;
13620 {
13621 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13622 if (SWIG_arg_fail(2)) SWIG_fail;
13623 }
13624 {
13625 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13626 if (SWIG_arg_fail(3)) SWIG_fail;
13627 }
13628 {
13629 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13630 if (SWIG_arg_fail(4)) SWIG_fail;
13631 }
13632 {
13633 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
13634 if (SWIG_arg_fail(5)) SWIG_fail;
13635 }
13636 {
13637 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj5));
13638 if (SWIG_arg_fail(6)) SWIG_fail;
13639 }
13640 {
13641 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj6));
13642 if (SWIG_arg_fail(7)) SWIG_fail;
13643 }
13644 {
13645 PyThreadState* __tstate = wxPyBeginAllowThreads();
13646 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13647
13648 wxPyEndAllowThreads(__tstate);
13649 if (PyErr_Occurred()) SWIG_fail;
13650 }
13651 Py_INCREF(Py_None); resultobj = Py_None;
13652 return resultobj;
13653 fail:
13654 return NULL;
13655 }
13656
13657
13658 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13659 PyObject *resultobj;
13660 wxImage *arg1 = (wxImage *) 0 ;
13661 byte arg2 ;
13662 byte arg3 ;
13663 byte arg4 ;
13664 SwigValueWrapper<wxImage > result;
13665 PyObject * obj0 = 0 ;
13666 PyObject * obj1 = 0 ;
13667 PyObject * obj2 = 0 ;
13668 PyObject * obj3 = 0 ;
13669 char *kwnames[] = {
13670 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13671 };
13672
13673 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13674 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13675 if (SWIG_arg_fail(1)) SWIG_fail;
13676 {
13677 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
13678 if (SWIG_arg_fail(2)) SWIG_fail;
13679 }
13680 {
13681 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
13682 if (SWIG_arg_fail(3)) SWIG_fail;
13683 }
13684 {
13685 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
13686 if (SWIG_arg_fail(4)) SWIG_fail;
13687 }
13688 {
13689 PyThreadState* __tstate = wxPyBeginAllowThreads();
13690 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13691
13692 wxPyEndAllowThreads(__tstate);
13693 if (PyErr_Occurred()) SWIG_fail;
13694 }
13695 {
13696 wxImage * resultptr;
13697 resultptr = new wxImage((wxImage &)(result));
13698 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13699 }
13700 return resultobj;
13701 fail:
13702 return NULL;
13703 }
13704
13705
13706 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13707 PyObject *resultobj;
13708 wxImage *arg1 = (wxImage *) 0 ;
13709 wxString *arg2 = 0 ;
13710 wxString *arg3 = 0 ;
13711 bool temp2 = false ;
13712 bool temp3 = false ;
13713 PyObject * obj0 = 0 ;
13714 PyObject * obj1 = 0 ;
13715 PyObject * obj2 = 0 ;
13716 char *kwnames[] = {
13717 (char *) "self",(char *) "name",(char *) "value", NULL
13718 };
13719
13720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13722 if (SWIG_arg_fail(1)) SWIG_fail;
13723 {
13724 arg2 = wxString_in_helper(obj1);
13725 if (arg2 == NULL) SWIG_fail;
13726 temp2 = true;
13727 }
13728 {
13729 arg3 = wxString_in_helper(obj2);
13730 if (arg3 == NULL) SWIG_fail;
13731 temp3 = true;
13732 }
13733 {
13734 PyThreadState* __tstate = wxPyBeginAllowThreads();
13735 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13736
13737 wxPyEndAllowThreads(__tstate);
13738 if (PyErr_Occurred()) SWIG_fail;
13739 }
13740 Py_INCREF(Py_None); resultobj = Py_None;
13741 {
13742 if (temp2)
13743 delete arg2;
13744 }
13745 {
13746 if (temp3)
13747 delete arg3;
13748 }
13749 return resultobj;
13750 fail:
13751 {
13752 if (temp2)
13753 delete arg2;
13754 }
13755 {
13756 if (temp3)
13757 delete arg3;
13758 }
13759 return NULL;
13760 }
13761
13762
13763 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13764 PyObject *resultobj;
13765 wxImage *arg1 = (wxImage *) 0 ;
13766 wxString *arg2 = 0 ;
13767 int arg3 ;
13768 bool temp2 = false ;
13769 PyObject * obj0 = 0 ;
13770 PyObject * obj1 = 0 ;
13771 PyObject * obj2 = 0 ;
13772 char *kwnames[] = {
13773 (char *) "self",(char *) "name",(char *) "value", NULL
13774 };
13775
13776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13778 if (SWIG_arg_fail(1)) SWIG_fail;
13779 {
13780 arg2 = wxString_in_helper(obj1);
13781 if (arg2 == NULL) SWIG_fail;
13782 temp2 = true;
13783 }
13784 {
13785 arg3 = (int)(SWIG_As_int(obj2));
13786 if (SWIG_arg_fail(3)) SWIG_fail;
13787 }
13788 {
13789 PyThreadState* __tstate = wxPyBeginAllowThreads();
13790 (arg1)->SetOption((wxString const &)*arg2,arg3);
13791
13792 wxPyEndAllowThreads(__tstate);
13793 if (PyErr_Occurred()) SWIG_fail;
13794 }
13795 Py_INCREF(Py_None); resultobj = Py_None;
13796 {
13797 if (temp2)
13798 delete arg2;
13799 }
13800 return resultobj;
13801 fail:
13802 {
13803 if (temp2)
13804 delete arg2;
13805 }
13806 return NULL;
13807 }
13808
13809
13810 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13811 PyObject *resultobj;
13812 wxImage *arg1 = (wxImage *) 0 ;
13813 wxString *arg2 = 0 ;
13814 wxString result;
13815 bool temp2 = false ;
13816 PyObject * obj0 = 0 ;
13817 PyObject * obj1 = 0 ;
13818 char *kwnames[] = {
13819 (char *) "self",(char *) "name", NULL
13820 };
13821
13822 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13823 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13824 if (SWIG_arg_fail(1)) SWIG_fail;
13825 {
13826 arg2 = wxString_in_helper(obj1);
13827 if (arg2 == NULL) SWIG_fail;
13828 temp2 = true;
13829 }
13830 {
13831 PyThreadState* __tstate = wxPyBeginAllowThreads();
13832 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13833
13834 wxPyEndAllowThreads(__tstate);
13835 if (PyErr_Occurred()) SWIG_fail;
13836 }
13837 {
13838 #if wxUSE_UNICODE
13839 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13840 #else
13841 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13842 #endif
13843 }
13844 {
13845 if (temp2)
13846 delete arg2;
13847 }
13848 return resultobj;
13849 fail:
13850 {
13851 if (temp2)
13852 delete arg2;
13853 }
13854 return NULL;
13855 }
13856
13857
13858 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13859 PyObject *resultobj;
13860 wxImage *arg1 = (wxImage *) 0 ;
13861 wxString *arg2 = 0 ;
13862 int result;
13863 bool temp2 = false ;
13864 PyObject * obj0 = 0 ;
13865 PyObject * obj1 = 0 ;
13866 char *kwnames[] = {
13867 (char *) "self",(char *) "name", NULL
13868 };
13869
13870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13872 if (SWIG_arg_fail(1)) SWIG_fail;
13873 {
13874 arg2 = wxString_in_helper(obj1);
13875 if (arg2 == NULL) SWIG_fail;
13876 temp2 = true;
13877 }
13878 {
13879 PyThreadState* __tstate = wxPyBeginAllowThreads();
13880 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13881
13882 wxPyEndAllowThreads(__tstate);
13883 if (PyErr_Occurred()) SWIG_fail;
13884 }
13885 {
13886 resultobj = SWIG_From_int((int)(result));
13887 }
13888 {
13889 if (temp2)
13890 delete arg2;
13891 }
13892 return resultobj;
13893 fail:
13894 {
13895 if (temp2)
13896 delete arg2;
13897 }
13898 return NULL;
13899 }
13900
13901
13902 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13903 PyObject *resultobj;
13904 wxImage *arg1 = (wxImage *) 0 ;
13905 wxString *arg2 = 0 ;
13906 bool result;
13907 bool temp2 = false ;
13908 PyObject * obj0 = 0 ;
13909 PyObject * obj1 = 0 ;
13910 char *kwnames[] = {
13911 (char *) "self",(char *) "name", NULL
13912 };
13913
13914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13916 if (SWIG_arg_fail(1)) SWIG_fail;
13917 {
13918 arg2 = wxString_in_helper(obj1);
13919 if (arg2 == NULL) SWIG_fail;
13920 temp2 = true;
13921 }
13922 {
13923 PyThreadState* __tstate = wxPyBeginAllowThreads();
13924 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13925
13926 wxPyEndAllowThreads(__tstate);
13927 if (PyErr_Occurred()) SWIG_fail;
13928 }
13929 {
13930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13931 }
13932 {
13933 if (temp2)
13934 delete arg2;
13935 }
13936 return resultobj;
13937 fail:
13938 {
13939 if (temp2)
13940 delete arg2;
13941 }
13942 return NULL;
13943 }
13944
13945
13946 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13947 PyObject *resultobj;
13948 wxImage *arg1 = (wxImage *) 0 ;
13949 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13950 unsigned long result;
13951 PyObject * obj0 = 0 ;
13952 PyObject * obj1 = 0 ;
13953 char *kwnames[] = {
13954 (char *) "self",(char *) "stopafter", NULL
13955 };
13956
13957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13959 if (SWIG_arg_fail(1)) SWIG_fail;
13960 if (obj1) {
13961 {
13962 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13963 if (SWIG_arg_fail(2)) SWIG_fail;
13964 }
13965 }
13966 {
13967 PyThreadState* __tstate = wxPyBeginAllowThreads();
13968 result = (unsigned long)(arg1)->CountColours(arg2);
13969
13970 wxPyEndAllowThreads(__tstate);
13971 if (PyErr_Occurred()) SWIG_fail;
13972 }
13973 {
13974 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13975 }
13976 return resultobj;
13977 fail:
13978 return NULL;
13979 }
13980
13981
13982 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13983 PyObject *resultobj;
13984 wxImage *arg1 = (wxImage *) 0 ;
13985 wxImageHistogram *arg2 = 0 ;
13986 unsigned long result;
13987 PyObject * obj0 = 0 ;
13988 PyObject * obj1 = 0 ;
13989 char *kwnames[] = {
13990 (char *) "self",(char *) "h", NULL
13991 };
13992
13993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13995 if (SWIG_arg_fail(1)) SWIG_fail;
13996 {
13997 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13998 if (SWIG_arg_fail(2)) SWIG_fail;
13999 if (arg2 == NULL) {
14000 SWIG_null_ref("wxImageHistogram");
14001 }
14002 if (SWIG_arg_fail(2)) SWIG_fail;
14003 }
14004 {
14005 PyThreadState* __tstate = wxPyBeginAllowThreads();
14006 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
14007
14008 wxPyEndAllowThreads(__tstate);
14009 if (PyErr_Occurred()) SWIG_fail;
14010 }
14011 {
14012 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
14013 }
14014 return resultobj;
14015 fail:
14016 return NULL;
14017 }
14018
14019
14020 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14021 PyObject *resultobj;
14022 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14023 PyObject * obj0 = 0 ;
14024 char *kwnames[] = {
14025 (char *) "handler", NULL
14026 };
14027
14028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
14029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14030 if (SWIG_arg_fail(1)) SWIG_fail;
14031 {
14032 PyThreadState* __tstate = wxPyBeginAllowThreads();
14033 wxImage::AddHandler(arg1);
14034
14035 wxPyEndAllowThreads(__tstate);
14036 if (PyErr_Occurred()) SWIG_fail;
14037 }
14038 Py_INCREF(Py_None); resultobj = Py_None;
14039 return resultobj;
14040 fail:
14041 return NULL;
14042 }
14043
14044
14045 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14046 PyObject *resultobj;
14047 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14048 PyObject * obj0 = 0 ;
14049 char *kwnames[] = {
14050 (char *) "handler", NULL
14051 };
14052
14053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
14054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
14055 if (SWIG_arg_fail(1)) SWIG_fail;
14056 {
14057 PyThreadState* __tstate = wxPyBeginAllowThreads();
14058 wxImage::InsertHandler(arg1);
14059
14060 wxPyEndAllowThreads(__tstate);
14061 if (PyErr_Occurred()) SWIG_fail;
14062 }
14063 Py_INCREF(Py_None); resultobj = Py_None;
14064 return resultobj;
14065 fail:
14066 return NULL;
14067 }
14068
14069
14070 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14071 PyObject *resultobj;
14072 wxString *arg1 = 0 ;
14073 bool result;
14074 bool temp1 = false ;
14075 PyObject * obj0 = 0 ;
14076 char *kwnames[] = {
14077 (char *) "name", NULL
14078 };
14079
14080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
14081 {
14082 arg1 = wxString_in_helper(obj0);
14083 if (arg1 == NULL) SWIG_fail;
14084 temp1 = true;
14085 }
14086 {
14087 PyThreadState* __tstate = wxPyBeginAllowThreads();
14088 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
14089
14090 wxPyEndAllowThreads(__tstate);
14091 if (PyErr_Occurred()) SWIG_fail;
14092 }
14093 {
14094 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14095 }
14096 {
14097 if (temp1)
14098 delete arg1;
14099 }
14100 return resultobj;
14101 fail:
14102 {
14103 if (temp1)
14104 delete arg1;
14105 }
14106 return NULL;
14107 }
14108
14109
14110 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
14111 PyObject *resultobj;
14112 wxString result;
14113 char *kwnames[] = {
14114 NULL
14115 };
14116
14117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
14118 {
14119 PyThreadState* __tstate = wxPyBeginAllowThreads();
14120 result = wxImage::GetImageExtWildcard();
14121
14122 wxPyEndAllowThreads(__tstate);
14123 if (PyErr_Occurred()) SWIG_fail;
14124 }
14125 {
14126 #if wxUSE_UNICODE
14127 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14128 #else
14129 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14130 #endif
14131 }
14132 return resultobj;
14133 fail:
14134 return NULL;
14135 }
14136
14137
14138 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14139 PyObject *resultobj;
14140 wxImage *arg1 = (wxImage *) 0 ;
14141 int arg2 = (int) -1 ;
14142 wxBitmap result;
14143 PyObject * obj0 = 0 ;
14144 PyObject * obj1 = 0 ;
14145 char *kwnames[] = {
14146 (char *) "self",(char *) "depth", NULL
14147 };
14148
14149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
14150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14151 if (SWIG_arg_fail(1)) SWIG_fail;
14152 if (obj1) {
14153 {
14154 arg2 = (int)(SWIG_As_int(obj1));
14155 if (SWIG_arg_fail(2)) SWIG_fail;
14156 }
14157 }
14158 {
14159 if (!wxPyCheckForApp()) SWIG_fail;
14160 PyThreadState* __tstate = wxPyBeginAllowThreads();
14161 result = wxImage_ConvertToBitmap(arg1,arg2);
14162
14163 wxPyEndAllowThreads(__tstate);
14164 if (PyErr_Occurred()) SWIG_fail;
14165 }
14166 {
14167 wxBitmap * resultptr;
14168 resultptr = new wxBitmap((wxBitmap &)(result));
14169 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14170 }
14171 return resultobj;
14172 fail:
14173 return NULL;
14174 }
14175
14176
14177 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
14178 PyObject *resultobj;
14179 wxImage *arg1 = (wxImage *) 0 ;
14180 byte arg2 ;
14181 byte arg3 ;
14182 byte arg4 ;
14183 wxBitmap result;
14184 PyObject * obj0 = 0 ;
14185 PyObject * obj1 = 0 ;
14186 PyObject * obj2 = 0 ;
14187 PyObject * obj3 = 0 ;
14188 char *kwnames[] = {
14189 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
14190 };
14191
14192 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14193 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14194 if (SWIG_arg_fail(1)) SWIG_fail;
14195 {
14196 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
14197 if (SWIG_arg_fail(2)) SWIG_fail;
14198 }
14199 {
14200 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
14201 if (SWIG_arg_fail(3)) SWIG_fail;
14202 }
14203 {
14204 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
14205 if (SWIG_arg_fail(4)) SWIG_fail;
14206 }
14207 {
14208 if (!wxPyCheckForApp()) SWIG_fail;
14209 PyThreadState* __tstate = wxPyBeginAllowThreads();
14210 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
14211
14212 wxPyEndAllowThreads(__tstate);
14213 if (PyErr_Occurred()) SWIG_fail;
14214 }
14215 {
14216 wxBitmap * resultptr;
14217 resultptr = new wxBitmap((wxBitmap &)(result));
14218 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
14219 }
14220 return resultobj;
14221 fail:
14222 return NULL;
14223 }
14224
14225
14226 static PyObject *_wrap_Image_RotateHue(PyObject *, PyObject *args, PyObject *kwargs) {
14227 PyObject *resultobj;
14228 wxImage *arg1 = (wxImage *) 0 ;
14229 double arg2 ;
14230 PyObject * obj0 = 0 ;
14231 PyObject * obj1 = 0 ;
14232 char *kwnames[] = {
14233 (char *) "self",(char *) "angle", NULL
14234 };
14235
14236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) goto fail;
14237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14238 if (SWIG_arg_fail(1)) SWIG_fail;
14239 {
14240 arg2 = (double)(SWIG_As_double(obj1));
14241 if (SWIG_arg_fail(2)) SWIG_fail;
14242 }
14243 {
14244 PyThreadState* __tstate = wxPyBeginAllowThreads();
14245 (arg1)->RotateHue(arg2);
14246
14247 wxPyEndAllowThreads(__tstate);
14248 if (PyErr_Occurred()) SWIG_fail;
14249 }
14250 Py_INCREF(Py_None); resultobj = Py_None;
14251 return resultobj;
14252 fail:
14253 return NULL;
14254 }
14255
14256
14257 static PyObject *_wrap_Image_RGBtoHSV(PyObject *, PyObject *args, PyObject *kwargs) {
14258 PyObject *resultobj;
14259 wxImage_RGBValue arg1 ;
14260 wxImage_HSVValue result;
14261 PyObject * obj0 = 0 ;
14262 char *kwnames[] = {
14263 (char *) "rgb", NULL
14264 };
14265
14266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) goto fail;
14267 {
14268 wxImage_RGBValue * argp;
14269 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_EXCEPTION);
14270 if (SWIG_arg_fail(1)) SWIG_fail;
14271 if (argp == NULL) {
14272 SWIG_null_ref("wxImage_RGBValue");
14273 }
14274 if (SWIG_arg_fail(1)) SWIG_fail;
14275 arg1 = *argp;
14276 }
14277 {
14278 PyThreadState* __tstate = wxPyBeginAllowThreads();
14279 result = wxImage::RGBtoHSV(arg1);
14280
14281 wxPyEndAllowThreads(__tstate);
14282 if (PyErr_Occurred()) SWIG_fail;
14283 }
14284 {
14285 wxImage_HSVValue * resultptr;
14286 resultptr = new wxImage_HSVValue((wxImage_HSVValue &)(result));
14287 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_HSVValue, 1);
14288 }
14289 return resultobj;
14290 fail:
14291 return NULL;
14292 }
14293
14294
14295 static PyObject *_wrap_Image_HSVtoRGB(PyObject *, PyObject *args, PyObject *kwargs) {
14296 PyObject *resultobj;
14297 wxImage_HSVValue arg1 ;
14298 wxImage_RGBValue result;
14299 PyObject * obj0 = 0 ;
14300 char *kwnames[] = {
14301 (char *) "hsv", NULL
14302 };
14303
14304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) goto fail;
14305 {
14306 wxImage_HSVValue * argp;
14307 SWIG_Python_ConvertPtr(obj0, (void **)&argp, SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_EXCEPTION);
14308 if (SWIG_arg_fail(1)) SWIG_fail;
14309 if (argp == NULL) {
14310 SWIG_null_ref("wxImage_HSVValue");
14311 }
14312 if (SWIG_arg_fail(1)) SWIG_fail;
14313 arg1 = *argp;
14314 }
14315 {
14316 PyThreadState* __tstate = wxPyBeginAllowThreads();
14317 result = wxImage::HSVtoRGB(arg1);
14318
14319 wxPyEndAllowThreads(__tstate);
14320 if (PyErr_Occurred()) SWIG_fail;
14321 }
14322 {
14323 wxImage_RGBValue * resultptr;
14324 resultptr = new wxImage_RGBValue((wxImage_RGBValue &)(result));
14325 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage_RGBValue, 1);
14326 }
14327 return resultobj;
14328 fail:
14329 return NULL;
14330 }
14331
14332
14333 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
14334 PyObject *obj;
14335 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14336 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
14337 Py_INCREF(obj);
14338 return Py_BuildValue((char *)"");
14339 }
14340 static int _wrap_NullImage_set(PyObject *) {
14341 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
14342 return 1;
14343 }
14344
14345
14346 static PyObject *_wrap_NullImage_get(void) {
14347 PyObject *pyobj;
14348
14349 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
14350 return pyobj;
14351 }
14352
14353
14354 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
14355 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
14356 return 1;
14357 }
14358
14359
14360 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
14361 PyObject *pyobj;
14362
14363 {
14364 #if wxUSE_UNICODE
14365 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14366 #else
14367 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
14368 #endif
14369 }
14370 return pyobj;
14371 }
14372
14373
14374 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
14375 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
14376 return 1;
14377 }
14378
14379
14380 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
14381 PyObject *pyobj;
14382
14383 {
14384 #if wxUSE_UNICODE
14385 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14386 #else
14387 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
14388 #endif
14389 }
14390 return pyobj;
14391 }
14392
14393
14394 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
14395 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
14396 return 1;
14397 }
14398
14399
14400 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
14401 PyObject *pyobj;
14402
14403 {
14404 #if wxUSE_UNICODE
14405 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14406 #else
14407 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
14408 #endif
14409 }
14410 return pyobj;
14411 }
14412
14413
14414 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
14415 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
14416 return 1;
14417 }
14418
14419
14420 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
14421 PyObject *pyobj;
14422
14423 {
14424 #if wxUSE_UNICODE
14425 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14426 #else
14427 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
14428 #endif
14429 }
14430 return pyobj;
14431 }
14432
14433
14434 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
14435 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
14436 return 1;
14437 }
14438
14439
14440 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
14441 PyObject *pyobj;
14442
14443 {
14444 #if wxUSE_UNICODE
14445 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14446 #else
14447 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
14448 #endif
14449 }
14450 return pyobj;
14451 }
14452
14453
14454 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
14455 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
14456 return 1;
14457 }
14458
14459
14460 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
14461 PyObject *pyobj;
14462
14463 {
14464 #if wxUSE_UNICODE
14465 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14466 #else
14467 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
14468 #endif
14469 }
14470 return pyobj;
14471 }
14472
14473
14474 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
14475 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
14476 return 1;
14477 }
14478
14479
14480 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
14481 PyObject *pyobj;
14482
14483 {
14484 #if wxUSE_UNICODE
14485 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14486 #else
14487 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
14488 #endif
14489 }
14490 return pyobj;
14491 }
14492
14493
14494 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
14495 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
14496 return 1;
14497 }
14498
14499
14500 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
14501 PyObject *pyobj;
14502
14503 {
14504 #if wxUSE_UNICODE
14505 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14506 #else
14507 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
14508 #endif
14509 }
14510 return pyobj;
14511 }
14512
14513
14514 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
14515 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
14516 return 1;
14517 }
14518
14519
14520 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14521 PyObject *pyobj;
14522
14523 {
14524 #if wxUSE_UNICODE
14525 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14526 #else
14527 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14528 #endif
14529 }
14530 return pyobj;
14531 }
14532
14533
14534 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14535 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14536 return 1;
14537 }
14538
14539
14540 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14541 PyObject *pyobj;
14542
14543 {
14544 #if wxUSE_UNICODE
14545 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14546 #else
14547 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14548 #endif
14549 }
14550 return pyobj;
14551 }
14552
14553
14554 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14555 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14556 return 1;
14557 }
14558
14559
14560 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14561 PyObject *pyobj;
14562
14563 {
14564 #if wxUSE_UNICODE
14565 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14566 #else
14567 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14568 #endif
14569 }
14570 return pyobj;
14571 }
14572
14573
14574 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14575 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14576 return 1;
14577 }
14578
14579
14580 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14581 PyObject *pyobj;
14582
14583 {
14584 #if wxUSE_UNICODE
14585 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14586 #else
14587 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14588 #endif
14589 }
14590 return pyobj;
14591 }
14592
14593
14594 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14595 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14596 return 1;
14597 }
14598
14599
14600 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14601 PyObject *pyobj;
14602
14603 {
14604 #if wxUSE_UNICODE
14605 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14606 #else
14607 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14608 #endif
14609 }
14610 return pyobj;
14611 }
14612
14613
14614 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14615 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14616 return 1;
14617 }
14618
14619
14620 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14621 PyObject *pyobj;
14622
14623 {
14624 #if wxUSE_UNICODE
14625 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14626 #else
14627 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14628 #endif
14629 }
14630 return pyobj;
14631 }
14632
14633
14634 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14635 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14636 return 1;
14637 }
14638
14639
14640 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14641 PyObject *pyobj;
14642
14643 {
14644 #if wxUSE_UNICODE
14645 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14646 #else
14647 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14648 #endif
14649 }
14650 return pyobj;
14651 }
14652
14653
14654 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14655 PyObject *resultobj;
14656 wxBMPHandler *result;
14657 char *kwnames[] = {
14658 NULL
14659 };
14660
14661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14662 {
14663 PyThreadState* __tstate = wxPyBeginAllowThreads();
14664 result = (wxBMPHandler *)new wxBMPHandler();
14665
14666 wxPyEndAllowThreads(__tstate);
14667 if (PyErr_Occurred()) SWIG_fail;
14668 }
14669 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14670 return resultobj;
14671 fail:
14672 return NULL;
14673 }
14674
14675
14676 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14677 PyObject *obj;
14678 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14679 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14680 Py_INCREF(obj);
14681 return Py_BuildValue((char *)"");
14682 }
14683 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14684 PyObject *resultobj;
14685 wxICOHandler *result;
14686 char *kwnames[] = {
14687 NULL
14688 };
14689
14690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14691 {
14692 PyThreadState* __tstate = wxPyBeginAllowThreads();
14693 result = (wxICOHandler *)new wxICOHandler();
14694
14695 wxPyEndAllowThreads(__tstate);
14696 if (PyErr_Occurred()) SWIG_fail;
14697 }
14698 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14699 return resultobj;
14700 fail:
14701 return NULL;
14702 }
14703
14704
14705 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14706 PyObject *obj;
14707 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14708 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14709 Py_INCREF(obj);
14710 return Py_BuildValue((char *)"");
14711 }
14712 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14713 PyObject *resultobj;
14714 wxCURHandler *result;
14715 char *kwnames[] = {
14716 NULL
14717 };
14718
14719 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14720 {
14721 PyThreadState* __tstate = wxPyBeginAllowThreads();
14722 result = (wxCURHandler *)new wxCURHandler();
14723
14724 wxPyEndAllowThreads(__tstate);
14725 if (PyErr_Occurred()) SWIG_fail;
14726 }
14727 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14728 return resultobj;
14729 fail:
14730 return NULL;
14731 }
14732
14733
14734 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14735 PyObject *obj;
14736 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14737 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14738 Py_INCREF(obj);
14739 return Py_BuildValue((char *)"");
14740 }
14741 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14742 PyObject *resultobj;
14743 wxANIHandler *result;
14744 char *kwnames[] = {
14745 NULL
14746 };
14747
14748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14749 {
14750 PyThreadState* __tstate = wxPyBeginAllowThreads();
14751 result = (wxANIHandler *)new wxANIHandler();
14752
14753 wxPyEndAllowThreads(__tstate);
14754 if (PyErr_Occurred()) SWIG_fail;
14755 }
14756 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14757 return resultobj;
14758 fail:
14759 return NULL;
14760 }
14761
14762
14763 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14764 PyObject *obj;
14765 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14766 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14767 Py_INCREF(obj);
14768 return Py_BuildValue((char *)"");
14769 }
14770 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14771 PyObject *resultobj;
14772 wxPNGHandler *result;
14773 char *kwnames[] = {
14774 NULL
14775 };
14776
14777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14778 {
14779 PyThreadState* __tstate = wxPyBeginAllowThreads();
14780 result = (wxPNGHandler *)new wxPNGHandler();
14781
14782 wxPyEndAllowThreads(__tstate);
14783 if (PyErr_Occurred()) SWIG_fail;
14784 }
14785 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14786 return resultobj;
14787 fail:
14788 return NULL;
14789 }
14790
14791
14792 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14793 PyObject *obj;
14794 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14795 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14796 Py_INCREF(obj);
14797 return Py_BuildValue((char *)"");
14798 }
14799 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14800 PyObject *resultobj;
14801 wxGIFHandler *result;
14802 char *kwnames[] = {
14803 NULL
14804 };
14805
14806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14807 {
14808 PyThreadState* __tstate = wxPyBeginAllowThreads();
14809 result = (wxGIFHandler *)new wxGIFHandler();
14810
14811 wxPyEndAllowThreads(__tstate);
14812 if (PyErr_Occurred()) SWIG_fail;
14813 }
14814 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14815 return resultobj;
14816 fail:
14817 return NULL;
14818 }
14819
14820
14821 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14822 PyObject *obj;
14823 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14824 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14825 Py_INCREF(obj);
14826 return Py_BuildValue((char *)"");
14827 }
14828 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14829 PyObject *resultobj;
14830 wxPCXHandler *result;
14831 char *kwnames[] = {
14832 NULL
14833 };
14834
14835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14836 {
14837 PyThreadState* __tstate = wxPyBeginAllowThreads();
14838 result = (wxPCXHandler *)new wxPCXHandler();
14839
14840 wxPyEndAllowThreads(__tstate);
14841 if (PyErr_Occurred()) SWIG_fail;
14842 }
14843 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14844 return resultobj;
14845 fail:
14846 return NULL;
14847 }
14848
14849
14850 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14851 PyObject *obj;
14852 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14853 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14854 Py_INCREF(obj);
14855 return Py_BuildValue((char *)"");
14856 }
14857 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14858 PyObject *resultobj;
14859 wxJPEGHandler *result;
14860 char *kwnames[] = {
14861 NULL
14862 };
14863
14864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14865 {
14866 PyThreadState* __tstate = wxPyBeginAllowThreads();
14867 result = (wxJPEGHandler *)new wxJPEGHandler();
14868
14869 wxPyEndAllowThreads(__tstate);
14870 if (PyErr_Occurred()) SWIG_fail;
14871 }
14872 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14873 return resultobj;
14874 fail:
14875 return NULL;
14876 }
14877
14878
14879 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14880 PyObject *obj;
14881 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14882 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14883 Py_INCREF(obj);
14884 return Py_BuildValue((char *)"");
14885 }
14886 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14887 PyObject *resultobj;
14888 wxPNMHandler *result;
14889 char *kwnames[] = {
14890 NULL
14891 };
14892
14893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14894 {
14895 PyThreadState* __tstate = wxPyBeginAllowThreads();
14896 result = (wxPNMHandler *)new wxPNMHandler();
14897
14898 wxPyEndAllowThreads(__tstate);
14899 if (PyErr_Occurred()) SWIG_fail;
14900 }
14901 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14902 return resultobj;
14903 fail:
14904 return NULL;
14905 }
14906
14907
14908 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
14909 PyObject *obj;
14910 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14911 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14912 Py_INCREF(obj);
14913 return Py_BuildValue((char *)"");
14914 }
14915 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14916 PyObject *resultobj;
14917 wxXPMHandler *result;
14918 char *kwnames[] = {
14919 NULL
14920 };
14921
14922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
14923 {
14924 PyThreadState* __tstate = wxPyBeginAllowThreads();
14925 result = (wxXPMHandler *)new wxXPMHandler();
14926
14927 wxPyEndAllowThreads(__tstate);
14928 if (PyErr_Occurred()) SWIG_fail;
14929 }
14930 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
14931 return resultobj;
14932 fail:
14933 return NULL;
14934 }
14935
14936
14937 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
14938 PyObject *obj;
14939 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14940 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
14941 Py_INCREF(obj);
14942 return Py_BuildValue((char *)"");
14943 }
14944 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14945 PyObject *resultobj;
14946 wxTIFFHandler *result;
14947 char *kwnames[] = {
14948 NULL
14949 };
14950
14951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14952 {
14953 PyThreadState* __tstate = wxPyBeginAllowThreads();
14954 result = (wxTIFFHandler *)new wxTIFFHandler();
14955
14956 wxPyEndAllowThreads(__tstate);
14957 if (PyErr_Occurred()) SWIG_fail;
14958 }
14959 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14960 return resultobj;
14961 fail:
14962 return NULL;
14963 }
14964
14965
14966 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14967 PyObject *obj;
14968 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14969 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14970 Py_INCREF(obj);
14971 return Py_BuildValue((char *)"");
14972 }
14973 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14974 PyObject *resultobj;
14975 wxImage *arg1 = 0 ;
14976 wxImage *arg2 = 0 ;
14977 int arg3 = (int) 236 ;
14978 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14979 bool result;
14980 PyObject * obj0 = 0 ;
14981 PyObject * obj1 = 0 ;
14982 PyObject * obj2 = 0 ;
14983 PyObject * obj3 = 0 ;
14984 char *kwnames[] = {
14985 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14986 };
14987
14988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14989 {
14990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14991 if (SWIG_arg_fail(1)) SWIG_fail;
14992 if (arg1 == NULL) {
14993 SWIG_null_ref("wxImage");
14994 }
14995 if (SWIG_arg_fail(1)) SWIG_fail;
14996 }
14997 {
14998 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14999 if (SWIG_arg_fail(2)) SWIG_fail;
15000 if (arg2 == NULL) {
15001 SWIG_null_ref("wxImage");
15002 }
15003 if (SWIG_arg_fail(2)) SWIG_fail;
15004 }
15005 if (obj2) {
15006 {
15007 arg3 = (int)(SWIG_As_int(obj2));
15008 if (SWIG_arg_fail(3)) SWIG_fail;
15009 }
15010 }
15011 if (obj3) {
15012 {
15013 arg4 = (int)(SWIG_As_int(obj3));
15014 if (SWIG_arg_fail(4)) SWIG_fail;
15015 }
15016 }
15017 {
15018 PyThreadState* __tstate = wxPyBeginAllowThreads();
15019 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
15020
15021 wxPyEndAllowThreads(__tstate);
15022 if (PyErr_Occurred()) SWIG_fail;
15023 }
15024 {
15025 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15026 }
15027 return resultobj;
15028 fail:
15029 return NULL;
15030 }
15031
15032
15033 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
15034 PyObject *obj;
15035 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15036 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
15037 Py_INCREF(obj);
15038 return Py_BuildValue((char *)"");
15039 }
15040 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15041 PyObject *resultobj;
15042 wxEvtHandler *result;
15043 char *kwnames[] = {
15044 NULL
15045 };
15046
15047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
15048 {
15049 PyThreadState* __tstate = wxPyBeginAllowThreads();
15050 result = (wxEvtHandler *)new wxEvtHandler();
15051
15052 wxPyEndAllowThreads(__tstate);
15053 if (PyErr_Occurred()) SWIG_fail;
15054 }
15055 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
15056 return resultobj;
15057 fail:
15058 return NULL;
15059 }
15060
15061
15062 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15063 PyObject *resultobj;
15064 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15065 wxEvtHandler *result;
15066 PyObject * obj0 = 0 ;
15067 char *kwnames[] = {
15068 (char *) "self", NULL
15069 };
15070
15071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
15072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15073 if (SWIG_arg_fail(1)) SWIG_fail;
15074 {
15075 PyThreadState* __tstate = wxPyBeginAllowThreads();
15076 result = (wxEvtHandler *)(arg1)->GetNextHandler();
15077
15078 wxPyEndAllowThreads(__tstate);
15079 if (PyErr_Occurred()) SWIG_fail;
15080 }
15081 {
15082 resultobj = wxPyMake_wxObject(result, 0);
15083 }
15084 return resultobj;
15085 fail:
15086 return NULL;
15087 }
15088
15089
15090 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15091 PyObject *resultobj;
15092 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15093 wxEvtHandler *result;
15094 PyObject * obj0 = 0 ;
15095 char *kwnames[] = {
15096 (char *) "self", NULL
15097 };
15098
15099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
15100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15101 if (SWIG_arg_fail(1)) SWIG_fail;
15102 {
15103 PyThreadState* __tstate = wxPyBeginAllowThreads();
15104 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
15105
15106 wxPyEndAllowThreads(__tstate);
15107 if (PyErr_Occurred()) SWIG_fail;
15108 }
15109 {
15110 resultobj = wxPyMake_wxObject(result, 0);
15111 }
15112 return resultobj;
15113 fail:
15114 return NULL;
15115 }
15116
15117
15118 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15119 PyObject *resultobj;
15120 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15121 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15122 PyObject * obj0 = 0 ;
15123 PyObject * obj1 = 0 ;
15124 char *kwnames[] = {
15125 (char *) "self",(char *) "handler", NULL
15126 };
15127
15128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
15129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15130 if (SWIG_arg_fail(1)) SWIG_fail;
15131 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15132 if (SWIG_arg_fail(2)) SWIG_fail;
15133 {
15134 PyThreadState* __tstate = wxPyBeginAllowThreads();
15135 (arg1)->SetNextHandler(arg2);
15136
15137 wxPyEndAllowThreads(__tstate);
15138 if (PyErr_Occurred()) SWIG_fail;
15139 }
15140 Py_INCREF(Py_None); resultobj = Py_None;
15141 return resultobj;
15142 fail:
15143 return NULL;
15144 }
15145
15146
15147 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
15148 PyObject *resultobj;
15149 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15150 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
15151 PyObject * obj0 = 0 ;
15152 PyObject * obj1 = 0 ;
15153 char *kwnames[] = {
15154 (char *) "self",(char *) "handler", NULL
15155 };
15156
15157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
15158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15159 if (SWIG_arg_fail(1)) SWIG_fail;
15160 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15161 if (SWIG_arg_fail(2)) SWIG_fail;
15162 {
15163 PyThreadState* __tstate = wxPyBeginAllowThreads();
15164 (arg1)->SetPreviousHandler(arg2);
15165
15166 wxPyEndAllowThreads(__tstate);
15167 if (PyErr_Occurred()) SWIG_fail;
15168 }
15169 Py_INCREF(Py_None); resultobj = Py_None;
15170 return resultobj;
15171 fail:
15172 return NULL;
15173 }
15174
15175
15176 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15177 PyObject *resultobj;
15178 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15179 bool result;
15180 PyObject * obj0 = 0 ;
15181 char *kwnames[] = {
15182 (char *) "self", NULL
15183 };
15184
15185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
15186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15187 if (SWIG_arg_fail(1)) SWIG_fail;
15188 {
15189 PyThreadState* __tstate = wxPyBeginAllowThreads();
15190 result = (bool)(arg1)->GetEvtHandlerEnabled();
15191
15192 wxPyEndAllowThreads(__tstate);
15193 if (PyErr_Occurred()) SWIG_fail;
15194 }
15195 {
15196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15197 }
15198 return resultobj;
15199 fail:
15200 return NULL;
15201 }
15202
15203
15204 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
15205 PyObject *resultobj;
15206 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15207 bool arg2 ;
15208 PyObject * obj0 = 0 ;
15209 PyObject * obj1 = 0 ;
15210 char *kwnames[] = {
15211 (char *) "self",(char *) "enabled", NULL
15212 };
15213
15214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
15215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15216 if (SWIG_arg_fail(1)) SWIG_fail;
15217 {
15218 arg2 = (bool)(SWIG_As_bool(obj1));
15219 if (SWIG_arg_fail(2)) SWIG_fail;
15220 }
15221 {
15222 PyThreadState* __tstate = wxPyBeginAllowThreads();
15223 (arg1)->SetEvtHandlerEnabled(arg2);
15224
15225 wxPyEndAllowThreads(__tstate);
15226 if (PyErr_Occurred()) SWIG_fail;
15227 }
15228 Py_INCREF(Py_None); resultobj = Py_None;
15229 return resultobj;
15230 fail:
15231 return NULL;
15232 }
15233
15234
15235 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15236 PyObject *resultobj;
15237 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15238 wxEvent *arg2 = 0 ;
15239 bool result;
15240 PyObject * obj0 = 0 ;
15241 PyObject * obj1 = 0 ;
15242 char *kwnames[] = {
15243 (char *) "self",(char *) "event", NULL
15244 };
15245
15246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
15247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15248 if (SWIG_arg_fail(1)) SWIG_fail;
15249 {
15250 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15251 if (SWIG_arg_fail(2)) SWIG_fail;
15252 if (arg2 == NULL) {
15253 SWIG_null_ref("wxEvent");
15254 }
15255 if (SWIG_arg_fail(2)) SWIG_fail;
15256 }
15257 {
15258 PyThreadState* __tstate = wxPyBeginAllowThreads();
15259 result = (bool)(arg1)->ProcessEvent(*arg2);
15260
15261 wxPyEndAllowThreads(__tstate);
15262 if (PyErr_Occurred()) SWIG_fail;
15263 }
15264 {
15265 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15266 }
15267 return resultobj;
15268 fail:
15269 return NULL;
15270 }
15271
15272
15273 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15274 PyObject *resultobj;
15275 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15276 wxEvent *arg2 = 0 ;
15277 PyObject * obj0 = 0 ;
15278 PyObject * obj1 = 0 ;
15279 char *kwnames[] = {
15280 (char *) "self",(char *) "event", NULL
15281 };
15282
15283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
15284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15285 if (SWIG_arg_fail(1)) SWIG_fail;
15286 {
15287 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15288 if (SWIG_arg_fail(2)) SWIG_fail;
15289 if (arg2 == NULL) {
15290 SWIG_null_ref("wxEvent");
15291 }
15292 if (SWIG_arg_fail(2)) SWIG_fail;
15293 }
15294 {
15295 PyThreadState* __tstate = wxPyBeginAllowThreads();
15296 (arg1)->AddPendingEvent(*arg2);
15297
15298 wxPyEndAllowThreads(__tstate);
15299 if (PyErr_Occurred()) SWIG_fail;
15300 }
15301 Py_INCREF(Py_None); resultobj = Py_None;
15302 return resultobj;
15303 fail:
15304 return NULL;
15305 }
15306
15307
15308 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
15309 PyObject *resultobj;
15310 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15311 PyObject * obj0 = 0 ;
15312 char *kwnames[] = {
15313 (char *) "self", NULL
15314 };
15315
15316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
15317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15318 if (SWIG_arg_fail(1)) SWIG_fail;
15319 {
15320 PyThreadState* __tstate = wxPyBeginAllowThreads();
15321 (arg1)->ProcessPendingEvents();
15322
15323 wxPyEndAllowThreads(__tstate);
15324 if (PyErr_Occurred()) SWIG_fail;
15325 }
15326 Py_INCREF(Py_None); resultobj = Py_None;
15327 return resultobj;
15328 fail:
15329 return NULL;
15330 }
15331
15332
15333 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
15334 PyObject *resultobj;
15335 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15336 int arg2 ;
15337 int arg3 ;
15338 int arg4 ;
15339 PyObject *arg5 = (PyObject *) 0 ;
15340 PyObject * obj0 = 0 ;
15341 PyObject * obj1 = 0 ;
15342 PyObject * obj2 = 0 ;
15343 PyObject * obj3 = 0 ;
15344 PyObject * obj4 = 0 ;
15345 char *kwnames[] = {
15346 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
15347 };
15348
15349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
15350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15351 if (SWIG_arg_fail(1)) SWIG_fail;
15352 {
15353 arg2 = (int)(SWIG_As_int(obj1));
15354 if (SWIG_arg_fail(2)) SWIG_fail;
15355 }
15356 {
15357 arg3 = (int)(SWIG_As_int(obj2));
15358 if (SWIG_arg_fail(3)) SWIG_fail;
15359 }
15360 {
15361 arg4 = (int)(SWIG_As_int(obj3));
15362 if (SWIG_arg_fail(4)) SWIG_fail;
15363 }
15364 arg5 = obj4;
15365 {
15366 PyThreadState* __tstate = wxPyBeginAllowThreads();
15367 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
15368
15369 wxPyEndAllowThreads(__tstate);
15370 if (PyErr_Occurred()) SWIG_fail;
15371 }
15372 Py_INCREF(Py_None); resultobj = Py_None;
15373 return resultobj;
15374 fail:
15375 return NULL;
15376 }
15377
15378
15379 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
15380 PyObject *resultobj;
15381 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15382 int arg2 ;
15383 int arg3 = (int) -1 ;
15384 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
15385 bool result;
15386 PyObject * obj0 = 0 ;
15387 PyObject * obj1 = 0 ;
15388 PyObject * obj2 = 0 ;
15389 PyObject * obj3 = 0 ;
15390 char *kwnames[] = {
15391 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
15392 };
15393
15394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
15395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15396 if (SWIG_arg_fail(1)) SWIG_fail;
15397 {
15398 arg2 = (int)(SWIG_As_int(obj1));
15399 if (SWIG_arg_fail(2)) SWIG_fail;
15400 }
15401 if (obj2) {
15402 {
15403 arg3 = (int)(SWIG_As_int(obj2));
15404 if (SWIG_arg_fail(3)) SWIG_fail;
15405 }
15406 }
15407 if (obj3) {
15408 {
15409 arg4 = (wxEventType)(SWIG_As_int(obj3));
15410 if (SWIG_arg_fail(4)) SWIG_fail;
15411 }
15412 }
15413 {
15414 PyThreadState* __tstate = wxPyBeginAllowThreads();
15415 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
15416
15417 wxPyEndAllowThreads(__tstate);
15418 if (PyErr_Occurred()) SWIG_fail;
15419 }
15420 {
15421 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15422 }
15423 return resultobj;
15424 fail:
15425 return NULL;
15426 }
15427
15428
15429 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
15430 PyObject *resultobj;
15431 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
15432 PyObject *arg2 = (PyObject *) 0 ;
15433 bool arg3 = (bool) true ;
15434 PyObject * obj0 = 0 ;
15435 PyObject * obj1 = 0 ;
15436 PyObject * obj2 = 0 ;
15437 char *kwnames[] = {
15438 (char *) "self",(char *) "_self",(char *) "incref", NULL
15439 };
15440
15441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
15442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
15443 if (SWIG_arg_fail(1)) SWIG_fail;
15444 arg2 = obj1;
15445 if (obj2) {
15446 {
15447 arg3 = (bool)(SWIG_As_bool(obj2));
15448 if (SWIG_arg_fail(3)) SWIG_fail;
15449 }
15450 }
15451 {
15452 PyThreadState* __tstate = wxPyBeginAllowThreads();
15453 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
15454
15455 wxPyEndAllowThreads(__tstate);
15456 if (PyErr_Occurred()) SWIG_fail;
15457 }
15458 Py_INCREF(Py_None); resultobj = Py_None;
15459 return resultobj;
15460 fail:
15461 return NULL;
15462 }
15463
15464
15465 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
15466 PyObject *obj;
15467 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15468 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
15469 Py_INCREF(obj);
15470 return Py_BuildValue((char *)"");
15471 }
15472 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15473 PyObject *resultobj;
15474 wxEventType result;
15475 char *kwnames[] = {
15476 NULL
15477 };
15478
15479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
15480 {
15481 PyThreadState* __tstate = wxPyBeginAllowThreads();
15482 result = (wxEventType)wxNewEventType();
15483
15484 wxPyEndAllowThreads(__tstate);
15485 if (PyErr_Occurred()) SWIG_fail;
15486 }
15487 {
15488 resultobj = SWIG_From_int((int)(result));
15489 }
15490 return resultobj;
15491 fail:
15492 return NULL;
15493 }
15494
15495
15496 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
15497 PyObject *resultobj;
15498 wxEvent *arg1 = (wxEvent *) 0 ;
15499 PyObject * obj0 = 0 ;
15500 char *kwnames[] = {
15501 (char *) "self", NULL
15502 };
15503
15504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
15505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15506 if (SWIG_arg_fail(1)) SWIG_fail;
15507 {
15508 PyThreadState* __tstate = wxPyBeginAllowThreads();
15509 delete arg1;
15510
15511 wxPyEndAllowThreads(__tstate);
15512 if (PyErr_Occurred()) SWIG_fail;
15513 }
15514 Py_INCREF(Py_None); resultobj = Py_None;
15515 return resultobj;
15516 fail:
15517 return NULL;
15518 }
15519
15520
15521 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15522 PyObject *resultobj;
15523 wxEvent *arg1 = (wxEvent *) 0 ;
15524 wxEventType arg2 ;
15525 PyObject * obj0 = 0 ;
15526 PyObject * obj1 = 0 ;
15527 char *kwnames[] = {
15528 (char *) "self",(char *) "typ", NULL
15529 };
15530
15531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15533 if (SWIG_arg_fail(1)) SWIG_fail;
15534 {
15535 arg2 = (wxEventType)(SWIG_As_int(obj1));
15536 if (SWIG_arg_fail(2)) SWIG_fail;
15537 }
15538 {
15539 PyThreadState* __tstate = wxPyBeginAllowThreads();
15540 (arg1)->SetEventType(arg2);
15541
15542 wxPyEndAllowThreads(__tstate);
15543 if (PyErr_Occurred()) SWIG_fail;
15544 }
15545 Py_INCREF(Py_None); resultobj = Py_None;
15546 return resultobj;
15547 fail:
15548 return NULL;
15549 }
15550
15551
15552 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15553 PyObject *resultobj;
15554 wxEvent *arg1 = (wxEvent *) 0 ;
15555 wxEventType result;
15556 PyObject * obj0 = 0 ;
15557 char *kwnames[] = {
15558 (char *) "self", NULL
15559 };
15560
15561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15563 if (SWIG_arg_fail(1)) SWIG_fail;
15564 {
15565 PyThreadState* __tstate = wxPyBeginAllowThreads();
15566 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15567
15568 wxPyEndAllowThreads(__tstate);
15569 if (PyErr_Occurred()) SWIG_fail;
15570 }
15571 {
15572 resultobj = SWIG_From_int((int)(result));
15573 }
15574 return resultobj;
15575 fail:
15576 return NULL;
15577 }
15578
15579
15580 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15581 PyObject *resultobj;
15582 wxEvent *arg1 = (wxEvent *) 0 ;
15583 wxObject *result;
15584 PyObject * obj0 = 0 ;
15585 char *kwnames[] = {
15586 (char *) "self", NULL
15587 };
15588
15589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15591 if (SWIG_arg_fail(1)) SWIG_fail;
15592 {
15593 PyThreadState* __tstate = wxPyBeginAllowThreads();
15594 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15595
15596 wxPyEndAllowThreads(__tstate);
15597 if (PyErr_Occurred()) SWIG_fail;
15598 }
15599 {
15600 resultobj = wxPyMake_wxObject(result, 0);
15601 }
15602 return resultobj;
15603 fail:
15604 return NULL;
15605 }
15606
15607
15608 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15609 PyObject *resultobj;
15610 wxEvent *arg1 = (wxEvent *) 0 ;
15611 wxObject *arg2 = (wxObject *) 0 ;
15612 PyObject * obj0 = 0 ;
15613 PyObject * obj1 = 0 ;
15614 char *kwnames[] = {
15615 (char *) "self",(char *) "obj", NULL
15616 };
15617
15618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15620 if (SWIG_arg_fail(1)) SWIG_fail;
15621 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15622 if (SWIG_arg_fail(2)) SWIG_fail;
15623 {
15624 PyThreadState* __tstate = wxPyBeginAllowThreads();
15625 (arg1)->SetEventObject(arg2);
15626
15627 wxPyEndAllowThreads(__tstate);
15628 if (PyErr_Occurred()) SWIG_fail;
15629 }
15630 Py_INCREF(Py_None); resultobj = Py_None;
15631 return resultobj;
15632 fail:
15633 return NULL;
15634 }
15635
15636
15637 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15638 PyObject *resultobj;
15639 wxEvent *arg1 = (wxEvent *) 0 ;
15640 long result;
15641 PyObject * obj0 = 0 ;
15642 char *kwnames[] = {
15643 (char *) "self", NULL
15644 };
15645
15646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15648 if (SWIG_arg_fail(1)) SWIG_fail;
15649 {
15650 PyThreadState* __tstate = wxPyBeginAllowThreads();
15651 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15652
15653 wxPyEndAllowThreads(__tstate);
15654 if (PyErr_Occurred()) SWIG_fail;
15655 }
15656 {
15657 resultobj = SWIG_From_long((long)(result));
15658 }
15659 return resultobj;
15660 fail:
15661 return NULL;
15662 }
15663
15664
15665 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15666 PyObject *resultobj;
15667 wxEvent *arg1 = (wxEvent *) 0 ;
15668 long arg2 = (long) 0 ;
15669 PyObject * obj0 = 0 ;
15670 PyObject * obj1 = 0 ;
15671 char *kwnames[] = {
15672 (char *) "self",(char *) "ts", NULL
15673 };
15674
15675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15677 if (SWIG_arg_fail(1)) SWIG_fail;
15678 if (obj1) {
15679 {
15680 arg2 = (long)(SWIG_As_long(obj1));
15681 if (SWIG_arg_fail(2)) SWIG_fail;
15682 }
15683 }
15684 {
15685 PyThreadState* __tstate = wxPyBeginAllowThreads();
15686 (arg1)->SetTimestamp(arg2);
15687
15688 wxPyEndAllowThreads(__tstate);
15689 if (PyErr_Occurred()) SWIG_fail;
15690 }
15691 Py_INCREF(Py_None); resultobj = Py_None;
15692 return resultobj;
15693 fail:
15694 return NULL;
15695 }
15696
15697
15698 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15699 PyObject *resultobj;
15700 wxEvent *arg1 = (wxEvent *) 0 ;
15701 int result;
15702 PyObject * obj0 = 0 ;
15703 char *kwnames[] = {
15704 (char *) "self", NULL
15705 };
15706
15707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15709 if (SWIG_arg_fail(1)) SWIG_fail;
15710 {
15711 PyThreadState* __tstate = wxPyBeginAllowThreads();
15712 result = (int)((wxEvent const *)arg1)->GetId();
15713
15714 wxPyEndAllowThreads(__tstate);
15715 if (PyErr_Occurred()) SWIG_fail;
15716 }
15717 {
15718 resultobj = SWIG_From_int((int)(result));
15719 }
15720 return resultobj;
15721 fail:
15722 return NULL;
15723 }
15724
15725
15726 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15727 PyObject *resultobj;
15728 wxEvent *arg1 = (wxEvent *) 0 ;
15729 int arg2 ;
15730 PyObject * obj0 = 0 ;
15731 PyObject * obj1 = 0 ;
15732 char *kwnames[] = {
15733 (char *) "self",(char *) "Id", NULL
15734 };
15735
15736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15738 if (SWIG_arg_fail(1)) SWIG_fail;
15739 {
15740 arg2 = (int)(SWIG_As_int(obj1));
15741 if (SWIG_arg_fail(2)) SWIG_fail;
15742 }
15743 {
15744 PyThreadState* __tstate = wxPyBeginAllowThreads();
15745 (arg1)->SetId(arg2);
15746
15747 wxPyEndAllowThreads(__tstate);
15748 if (PyErr_Occurred()) SWIG_fail;
15749 }
15750 Py_INCREF(Py_None); resultobj = Py_None;
15751 return resultobj;
15752 fail:
15753 return NULL;
15754 }
15755
15756
15757 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15758 PyObject *resultobj;
15759 wxEvent *arg1 = (wxEvent *) 0 ;
15760 bool result;
15761 PyObject * obj0 = 0 ;
15762 char *kwnames[] = {
15763 (char *) "self", NULL
15764 };
15765
15766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15768 if (SWIG_arg_fail(1)) SWIG_fail;
15769 {
15770 PyThreadState* __tstate = wxPyBeginAllowThreads();
15771 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15772
15773 wxPyEndAllowThreads(__tstate);
15774 if (PyErr_Occurred()) SWIG_fail;
15775 }
15776 {
15777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15778 }
15779 return resultobj;
15780 fail:
15781 return NULL;
15782 }
15783
15784
15785 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15786 PyObject *resultobj;
15787 wxEvent *arg1 = (wxEvent *) 0 ;
15788 bool arg2 = (bool) true ;
15789 PyObject * obj0 = 0 ;
15790 PyObject * obj1 = 0 ;
15791 char *kwnames[] = {
15792 (char *) "self",(char *) "skip", NULL
15793 };
15794
15795 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15796 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15797 if (SWIG_arg_fail(1)) SWIG_fail;
15798 if (obj1) {
15799 {
15800 arg2 = (bool)(SWIG_As_bool(obj1));
15801 if (SWIG_arg_fail(2)) SWIG_fail;
15802 }
15803 }
15804 {
15805 PyThreadState* __tstate = wxPyBeginAllowThreads();
15806 (arg1)->Skip(arg2);
15807
15808 wxPyEndAllowThreads(__tstate);
15809 if (PyErr_Occurred()) SWIG_fail;
15810 }
15811 Py_INCREF(Py_None); resultobj = Py_None;
15812 return resultobj;
15813 fail:
15814 return NULL;
15815 }
15816
15817
15818 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15819 PyObject *resultobj;
15820 wxEvent *arg1 = (wxEvent *) 0 ;
15821 bool result;
15822 PyObject * obj0 = 0 ;
15823 char *kwnames[] = {
15824 (char *) "self", NULL
15825 };
15826
15827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15829 if (SWIG_arg_fail(1)) SWIG_fail;
15830 {
15831 PyThreadState* __tstate = wxPyBeginAllowThreads();
15832 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15833
15834 wxPyEndAllowThreads(__tstate);
15835 if (PyErr_Occurred()) SWIG_fail;
15836 }
15837 {
15838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15839 }
15840 return resultobj;
15841 fail:
15842 return NULL;
15843 }
15844
15845
15846 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15847 PyObject *resultobj;
15848 wxEvent *arg1 = (wxEvent *) 0 ;
15849 bool result;
15850 PyObject * obj0 = 0 ;
15851 char *kwnames[] = {
15852 (char *) "self", NULL
15853 };
15854
15855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15857 if (SWIG_arg_fail(1)) SWIG_fail;
15858 {
15859 PyThreadState* __tstate = wxPyBeginAllowThreads();
15860 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15861
15862 wxPyEndAllowThreads(__tstate);
15863 if (PyErr_Occurred()) SWIG_fail;
15864 }
15865 {
15866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15867 }
15868 return resultobj;
15869 fail:
15870 return NULL;
15871 }
15872
15873
15874 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15875 PyObject *resultobj;
15876 wxEvent *arg1 = (wxEvent *) 0 ;
15877 int result;
15878 PyObject * obj0 = 0 ;
15879 char *kwnames[] = {
15880 (char *) "self", NULL
15881 };
15882
15883 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15884 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15885 if (SWIG_arg_fail(1)) SWIG_fail;
15886 {
15887 PyThreadState* __tstate = wxPyBeginAllowThreads();
15888 result = (int)(arg1)->StopPropagation();
15889
15890 wxPyEndAllowThreads(__tstate);
15891 if (PyErr_Occurred()) SWIG_fail;
15892 }
15893 {
15894 resultobj = SWIG_From_int((int)(result));
15895 }
15896 return resultobj;
15897 fail:
15898 return NULL;
15899 }
15900
15901
15902 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15903 PyObject *resultobj;
15904 wxEvent *arg1 = (wxEvent *) 0 ;
15905 int arg2 ;
15906 PyObject * obj0 = 0 ;
15907 PyObject * obj1 = 0 ;
15908 char *kwnames[] = {
15909 (char *) "self",(char *) "propagationLevel", NULL
15910 };
15911
15912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15914 if (SWIG_arg_fail(1)) SWIG_fail;
15915 {
15916 arg2 = (int)(SWIG_As_int(obj1));
15917 if (SWIG_arg_fail(2)) SWIG_fail;
15918 }
15919 {
15920 PyThreadState* __tstate = wxPyBeginAllowThreads();
15921 (arg1)->ResumePropagation(arg2);
15922
15923 wxPyEndAllowThreads(__tstate);
15924 if (PyErr_Occurred()) SWIG_fail;
15925 }
15926 Py_INCREF(Py_None); resultobj = Py_None;
15927 return resultobj;
15928 fail:
15929 return NULL;
15930 }
15931
15932
15933 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15934 PyObject *resultobj;
15935 wxEvent *arg1 = (wxEvent *) 0 ;
15936 wxEvent *result;
15937 PyObject * obj0 = 0 ;
15938 char *kwnames[] = {
15939 (char *) "self", NULL
15940 };
15941
15942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
15943 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15944 if (SWIG_arg_fail(1)) SWIG_fail;
15945 {
15946 PyThreadState* __tstate = wxPyBeginAllowThreads();
15947 result = (wxEvent *)(arg1)->Clone();
15948
15949 wxPyEndAllowThreads(__tstate);
15950 if (PyErr_Occurred()) SWIG_fail;
15951 }
15952 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15953 return resultobj;
15954 fail:
15955 return NULL;
15956 }
15957
15958
15959 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
15960 PyObject *obj;
15961 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15962 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15963 Py_INCREF(obj);
15964 return Py_BuildValue((char *)"");
15965 }
15966 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15967 PyObject *resultobj;
15968 wxEvent *arg1 = 0 ;
15969 wxPropagationDisabler *result;
15970 PyObject * obj0 = 0 ;
15971 char *kwnames[] = {
15972 (char *) "event", NULL
15973 };
15974
15975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15976 {
15977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15978 if (SWIG_arg_fail(1)) SWIG_fail;
15979 if (arg1 == NULL) {
15980 SWIG_null_ref("wxEvent");
15981 }
15982 if (SWIG_arg_fail(1)) SWIG_fail;
15983 }
15984 {
15985 PyThreadState* __tstate = wxPyBeginAllowThreads();
15986 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15987
15988 wxPyEndAllowThreads(__tstate);
15989 if (PyErr_Occurred()) SWIG_fail;
15990 }
15991 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15992 return resultobj;
15993 fail:
15994 return NULL;
15995 }
15996
15997
15998 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15999 PyObject *resultobj;
16000 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
16001 PyObject * obj0 = 0 ;
16002 char *kwnames[] = {
16003 (char *) "self", NULL
16004 };
16005
16006 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
16007 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
16008 if (SWIG_arg_fail(1)) SWIG_fail;
16009 {
16010 PyThreadState* __tstate = wxPyBeginAllowThreads();
16011 delete arg1;
16012
16013 wxPyEndAllowThreads(__tstate);
16014 if (PyErr_Occurred()) SWIG_fail;
16015 }
16016 Py_INCREF(Py_None); resultobj = Py_None;
16017 return resultobj;
16018 fail:
16019 return NULL;
16020 }
16021
16022
16023 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
16024 PyObject *obj;
16025 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16026 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
16027 Py_INCREF(obj);
16028 return Py_BuildValue((char *)"");
16029 }
16030 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16031 PyObject *resultobj;
16032 wxEvent *arg1 = 0 ;
16033 wxPropagateOnce *result;
16034 PyObject * obj0 = 0 ;
16035 char *kwnames[] = {
16036 (char *) "event", NULL
16037 };
16038
16039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
16040 {
16041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
16042 if (SWIG_arg_fail(1)) SWIG_fail;
16043 if (arg1 == NULL) {
16044 SWIG_null_ref("wxEvent");
16045 }
16046 if (SWIG_arg_fail(1)) SWIG_fail;
16047 }
16048 {
16049 PyThreadState* __tstate = wxPyBeginAllowThreads();
16050 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
16051
16052 wxPyEndAllowThreads(__tstate);
16053 if (PyErr_Occurred()) SWIG_fail;
16054 }
16055 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
16056 return resultobj;
16057 fail:
16058 return NULL;
16059 }
16060
16061
16062 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
16063 PyObject *resultobj;
16064 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
16065 PyObject * obj0 = 0 ;
16066 char *kwnames[] = {
16067 (char *) "self", NULL
16068 };
16069
16070 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
16071 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
16072 if (SWIG_arg_fail(1)) SWIG_fail;
16073 {
16074 PyThreadState* __tstate = wxPyBeginAllowThreads();
16075 delete arg1;
16076
16077 wxPyEndAllowThreads(__tstate);
16078 if (PyErr_Occurred()) SWIG_fail;
16079 }
16080 Py_INCREF(Py_None); resultobj = Py_None;
16081 return resultobj;
16082 fail:
16083 return NULL;
16084 }
16085
16086
16087 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
16088 PyObject *obj;
16089 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16090 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
16091 Py_INCREF(obj);
16092 return Py_BuildValue((char *)"");
16093 }
16094 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16095 PyObject *resultobj;
16096 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16097 int arg2 = (int) 0 ;
16098 wxCommandEvent *result;
16099 PyObject * obj0 = 0 ;
16100 PyObject * obj1 = 0 ;
16101 char *kwnames[] = {
16102 (char *) "commandType",(char *) "winid", NULL
16103 };
16104
16105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
16106 if (obj0) {
16107 {
16108 arg1 = (wxEventType)(SWIG_As_int(obj0));
16109 if (SWIG_arg_fail(1)) SWIG_fail;
16110 }
16111 }
16112 if (obj1) {
16113 {
16114 arg2 = (int)(SWIG_As_int(obj1));
16115 if (SWIG_arg_fail(2)) SWIG_fail;
16116 }
16117 }
16118 {
16119 PyThreadState* __tstate = wxPyBeginAllowThreads();
16120 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
16121
16122 wxPyEndAllowThreads(__tstate);
16123 if (PyErr_Occurred()) SWIG_fail;
16124 }
16125 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
16126 return resultobj;
16127 fail:
16128 return NULL;
16129 }
16130
16131
16132 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16133 PyObject *resultobj;
16134 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16135 int result;
16136 PyObject * obj0 = 0 ;
16137 char *kwnames[] = {
16138 (char *) "self", NULL
16139 };
16140
16141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
16142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16143 if (SWIG_arg_fail(1)) SWIG_fail;
16144 {
16145 PyThreadState* __tstate = wxPyBeginAllowThreads();
16146 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
16147
16148 wxPyEndAllowThreads(__tstate);
16149 if (PyErr_Occurred()) SWIG_fail;
16150 }
16151 {
16152 resultobj = SWIG_From_int((int)(result));
16153 }
16154 return resultobj;
16155 fail:
16156 return NULL;
16157 }
16158
16159
16160 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
16161 PyObject *resultobj;
16162 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16163 wxString *arg2 = 0 ;
16164 bool temp2 = false ;
16165 PyObject * obj0 = 0 ;
16166 PyObject * obj1 = 0 ;
16167 char *kwnames[] = {
16168 (char *) "self",(char *) "s", NULL
16169 };
16170
16171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
16172 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16173 if (SWIG_arg_fail(1)) SWIG_fail;
16174 {
16175 arg2 = wxString_in_helper(obj1);
16176 if (arg2 == NULL) SWIG_fail;
16177 temp2 = true;
16178 }
16179 {
16180 PyThreadState* __tstate = wxPyBeginAllowThreads();
16181 (arg1)->SetString((wxString const &)*arg2);
16182
16183 wxPyEndAllowThreads(__tstate);
16184 if (PyErr_Occurred()) SWIG_fail;
16185 }
16186 Py_INCREF(Py_None); resultobj = Py_None;
16187 {
16188 if (temp2)
16189 delete arg2;
16190 }
16191 return resultobj;
16192 fail:
16193 {
16194 if (temp2)
16195 delete arg2;
16196 }
16197 return NULL;
16198 }
16199
16200
16201 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
16202 PyObject *resultobj;
16203 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16204 wxString result;
16205 PyObject * obj0 = 0 ;
16206 char *kwnames[] = {
16207 (char *) "self", NULL
16208 };
16209
16210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
16211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16212 if (SWIG_arg_fail(1)) SWIG_fail;
16213 {
16214 PyThreadState* __tstate = wxPyBeginAllowThreads();
16215 result = ((wxCommandEvent const *)arg1)->GetString();
16216
16217 wxPyEndAllowThreads(__tstate);
16218 if (PyErr_Occurred()) SWIG_fail;
16219 }
16220 {
16221 #if wxUSE_UNICODE
16222 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16223 #else
16224 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16225 #endif
16226 }
16227 return resultobj;
16228 fail:
16229 return NULL;
16230 }
16231
16232
16233 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
16234 PyObject *resultobj;
16235 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16236 bool result;
16237 PyObject * obj0 = 0 ;
16238 char *kwnames[] = {
16239 (char *) "self", NULL
16240 };
16241
16242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
16243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16244 if (SWIG_arg_fail(1)) SWIG_fail;
16245 {
16246 PyThreadState* __tstate = wxPyBeginAllowThreads();
16247 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
16248
16249 wxPyEndAllowThreads(__tstate);
16250 if (PyErr_Occurred()) SWIG_fail;
16251 }
16252 {
16253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16254 }
16255 return resultobj;
16256 fail:
16257 return NULL;
16258 }
16259
16260
16261 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
16262 PyObject *resultobj;
16263 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16264 bool result;
16265 PyObject * obj0 = 0 ;
16266 char *kwnames[] = {
16267 (char *) "self", NULL
16268 };
16269
16270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
16271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16272 if (SWIG_arg_fail(1)) SWIG_fail;
16273 {
16274 PyThreadState* __tstate = wxPyBeginAllowThreads();
16275 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
16276
16277 wxPyEndAllowThreads(__tstate);
16278 if (PyErr_Occurred()) SWIG_fail;
16279 }
16280 {
16281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16282 }
16283 return resultobj;
16284 fail:
16285 return NULL;
16286 }
16287
16288
16289 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16290 PyObject *resultobj;
16291 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16292 long arg2 ;
16293 PyObject * obj0 = 0 ;
16294 PyObject * obj1 = 0 ;
16295 char *kwnames[] = {
16296 (char *) "self",(char *) "extraLong", NULL
16297 };
16298
16299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
16300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16301 if (SWIG_arg_fail(1)) SWIG_fail;
16302 {
16303 arg2 = (long)(SWIG_As_long(obj1));
16304 if (SWIG_arg_fail(2)) SWIG_fail;
16305 }
16306 {
16307 PyThreadState* __tstate = wxPyBeginAllowThreads();
16308 (arg1)->SetExtraLong(arg2);
16309
16310 wxPyEndAllowThreads(__tstate);
16311 if (PyErr_Occurred()) SWIG_fail;
16312 }
16313 Py_INCREF(Py_None); resultobj = Py_None;
16314 return resultobj;
16315 fail:
16316 return NULL;
16317 }
16318
16319
16320 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
16321 PyObject *resultobj;
16322 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16323 long result;
16324 PyObject * obj0 = 0 ;
16325 char *kwnames[] = {
16326 (char *) "self", NULL
16327 };
16328
16329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
16330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16331 if (SWIG_arg_fail(1)) SWIG_fail;
16332 {
16333 PyThreadState* __tstate = wxPyBeginAllowThreads();
16334 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
16335
16336 wxPyEndAllowThreads(__tstate);
16337 if (PyErr_Occurred()) SWIG_fail;
16338 }
16339 {
16340 resultobj = SWIG_From_long((long)(result));
16341 }
16342 return resultobj;
16343 fail:
16344 return NULL;
16345 }
16346
16347
16348 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16349 PyObject *resultobj;
16350 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16351 int arg2 ;
16352 PyObject * obj0 = 0 ;
16353 PyObject * obj1 = 0 ;
16354 char *kwnames[] = {
16355 (char *) "self",(char *) "i", NULL
16356 };
16357
16358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
16359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16360 if (SWIG_arg_fail(1)) SWIG_fail;
16361 {
16362 arg2 = (int)(SWIG_As_int(obj1));
16363 if (SWIG_arg_fail(2)) SWIG_fail;
16364 }
16365 {
16366 PyThreadState* __tstate = wxPyBeginAllowThreads();
16367 (arg1)->SetInt(arg2);
16368
16369 wxPyEndAllowThreads(__tstate);
16370 if (PyErr_Occurred()) SWIG_fail;
16371 }
16372 Py_INCREF(Py_None); resultobj = Py_None;
16373 return resultobj;
16374 fail:
16375 return NULL;
16376 }
16377
16378
16379 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
16380 PyObject *resultobj;
16381 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16382 long result;
16383 PyObject * obj0 = 0 ;
16384 char *kwnames[] = {
16385 (char *) "self", NULL
16386 };
16387
16388 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
16389 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16390 if (SWIG_arg_fail(1)) SWIG_fail;
16391 {
16392 PyThreadState* __tstate = wxPyBeginAllowThreads();
16393 result = (long)((wxCommandEvent const *)arg1)->GetInt();
16394
16395 wxPyEndAllowThreads(__tstate);
16396 if (PyErr_Occurred()) SWIG_fail;
16397 }
16398 {
16399 resultobj = SWIG_From_long((long)(result));
16400 }
16401 return resultobj;
16402 fail:
16403 return NULL;
16404 }
16405
16406
16407 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
16408 PyObject *resultobj;
16409 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
16410 wxEvent *result;
16411 PyObject * obj0 = 0 ;
16412 char *kwnames[] = {
16413 (char *) "self", NULL
16414 };
16415
16416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
16417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
16418 if (SWIG_arg_fail(1)) SWIG_fail;
16419 {
16420 PyThreadState* __tstate = wxPyBeginAllowThreads();
16421 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
16422
16423 wxPyEndAllowThreads(__tstate);
16424 if (PyErr_Occurred()) SWIG_fail;
16425 }
16426 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
16427 return resultobj;
16428 fail:
16429 return NULL;
16430 }
16431
16432
16433 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
16434 PyObject *obj;
16435 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16436 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
16437 Py_INCREF(obj);
16438 return Py_BuildValue((char *)"");
16439 }
16440 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16441 PyObject *resultobj;
16442 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16443 int arg2 = (int) 0 ;
16444 wxNotifyEvent *result;
16445 PyObject * obj0 = 0 ;
16446 PyObject * obj1 = 0 ;
16447 char *kwnames[] = {
16448 (char *) "commandType",(char *) "winid", NULL
16449 };
16450
16451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
16452 if (obj0) {
16453 {
16454 arg1 = (wxEventType)(SWIG_As_int(obj0));
16455 if (SWIG_arg_fail(1)) SWIG_fail;
16456 }
16457 }
16458 if (obj1) {
16459 {
16460 arg2 = (int)(SWIG_As_int(obj1));
16461 if (SWIG_arg_fail(2)) SWIG_fail;
16462 }
16463 }
16464 {
16465 PyThreadState* __tstate = wxPyBeginAllowThreads();
16466 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
16467
16468 wxPyEndAllowThreads(__tstate);
16469 if (PyErr_Occurred()) SWIG_fail;
16470 }
16471 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
16472 return resultobj;
16473 fail:
16474 return NULL;
16475 }
16476
16477
16478 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
16479 PyObject *resultobj;
16480 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16481 PyObject * obj0 = 0 ;
16482 char *kwnames[] = {
16483 (char *) "self", NULL
16484 };
16485
16486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
16487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16488 if (SWIG_arg_fail(1)) SWIG_fail;
16489 {
16490 PyThreadState* __tstate = wxPyBeginAllowThreads();
16491 (arg1)->Veto();
16492
16493 wxPyEndAllowThreads(__tstate);
16494 if (PyErr_Occurred()) SWIG_fail;
16495 }
16496 Py_INCREF(Py_None); resultobj = Py_None;
16497 return resultobj;
16498 fail:
16499 return NULL;
16500 }
16501
16502
16503 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
16504 PyObject *resultobj;
16505 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16506 PyObject * obj0 = 0 ;
16507 char *kwnames[] = {
16508 (char *) "self", NULL
16509 };
16510
16511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
16512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16513 if (SWIG_arg_fail(1)) SWIG_fail;
16514 {
16515 PyThreadState* __tstate = wxPyBeginAllowThreads();
16516 (arg1)->Allow();
16517
16518 wxPyEndAllowThreads(__tstate);
16519 if (PyErr_Occurred()) SWIG_fail;
16520 }
16521 Py_INCREF(Py_None); resultobj = Py_None;
16522 return resultobj;
16523 fail:
16524 return NULL;
16525 }
16526
16527
16528 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16529 PyObject *resultobj;
16530 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16531 bool result;
16532 PyObject * obj0 = 0 ;
16533 char *kwnames[] = {
16534 (char *) "self", NULL
16535 };
16536
16537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16539 if (SWIG_arg_fail(1)) SWIG_fail;
16540 {
16541 PyThreadState* __tstate = wxPyBeginAllowThreads();
16542 result = (bool)(arg1)->IsAllowed();
16543
16544 wxPyEndAllowThreads(__tstate);
16545 if (PyErr_Occurred()) SWIG_fail;
16546 }
16547 {
16548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16549 }
16550 return resultobj;
16551 fail:
16552 return NULL;
16553 }
16554
16555
16556 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16557 PyObject *obj;
16558 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16559 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16560 Py_INCREF(obj);
16561 return Py_BuildValue((char *)"");
16562 }
16563 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16564 PyObject *resultobj;
16565 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16566 int arg2 = (int) 0 ;
16567 int arg3 = (int) 0 ;
16568 int arg4 = (int) 0 ;
16569 wxScrollEvent *result;
16570 PyObject * obj0 = 0 ;
16571 PyObject * obj1 = 0 ;
16572 PyObject * obj2 = 0 ;
16573 PyObject * obj3 = 0 ;
16574 char *kwnames[] = {
16575 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16576 };
16577
16578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16579 if (obj0) {
16580 {
16581 arg1 = (wxEventType)(SWIG_As_int(obj0));
16582 if (SWIG_arg_fail(1)) SWIG_fail;
16583 }
16584 }
16585 if (obj1) {
16586 {
16587 arg2 = (int)(SWIG_As_int(obj1));
16588 if (SWIG_arg_fail(2)) SWIG_fail;
16589 }
16590 }
16591 if (obj2) {
16592 {
16593 arg3 = (int)(SWIG_As_int(obj2));
16594 if (SWIG_arg_fail(3)) SWIG_fail;
16595 }
16596 }
16597 if (obj3) {
16598 {
16599 arg4 = (int)(SWIG_As_int(obj3));
16600 if (SWIG_arg_fail(4)) SWIG_fail;
16601 }
16602 }
16603 {
16604 PyThreadState* __tstate = wxPyBeginAllowThreads();
16605 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16606
16607 wxPyEndAllowThreads(__tstate);
16608 if (PyErr_Occurred()) SWIG_fail;
16609 }
16610 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16611 return resultobj;
16612 fail:
16613 return NULL;
16614 }
16615
16616
16617 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16618 PyObject *resultobj;
16619 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16620 int result;
16621 PyObject * obj0 = 0 ;
16622 char *kwnames[] = {
16623 (char *) "self", NULL
16624 };
16625
16626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16628 if (SWIG_arg_fail(1)) SWIG_fail;
16629 {
16630 PyThreadState* __tstate = wxPyBeginAllowThreads();
16631 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16632
16633 wxPyEndAllowThreads(__tstate);
16634 if (PyErr_Occurred()) SWIG_fail;
16635 }
16636 {
16637 resultobj = SWIG_From_int((int)(result));
16638 }
16639 return resultobj;
16640 fail:
16641 return NULL;
16642 }
16643
16644
16645 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16646 PyObject *resultobj;
16647 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16648 int result;
16649 PyObject * obj0 = 0 ;
16650 char *kwnames[] = {
16651 (char *) "self", NULL
16652 };
16653
16654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16656 if (SWIG_arg_fail(1)) SWIG_fail;
16657 {
16658 PyThreadState* __tstate = wxPyBeginAllowThreads();
16659 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16660
16661 wxPyEndAllowThreads(__tstate);
16662 if (PyErr_Occurred()) SWIG_fail;
16663 }
16664 {
16665 resultobj = SWIG_From_int((int)(result));
16666 }
16667 return resultobj;
16668 fail:
16669 return NULL;
16670 }
16671
16672
16673 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16674 PyObject *resultobj;
16675 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16676 int arg2 ;
16677 PyObject * obj0 = 0 ;
16678 PyObject * obj1 = 0 ;
16679 char *kwnames[] = {
16680 (char *) "self",(char *) "orient", NULL
16681 };
16682
16683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16685 if (SWIG_arg_fail(1)) SWIG_fail;
16686 {
16687 arg2 = (int)(SWIG_As_int(obj1));
16688 if (SWIG_arg_fail(2)) SWIG_fail;
16689 }
16690 {
16691 PyThreadState* __tstate = wxPyBeginAllowThreads();
16692 (arg1)->SetOrientation(arg2);
16693
16694 wxPyEndAllowThreads(__tstate);
16695 if (PyErr_Occurred()) SWIG_fail;
16696 }
16697 Py_INCREF(Py_None); resultobj = Py_None;
16698 return resultobj;
16699 fail:
16700 return NULL;
16701 }
16702
16703
16704 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16705 PyObject *resultobj;
16706 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16707 int arg2 ;
16708 PyObject * obj0 = 0 ;
16709 PyObject * obj1 = 0 ;
16710 char *kwnames[] = {
16711 (char *) "self",(char *) "pos", NULL
16712 };
16713
16714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16716 if (SWIG_arg_fail(1)) SWIG_fail;
16717 {
16718 arg2 = (int)(SWIG_As_int(obj1));
16719 if (SWIG_arg_fail(2)) SWIG_fail;
16720 }
16721 {
16722 PyThreadState* __tstate = wxPyBeginAllowThreads();
16723 (arg1)->SetPosition(arg2);
16724
16725 wxPyEndAllowThreads(__tstate);
16726 if (PyErr_Occurred()) SWIG_fail;
16727 }
16728 Py_INCREF(Py_None); resultobj = Py_None;
16729 return resultobj;
16730 fail:
16731 return NULL;
16732 }
16733
16734
16735 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16736 PyObject *obj;
16737 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16738 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16739 Py_INCREF(obj);
16740 return Py_BuildValue((char *)"");
16741 }
16742 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16743 PyObject *resultobj;
16744 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16745 int arg2 = (int) 0 ;
16746 int arg3 = (int) 0 ;
16747 wxScrollWinEvent *result;
16748 PyObject * obj0 = 0 ;
16749 PyObject * obj1 = 0 ;
16750 PyObject * obj2 = 0 ;
16751 char *kwnames[] = {
16752 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16753 };
16754
16755 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16756 if (obj0) {
16757 {
16758 arg1 = (wxEventType)(SWIG_As_int(obj0));
16759 if (SWIG_arg_fail(1)) SWIG_fail;
16760 }
16761 }
16762 if (obj1) {
16763 {
16764 arg2 = (int)(SWIG_As_int(obj1));
16765 if (SWIG_arg_fail(2)) SWIG_fail;
16766 }
16767 }
16768 if (obj2) {
16769 {
16770 arg3 = (int)(SWIG_As_int(obj2));
16771 if (SWIG_arg_fail(3)) SWIG_fail;
16772 }
16773 }
16774 {
16775 PyThreadState* __tstate = wxPyBeginAllowThreads();
16776 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16777
16778 wxPyEndAllowThreads(__tstate);
16779 if (PyErr_Occurred()) SWIG_fail;
16780 }
16781 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16782 return resultobj;
16783 fail:
16784 return NULL;
16785 }
16786
16787
16788 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16789 PyObject *resultobj;
16790 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16791 int result;
16792 PyObject * obj0 = 0 ;
16793 char *kwnames[] = {
16794 (char *) "self", NULL
16795 };
16796
16797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16799 if (SWIG_arg_fail(1)) SWIG_fail;
16800 {
16801 PyThreadState* __tstate = wxPyBeginAllowThreads();
16802 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16803
16804 wxPyEndAllowThreads(__tstate);
16805 if (PyErr_Occurred()) SWIG_fail;
16806 }
16807 {
16808 resultobj = SWIG_From_int((int)(result));
16809 }
16810 return resultobj;
16811 fail:
16812 return NULL;
16813 }
16814
16815
16816 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16817 PyObject *resultobj;
16818 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16819 int result;
16820 PyObject * obj0 = 0 ;
16821 char *kwnames[] = {
16822 (char *) "self", NULL
16823 };
16824
16825 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16826 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16827 if (SWIG_arg_fail(1)) SWIG_fail;
16828 {
16829 PyThreadState* __tstate = wxPyBeginAllowThreads();
16830 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16831
16832 wxPyEndAllowThreads(__tstate);
16833 if (PyErr_Occurred()) SWIG_fail;
16834 }
16835 {
16836 resultobj = SWIG_From_int((int)(result));
16837 }
16838 return resultobj;
16839 fail:
16840 return NULL;
16841 }
16842
16843
16844 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16845 PyObject *resultobj;
16846 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16847 int arg2 ;
16848 PyObject * obj0 = 0 ;
16849 PyObject * obj1 = 0 ;
16850 char *kwnames[] = {
16851 (char *) "self",(char *) "orient", NULL
16852 };
16853
16854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16856 if (SWIG_arg_fail(1)) SWIG_fail;
16857 {
16858 arg2 = (int)(SWIG_As_int(obj1));
16859 if (SWIG_arg_fail(2)) SWIG_fail;
16860 }
16861 {
16862 PyThreadState* __tstate = wxPyBeginAllowThreads();
16863 (arg1)->SetOrientation(arg2);
16864
16865 wxPyEndAllowThreads(__tstate);
16866 if (PyErr_Occurred()) SWIG_fail;
16867 }
16868 Py_INCREF(Py_None); resultobj = Py_None;
16869 return resultobj;
16870 fail:
16871 return NULL;
16872 }
16873
16874
16875 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16876 PyObject *resultobj;
16877 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16878 int arg2 ;
16879 PyObject * obj0 = 0 ;
16880 PyObject * obj1 = 0 ;
16881 char *kwnames[] = {
16882 (char *) "self",(char *) "pos", NULL
16883 };
16884
16885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16887 if (SWIG_arg_fail(1)) SWIG_fail;
16888 {
16889 arg2 = (int)(SWIG_As_int(obj1));
16890 if (SWIG_arg_fail(2)) SWIG_fail;
16891 }
16892 {
16893 PyThreadState* __tstate = wxPyBeginAllowThreads();
16894 (arg1)->SetPosition(arg2);
16895
16896 wxPyEndAllowThreads(__tstate);
16897 if (PyErr_Occurred()) SWIG_fail;
16898 }
16899 Py_INCREF(Py_None); resultobj = Py_None;
16900 return resultobj;
16901 fail:
16902 return NULL;
16903 }
16904
16905
16906 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16907 PyObject *obj;
16908 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16909 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16910 Py_INCREF(obj);
16911 return Py_BuildValue((char *)"");
16912 }
16913 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16914 PyObject *resultobj;
16915 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16916 wxMouseEvent *result;
16917 PyObject * obj0 = 0 ;
16918 char *kwnames[] = {
16919 (char *) "mouseType", NULL
16920 };
16921
16922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
16923 if (obj0) {
16924 {
16925 arg1 = (wxEventType)(SWIG_As_int(obj0));
16926 if (SWIG_arg_fail(1)) SWIG_fail;
16927 }
16928 }
16929 {
16930 PyThreadState* __tstate = wxPyBeginAllowThreads();
16931 result = (wxMouseEvent *)new wxMouseEvent(arg1);
16932
16933 wxPyEndAllowThreads(__tstate);
16934 if (PyErr_Occurred()) SWIG_fail;
16935 }
16936 {
16937 resultobj = wxPyMake_wxObject(result, 1);
16938 }
16939 return resultobj;
16940 fail:
16941 return NULL;
16942 }
16943
16944
16945 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
16946 PyObject *resultobj;
16947 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16948 bool result;
16949 PyObject * obj0 = 0 ;
16950 char *kwnames[] = {
16951 (char *) "self", NULL
16952 };
16953
16954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16956 if (SWIG_arg_fail(1)) SWIG_fail;
16957 {
16958 PyThreadState* __tstate = wxPyBeginAllowThreads();
16959 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16960
16961 wxPyEndAllowThreads(__tstate);
16962 if (PyErr_Occurred()) SWIG_fail;
16963 }
16964 {
16965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16966 }
16967 return resultobj;
16968 fail:
16969 return NULL;
16970 }
16971
16972
16973 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16974 PyObject *resultobj;
16975 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16976 int arg2 = (int) wxMOUSE_BTN_ANY ;
16977 bool result;
16978 PyObject * obj0 = 0 ;
16979 PyObject * obj1 = 0 ;
16980 char *kwnames[] = {
16981 (char *) "self",(char *) "but", NULL
16982 };
16983
16984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16986 if (SWIG_arg_fail(1)) SWIG_fail;
16987 if (obj1) {
16988 {
16989 arg2 = (int)(SWIG_As_int(obj1));
16990 if (SWIG_arg_fail(2)) SWIG_fail;
16991 }
16992 }
16993 {
16994 PyThreadState* __tstate = wxPyBeginAllowThreads();
16995 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16996
16997 wxPyEndAllowThreads(__tstate);
16998 if (PyErr_Occurred()) SWIG_fail;
16999 }
17000 {
17001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17002 }
17003 return resultobj;
17004 fail:
17005 return NULL;
17006 }
17007
17008
17009 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17010 PyObject *resultobj;
17011 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17012 int arg2 = (int) wxMOUSE_BTN_ANY ;
17013 bool result;
17014 PyObject * obj0 = 0 ;
17015 PyObject * obj1 = 0 ;
17016 char *kwnames[] = {
17017 (char *) "self",(char *) "but", NULL
17018 };
17019
17020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
17021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17022 if (SWIG_arg_fail(1)) SWIG_fail;
17023 if (obj1) {
17024 {
17025 arg2 = (int)(SWIG_As_int(obj1));
17026 if (SWIG_arg_fail(2)) SWIG_fail;
17027 }
17028 }
17029 {
17030 PyThreadState* __tstate = wxPyBeginAllowThreads();
17031 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
17032
17033 wxPyEndAllowThreads(__tstate);
17034 if (PyErr_Occurred()) SWIG_fail;
17035 }
17036 {
17037 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17038 }
17039 return resultobj;
17040 fail:
17041 return NULL;
17042 }
17043
17044
17045 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
17046 PyObject *resultobj;
17047 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17048 int arg2 = (int) wxMOUSE_BTN_ANY ;
17049 bool result;
17050 PyObject * obj0 = 0 ;
17051 PyObject * obj1 = 0 ;
17052 char *kwnames[] = {
17053 (char *) "self",(char *) "but", NULL
17054 };
17055
17056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
17057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17058 if (SWIG_arg_fail(1)) SWIG_fail;
17059 if (obj1) {
17060 {
17061 arg2 = (int)(SWIG_As_int(obj1));
17062 if (SWIG_arg_fail(2)) SWIG_fail;
17063 }
17064 }
17065 {
17066 PyThreadState* __tstate = wxPyBeginAllowThreads();
17067 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
17068
17069 wxPyEndAllowThreads(__tstate);
17070 if (PyErr_Occurred()) SWIG_fail;
17071 }
17072 {
17073 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17074 }
17075 return resultobj;
17076 fail:
17077 return NULL;
17078 }
17079
17080
17081 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
17082 PyObject *resultobj;
17083 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17084 int arg2 ;
17085 bool result;
17086 PyObject * obj0 = 0 ;
17087 PyObject * obj1 = 0 ;
17088 char *kwnames[] = {
17089 (char *) "self",(char *) "button", NULL
17090 };
17091
17092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
17093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17094 if (SWIG_arg_fail(1)) SWIG_fail;
17095 {
17096 arg2 = (int)(SWIG_As_int(obj1));
17097 if (SWIG_arg_fail(2)) SWIG_fail;
17098 }
17099 {
17100 PyThreadState* __tstate = wxPyBeginAllowThreads();
17101 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
17102
17103 wxPyEndAllowThreads(__tstate);
17104 if (PyErr_Occurred()) SWIG_fail;
17105 }
17106 {
17107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17108 }
17109 return resultobj;
17110 fail:
17111 return NULL;
17112 }
17113
17114
17115 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17116 PyObject *resultobj;
17117 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17118 int arg2 ;
17119 bool result;
17120 PyObject * obj0 = 0 ;
17121 PyObject * obj1 = 0 ;
17122 char *kwnames[] = {
17123 (char *) "self",(char *) "but", NULL
17124 };
17125
17126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
17127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17128 if (SWIG_arg_fail(1)) SWIG_fail;
17129 {
17130 arg2 = (int)(SWIG_As_int(obj1));
17131 if (SWIG_arg_fail(2)) SWIG_fail;
17132 }
17133 {
17134 PyThreadState* __tstate = wxPyBeginAllowThreads();
17135 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
17136
17137 wxPyEndAllowThreads(__tstate);
17138 if (PyErr_Occurred()) SWIG_fail;
17139 }
17140 {
17141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17142 }
17143 return resultobj;
17144 fail:
17145 return NULL;
17146 }
17147
17148
17149 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
17150 PyObject *resultobj;
17151 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17152 int result;
17153 PyObject * obj0 = 0 ;
17154 char *kwnames[] = {
17155 (char *) "self", NULL
17156 };
17157
17158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
17159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17160 if (SWIG_arg_fail(1)) SWIG_fail;
17161 {
17162 PyThreadState* __tstate = wxPyBeginAllowThreads();
17163 result = (int)((wxMouseEvent const *)arg1)->GetButton();
17164
17165 wxPyEndAllowThreads(__tstate);
17166 if (PyErr_Occurred()) SWIG_fail;
17167 }
17168 {
17169 resultobj = SWIG_From_int((int)(result));
17170 }
17171 return resultobj;
17172 fail:
17173 return NULL;
17174 }
17175
17176
17177 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
17178 PyObject *resultobj;
17179 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17180 bool result;
17181 PyObject * obj0 = 0 ;
17182 char *kwnames[] = {
17183 (char *) "self", NULL
17184 };
17185
17186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
17187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17188 if (SWIG_arg_fail(1)) SWIG_fail;
17189 {
17190 PyThreadState* __tstate = wxPyBeginAllowThreads();
17191 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
17192
17193 wxPyEndAllowThreads(__tstate);
17194 if (PyErr_Occurred()) SWIG_fail;
17195 }
17196 {
17197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17198 }
17199 return resultobj;
17200 fail:
17201 return NULL;
17202 }
17203
17204
17205 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
17206 PyObject *resultobj;
17207 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17208 bool result;
17209 PyObject * obj0 = 0 ;
17210 char *kwnames[] = {
17211 (char *) "self", NULL
17212 };
17213
17214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
17215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17216 if (SWIG_arg_fail(1)) SWIG_fail;
17217 {
17218 PyThreadState* __tstate = wxPyBeginAllowThreads();
17219 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
17220
17221 wxPyEndAllowThreads(__tstate);
17222 if (PyErr_Occurred()) SWIG_fail;
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_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
17234 PyObject *resultobj;
17235 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17236 bool result;
17237 PyObject * obj0 = 0 ;
17238 char *kwnames[] = {
17239 (char *) "self", NULL
17240 };
17241
17242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
17243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17244 if (SWIG_arg_fail(1)) SWIG_fail;
17245 {
17246 PyThreadState* __tstate = wxPyBeginAllowThreads();
17247 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
17248
17249 wxPyEndAllowThreads(__tstate);
17250 if (PyErr_Occurred()) SWIG_fail;
17251 }
17252 {
17253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17254 }
17255 return resultobj;
17256 fail:
17257 return NULL;
17258 }
17259
17260
17261 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17262 PyObject *resultobj;
17263 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17264 bool result;
17265 PyObject * obj0 = 0 ;
17266 char *kwnames[] = {
17267 (char *) "self", NULL
17268 };
17269
17270 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
17271 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17272 if (SWIG_arg_fail(1)) SWIG_fail;
17273 {
17274 PyThreadState* __tstate = wxPyBeginAllowThreads();
17275 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
17276
17277 wxPyEndAllowThreads(__tstate);
17278 if (PyErr_Occurred()) SWIG_fail;
17279 }
17280 {
17281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17282 }
17283 return resultobj;
17284 fail:
17285 return NULL;
17286 }
17287
17288
17289 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
17290 PyObject *resultobj;
17291 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17292 bool result;
17293 PyObject * obj0 = 0 ;
17294 char *kwnames[] = {
17295 (char *) "self", NULL
17296 };
17297
17298 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
17299 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17300 if (SWIG_arg_fail(1)) SWIG_fail;
17301 {
17302 PyThreadState* __tstate = wxPyBeginAllowThreads();
17303 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
17304
17305 wxPyEndAllowThreads(__tstate);
17306 if (PyErr_Occurred()) SWIG_fail;
17307 }
17308 {
17309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17310 }
17311 return resultobj;
17312 fail:
17313 return NULL;
17314 }
17315
17316
17317 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
17318 PyObject *resultobj;
17319 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17320 bool result;
17321 PyObject * obj0 = 0 ;
17322 char *kwnames[] = {
17323 (char *) "self", NULL
17324 };
17325
17326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
17327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17328 if (SWIG_arg_fail(1)) SWIG_fail;
17329 {
17330 PyThreadState* __tstate = wxPyBeginAllowThreads();
17331 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
17332
17333 wxPyEndAllowThreads(__tstate);
17334 if (PyErr_Occurred()) SWIG_fail;
17335 }
17336 {
17337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17338 }
17339 return resultobj;
17340 fail:
17341 return NULL;
17342 }
17343
17344
17345 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
17346 PyObject *resultobj;
17347 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17348 bool result;
17349 PyObject * obj0 = 0 ;
17350 char *kwnames[] = {
17351 (char *) "self", NULL
17352 };
17353
17354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
17355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17356 if (SWIG_arg_fail(1)) SWIG_fail;
17357 {
17358 PyThreadState* __tstate = wxPyBeginAllowThreads();
17359 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
17360
17361 wxPyEndAllowThreads(__tstate);
17362 if (PyErr_Occurred()) SWIG_fail;
17363 }
17364 {
17365 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17366 }
17367 return resultobj;
17368 fail:
17369 return NULL;
17370 }
17371
17372
17373 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
17374 PyObject *resultobj;
17375 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17376 bool result;
17377 PyObject * obj0 = 0 ;
17378 char *kwnames[] = {
17379 (char *) "self", NULL
17380 };
17381
17382 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
17383 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17384 if (SWIG_arg_fail(1)) SWIG_fail;
17385 {
17386 PyThreadState* __tstate = wxPyBeginAllowThreads();
17387 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
17388
17389 wxPyEndAllowThreads(__tstate);
17390 if (PyErr_Occurred()) SWIG_fail;
17391 }
17392 {
17393 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17394 }
17395 return resultobj;
17396 fail:
17397 return NULL;
17398 }
17399
17400
17401 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
17402 PyObject *resultobj;
17403 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17404 bool result;
17405 PyObject * obj0 = 0 ;
17406 char *kwnames[] = {
17407 (char *) "self", NULL
17408 };
17409
17410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
17411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17412 if (SWIG_arg_fail(1)) SWIG_fail;
17413 {
17414 PyThreadState* __tstate = wxPyBeginAllowThreads();
17415 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
17416
17417 wxPyEndAllowThreads(__tstate);
17418 if (PyErr_Occurred()) SWIG_fail;
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_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
17430 PyObject *resultobj;
17431 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17432 bool result;
17433 PyObject * obj0 = 0 ;
17434 char *kwnames[] = {
17435 (char *) "self", NULL
17436 };
17437
17438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
17439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17440 if (SWIG_arg_fail(1)) SWIG_fail;
17441 {
17442 PyThreadState* __tstate = wxPyBeginAllowThreads();
17443 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
17444
17445 wxPyEndAllowThreads(__tstate);
17446 if (PyErr_Occurred()) SWIG_fail;
17447 }
17448 {
17449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17450 }
17451 return resultobj;
17452 fail:
17453 return NULL;
17454 }
17455
17456
17457 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
17458 PyObject *resultobj;
17459 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17460 bool result;
17461 PyObject * obj0 = 0 ;
17462 char *kwnames[] = {
17463 (char *) "self", NULL
17464 };
17465
17466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
17467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17468 if (SWIG_arg_fail(1)) SWIG_fail;
17469 {
17470 PyThreadState* __tstate = wxPyBeginAllowThreads();
17471 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
17472
17473 wxPyEndAllowThreads(__tstate);
17474 if (PyErr_Occurred()) SWIG_fail;
17475 }
17476 {
17477 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17478 }
17479 return resultobj;
17480 fail:
17481 return NULL;
17482 }
17483
17484
17485 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17486 PyObject *resultobj;
17487 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17488 bool result;
17489 PyObject * obj0 = 0 ;
17490 char *kwnames[] = {
17491 (char *) "self", NULL
17492 };
17493
17494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
17495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17496 if (SWIG_arg_fail(1)) SWIG_fail;
17497 {
17498 PyThreadState* __tstate = wxPyBeginAllowThreads();
17499 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
17500
17501 wxPyEndAllowThreads(__tstate);
17502 if (PyErr_Occurred()) SWIG_fail;
17503 }
17504 {
17505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17506 }
17507 return resultobj;
17508 fail:
17509 return NULL;
17510 }
17511
17512
17513 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17514 PyObject *resultobj;
17515 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17516 bool result;
17517 PyObject * obj0 = 0 ;
17518 char *kwnames[] = {
17519 (char *) "self", NULL
17520 };
17521
17522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17524 if (SWIG_arg_fail(1)) SWIG_fail;
17525 {
17526 PyThreadState* __tstate = wxPyBeginAllowThreads();
17527 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17528
17529 wxPyEndAllowThreads(__tstate);
17530 if (PyErr_Occurred()) SWIG_fail;
17531 }
17532 {
17533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17534 }
17535 return resultobj;
17536 fail:
17537 return NULL;
17538 }
17539
17540
17541 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17542 PyObject *resultobj;
17543 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17544 bool result;
17545 PyObject * obj0 = 0 ;
17546 char *kwnames[] = {
17547 (char *) "self", NULL
17548 };
17549
17550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17552 if (SWIG_arg_fail(1)) SWIG_fail;
17553 {
17554 PyThreadState* __tstate = wxPyBeginAllowThreads();
17555 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17556
17557 wxPyEndAllowThreads(__tstate);
17558 if (PyErr_Occurred()) SWIG_fail;
17559 }
17560 {
17561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17562 }
17563 return resultobj;
17564 fail:
17565 return NULL;
17566 }
17567
17568
17569 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17570 PyObject *resultobj;
17571 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17572 bool result;
17573 PyObject * obj0 = 0 ;
17574 char *kwnames[] = {
17575 (char *) "self", NULL
17576 };
17577
17578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17580 if (SWIG_arg_fail(1)) SWIG_fail;
17581 {
17582 PyThreadState* __tstate = wxPyBeginAllowThreads();
17583 result = (bool)(arg1)->LeftIsDown();
17584
17585 wxPyEndAllowThreads(__tstate);
17586 if (PyErr_Occurred()) SWIG_fail;
17587 }
17588 {
17589 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17590 }
17591 return resultobj;
17592 fail:
17593 return NULL;
17594 }
17595
17596
17597 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17598 PyObject *resultobj;
17599 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17600 bool result;
17601 PyObject * obj0 = 0 ;
17602 char *kwnames[] = {
17603 (char *) "self", NULL
17604 };
17605
17606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17608 if (SWIG_arg_fail(1)) SWIG_fail;
17609 {
17610 PyThreadState* __tstate = wxPyBeginAllowThreads();
17611 result = (bool)(arg1)->MiddleIsDown();
17612
17613 wxPyEndAllowThreads(__tstate);
17614 if (PyErr_Occurred()) SWIG_fail;
17615 }
17616 {
17617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17618 }
17619 return resultobj;
17620 fail:
17621 return NULL;
17622 }
17623
17624
17625 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17626 PyObject *resultobj;
17627 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17628 bool result;
17629 PyObject * obj0 = 0 ;
17630 char *kwnames[] = {
17631 (char *) "self", NULL
17632 };
17633
17634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17636 if (SWIG_arg_fail(1)) SWIG_fail;
17637 {
17638 PyThreadState* __tstate = wxPyBeginAllowThreads();
17639 result = (bool)(arg1)->RightIsDown();
17640
17641 wxPyEndAllowThreads(__tstate);
17642 if (PyErr_Occurred()) SWIG_fail;
17643 }
17644 {
17645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17646 }
17647 return resultobj;
17648 fail:
17649 return NULL;
17650 }
17651
17652
17653 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17654 PyObject *resultobj;
17655 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17656 bool result;
17657 PyObject * obj0 = 0 ;
17658 char *kwnames[] = {
17659 (char *) "self", NULL
17660 };
17661
17662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17663 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17664 if (SWIG_arg_fail(1)) SWIG_fail;
17665 {
17666 PyThreadState* __tstate = wxPyBeginAllowThreads();
17667 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17668
17669 wxPyEndAllowThreads(__tstate);
17670 if (PyErr_Occurred()) SWIG_fail;
17671 }
17672 {
17673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17674 }
17675 return resultobj;
17676 fail:
17677 return NULL;
17678 }
17679
17680
17681 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17682 PyObject *resultobj;
17683 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17684 bool result;
17685 PyObject * obj0 = 0 ;
17686 char *kwnames[] = {
17687 (char *) "self", NULL
17688 };
17689
17690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17692 if (SWIG_arg_fail(1)) SWIG_fail;
17693 {
17694 PyThreadState* __tstate = wxPyBeginAllowThreads();
17695 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17696
17697 wxPyEndAllowThreads(__tstate);
17698 if (PyErr_Occurred()) SWIG_fail;
17699 }
17700 {
17701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17702 }
17703 return resultobj;
17704 fail:
17705 return NULL;
17706 }
17707
17708
17709 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17710 PyObject *resultobj;
17711 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17712 bool result;
17713 PyObject * obj0 = 0 ;
17714 char *kwnames[] = {
17715 (char *) "self", NULL
17716 };
17717
17718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17719 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17720 if (SWIG_arg_fail(1)) SWIG_fail;
17721 {
17722 PyThreadState* __tstate = wxPyBeginAllowThreads();
17723 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17724
17725 wxPyEndAllowThreads(__tstate);
17726 if (PyErr_Occurred()) SWIG_fail;
17727 }
17728 {
17729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17730 }
17731 return resultobj;
17732 fail:
17733 return NULL;
17734 }
17735
17736
17737 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17738 PyObject *resultobj;
17739 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17740 bool result;
17741 PyObject * obj0 = 0 ;
17742 char *kwnames[] = {
17743 (char *) "self", NULL
17744 };
17745
17746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17748 if (SWIG_arg_fail(1)) SWIG_fail;
17749 {
17750 PyThreadState* __tstate = wxPyBeginAllowThreads();
17751 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17752
17753 wxPyEndAllowThreads(__tstate);
17754 if (PyErr_Occurred()) SWIG_fail;
17755 }
17756 {
17757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17758 }
17759 return resultobj;
17760 fail:
17761 return NULL;
17762 }
17763
17764
17765 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17766 PyObject *resultobj;
17767 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17768 wxPoint result;
17769 PyObject * obj0 = 0 ;
17770 char *kwnames[] = {
17771 (char *) "self", NULL
17772 };
17773
17774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17776 if (SWIG_arg_fail(1)) SWIG_fail;
17777 {
17778 PyThreadState* __tstate = wxPyBeginAllowThreads();
17779 result = (arg1)->GetPosition();
17780
17781 wxPyEndAllowThreads(__tstate);
17782 if (PyErr_Occurred()) SWIG_fail;
17783 }
17784 {
17785 wxPoint * resultptr;
17786 resultptr = new wxPoint((wxPoint &)(result));
17787 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17788 }
17789 return resultobj;
17790 fail:
17791 return NULL;
17792 }
17793
17794
17795 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17796 PyObject *resultobj;
17797 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17798 long *arg2 = (long *) 0 ;
17799 long *arg3 = (long *) 0 ;
17800 long temp2 ;
17801 int res2 = 0 ;
17802 long temp3 ;
17803 int res3 = 0 ;
17804 PyObject * obj0 = 0 ;
17805 char *kwnames[] = {
17806 (char *) "self", NULL
17807 };
17808
17809 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17810 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17813 if (SWIG_arg_fail(1)) SWIG_fail;
17814 {
17815 PyThreadState* __tstate = wxPyBeginAllowThreads();
17816 (arg1)->GetPosition(arg2,arg3);
17817
17818 wxPyEndAllowThreads(__tstate);
17819 if (PyErr_Occurred()) SWIG_fail;
17820 }
17821 Py_INCREF(Py_None); resultobj = Py_None;
17822 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17823 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17824 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17825 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17826 return resultobj;
17827 fail:
17828 return NULL;
17829 }
17830
17831
17832 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17833 PyObject *resultobj;
17834 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17835 wxDC *arg2 = 0 ;
17836 wxPoint result;
17837 PyObject * obj0 = 0 ;
17838 PyObject * obj1 = 0 ;
17839 char *kwnames[] = {
17840 (char *) "self",(char *) "dc", NULL
17841 };
17842
17843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) goto fail;
17844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17845 if (SWIG_arg_fail(1)) SWIG_fail;
17846 {
17847 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17848 if (SWIG_arg_fail(2)) SWIG_fail;
17849 if (arg2 == NULL) {
17850 SWIG_null_ref("wxDC");
17851 }
17852 if (SWIG_arg_fail(2)) SWIG_fail;
17853 }
17854 {
17855 PyThreadState* __tstate = wxPyBeginAllowThreads();
17856 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17857
17858 wxPyEndAllowThreads(__tstate);
17859 if (PyErr_Occurred()) SWIG_fail;
17860 }
17861 {
17862 wxPoint * resultptr;
17863 resultptr = new wxPoint((wxPoint &)(result));
17864 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17865 }
17866 return resultobj;
17867 fail:
17868 return NULL;
17869 }
17870
17871
17872 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17873 PyObject *resultobj;
17874 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17875 int result;
17876 PyObject * obj0 = 0 ;
17877 char *kwnames[] = {
17878 (char *) "self", NULL
17879 };
17880
17881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17882 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17883 if (SWIG_arg_fail(1)) SWIG_fail;
17884 {
17885 PyThreadState* __tstate = wxPyBeginAllowThreads();
17886 result = (int)((wxMouseEvent const *)arg1)->GetX();
17887
17888 wxPyEndAllowThreads(__tstate);
17889 if (PyErr_Occurred()) SWIG_fail;
17890 }
17891 {
17892 resultobj = SWIG_From_int((int)(result));
17893 }
17894 return resultobj;
17895 fail:
17896 return NULL;
17897 }
17898
17899
17900 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17901 PyObject *resultobj;
17902 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17903 int result;
17904 PyObject * obj0 = 0 ;
17905 char *kwnames[] = {
17906 (char *) "self", NULL
17907 };
17908
17909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
17910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17911 if (SWIG_arg_fail(1)) SWIG_fail;
17912 {
17913 PyThreadState* __tstate = wxPyBeginAllowThreads();
17914 result = (int)((wxMouseEvent const *)arg1)->GetY();
17915
17916 wxPyEndAllowThreads(__tstate);
17917 if (PyErr_Occurred()) SWIG_fail;
17918 }
17919 {
17920 resultobj = SWIG_From_int((int)(result));
17921 }
17922 return resultobj;
17923 fail:
17924 return NULL;
17925 }
17926
17927
17928 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
17929 PyObject *resultobj;
17930 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17931 int result;
17932 PyObject * obj0 = 0 ;
17933 char *kwnames[] = {
17934 (char *) "self", NULL
17935 };
17936
17937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
17938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17939 if (SWIG_arg_fail(1)) SWIG_fail;
17940 {
17941 PyThreadState* __tstate = wxPyBeginAllowThreads();
17942 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
17943
17944 wxPyEndAllowThreads(__tstate);
17945 if (PyErr_Occurred()) SWIG_fail;
17946 }
17947 {
17948 resultobj = SWIG_From_int((int)(result));
17949 }
17950 return resultobj;
17951 fail:
17952 return NULL;
17953 }
17954
17955
17956 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17957 PyObject *resultobj;
17958 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17959 int result;
17960 PyObject * obj0 = 0 ;
17961 char *kwnames[] = {
17962 (char *) "self", NULL
17963 };
17964
17965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17967 if (SWIG_arg_fail(1)) SWIG_fail;
17968 {
17969 PyThreadState* __tstate = wxPyBeginAllowThreads();
17970 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17971
17972 wxPyEndAllowThreads(__tstate);
17973 if (PyErr_Occurred()) SWIG_fail;
17974 }
17975 {
17976 resultobj = SWIG_From_int((int)(result));
17977 }
17978 return resultobj;
17979 fail:
17980 return NULL;
17981 }
17982
17983
17984 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17985 PyObject *resultobj;
17986 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17987 int result;
17988 PyObject * obj0 = 0 ;
17989 char *kwnames[] = {
17990 (char *) "self", NULL
17991 };
17992
17993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17995 if (SWIG_arg_fail(1)) SWIG_fail;
17996 {
17997 PyThreadState* __tstate = wxPyBeginAllowThreads();
17998 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17999
18000 wxPyEndAllowThreads(__tstate);
18001 if (PyErr_Occurred()) SWIG_fail;
18002 }
18003 {
18004 resultobj = SWIG_From_int((int)(result));
18005 }
18006 return resultobj;
18007 fail:
18008 return NULL;
18009 }
18010
18011
18012 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
18013 PyObject *resultobj;
18014 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18015 bool result;
18016 PyObject * obj0 = 0 ;
18017 char *kwnames[] = {
18018 (char *) "self", NULL
18019 };
18020
18021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
18022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18023 if (SWIG_arg_fail(1)) SWIG_fail;
18024 {
18025 PyThreadState* __tstate = wxPyBeginAllowThreads();
18026 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
18027
18028 wxPyEndAllowThreads(__tstate);
18029 if (PyErr_Occurred()) SWIG_fail;
18030 }
18031 {
18032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18033 }
18034 return resultobj;
18035 fail:
18036 return NULL;
18037 }
18038
18039
18040 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18041 PyObject *resultobj;
18042 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18043 int arg2 ;
18044 PyObject * obj0 = 0 ;
18045 PyObject * obj1 = 0 ;
18046 char *kwnames[] = {
18047 (char *) "self",(char *) "m_x", NULL
18048 };
18049
18050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18052 if (SWIG_arg_fail(1)) SWIG_fail;
18053 {
18054 arg2 = (int)(SWIG_As_int(obj1));
18055 if (SWIG_arg_fail(2)) SWIG_fail;
18056 }
18057 if (arg1) (arg1)->m_x = arg2;
18058
18059 Py_INCREF(Py_None); resultobj = Py_None;
18060 return resultobj;
18061 fail:
18062 return NULL;
18063 }
18064
18065
18066 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18067 PyObject *resultobj;
18068 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18069 int result;
18070 PyObject * obj0 = 0 ;
18071 char *kwnames[] = {
18072 (char *) "self", NULL
18073 };
18074
18075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
18076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18077 if (SWIG_arg_fail(1)) SWIG_fail;
18078 result = (int) ((arg1)->m_x);
18079
18080 {
18081 resultobj = SWIG_From_int((int)(result));
18082 }
18083 return resultobj;
18084 fail:
18085 return NULL;
18086 }
18087
18088
18089 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18090 PyObject *resultobj;
18091 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18092 int arg2 ;
18093 PyObject * obj0 = 0 ;
18094 PyObject * obj1 = 0 ;
18095 char *kwnames[] = {
18096 (char *) "self",(char *) "m_y", NULL
18097 };
18098
18099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18101 if (SWIG_arg_fail(1)) SWIG_fail;
18102 {
18103 arg2 = (int)(SWIG_As_int(obj1));
18104 if (SWIG_arg_fail(2)) SWIG_fail;
18105 }
18106 if (arg1) (arg1)->m_y = arg2;
18107
18108 Py_INCREF(Py_None); resultobj = Py_None;
18109 return resultobj;
18110 fail:
18111 return NULL;
18112 }
18113
18114
18115 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18116 PyObject *resultobj;
18117 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18118 int result;
18119 PyObject * obj0 = 0 ;
18120 char *kwnames[] = {
18121 (char *) "self", NULL
18122 };
18123
18124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
18125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18126 if (SWIG_arg_fail(1)) SWIG_fail;
18127 result = (int) ((arg1)->m_y);
18128
18129 {
18130 resultobj = SWIG_From_int((int)(result));
18131 }
18132 return resultobj;
18133 fail:
18134 return NULL;
18135 }
18136
18137
18138 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18139 PyObject *resultobj;
18140 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18141 bool arg2 ;
18142 PyObject * obj0 = 0 ;
18143 PyObject * obj1 = 0 ;
18144 char *kwnames[] = {
18145 (char *) "self",(char *) "m_leftDown", NULL
18146 };
18147
18148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
18149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18150 if (SWIG_arg_fail(1)) SWIG_fail;
18151 {
18152 arg2 = (bool)(SWIG_As_bool(obj1));
18153 if (SWIG_arg_fail(2)) SWIG_fail;
18154 }
18155 if (arg1) (arg1)->m_leftDown = arg2;
18156
18157 Py_INCREF(Py_None); resultobj = Py_None;
18158 return resultobj;
18159 fail:
18160 return NULL;
18161 }
18162
18163
18164 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18165 PyObject *resultobj;
18166 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18167 bool result;
18168 PyObject * obj0 = 0 ;
18169 char *kwnames[] = {
18170 (char *) "self", NULL
18171 };
18172
18173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
18174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18175 if (SWIG_arg_fail(1)) SWIG_fail;
18176 result = (bool) ((arg1)->m_leftDown);
18177
18178 {
18179 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18180 }
18181 return resultobj;
18182 fail:
18183 return NULL;
18184 }
18185
18186
18187 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18188 PyObject *resultobj;
18189 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18190 bool arg2 ;
18191 PyObject * obj0 = 0 ;
18192 PyObject * obj1 = 0 ;
18193 char *kwnames[] = {
18194 (char *) "self",(char *) "m_middleDown", NULL
18195 };
18196
18197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
18198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18199 if (SWIG_arg_fail(1)) SWIG_fail;
18200 {
18201 arg2 = (bool)(SWIG_As_bool(obj1));
18202 if (SWIG_arg_fail(2)) SWIG_fail;
18203 }
18204 if (arg1) (arg1)->m_middleDown = arg2;
18205
18206 Py_INCREF(Py_None); resultobj = Py_None;
18207 return resultobj;
18208 fail:
18209 return NULL;
18210 }
18211
18212
18213 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18214 PyObject *resultobj;
18215 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18216 bool result;
18217 PyObject * obj0 = 0 ;
18218 char *kwnames[] = {
18219 (char *) "self", NULL
18220 };
18221
18222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
18223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18224 if (SWIG_arg_fail(1)) SWIG_fail;
18225 result = (bool) ((arg1)->m_middleDown);
18226
18227 {
18228 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18229 }
18230 return resultobj;
18231 fail:
18232 return NULL;
18233 }
18234
18235
18236 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18237 PyObject *resultobj;
18238 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18239 bool arg2 ;
18240 PyObject * obj0 = 0 ;
18241 PyObject * obj1 = 0 ;
18242 char *kwnames[] = {
18243 (char *) "self",(char *) "m_rightDown", NULL
18244 };
18245
18246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
18247 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18248 if (SWIG_arg_fail(1)) SWIG_fail;
18249 {
18250 arg2 = (bool)(SWIG_As_bool(obj1));
18251 if (SWIG_arg_fail(2)) SWIG_fail;
18252 }
18253 if (arg1) (arg1)->m_rightDown = arg2;
18254
18255 Py_INCREF(Py_None); resultobj = Py_None;
18256 return resultobj;
18257 fail:
18258 return NULL;
18259 }
18260
18261
18262 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18263 PyObject *resultobj;
18264 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18265 bool result;
18266 PyObject * obj0 = 0 ;
18267 char *kwnames[] = {
18268 (char *) "self", NULL
18269 };
18270
18271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
18272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18273 if (SWIG_arg_fail(1)) SWIG_fail;
18274 result = (bool) ((arg1)->m_rightDown);
18275
18276 {
18277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18278 }
18279 return resultobj;
18280 fail:
18281 return NULL;
18282 }
18283
18284
18285 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18286 PyObject *resultobj;
18287 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18288 bool arg2 ;
18289 PyObject * obj0 = 0 ;
18290 PyObject * obj1 = 0 ;
18291 char *kwnames[] = {
18292 (char *) "self",(char *) "m_controlDown", NULL
18293 };
18294
18295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18297 if (SWIG_arg_fail(1)) SWIG_fail;
18298 {
18299 arg2 = (bool)(SWIG_As_bool(obj1));
18300 if (SWIG_arg_fail(2)) SWIG_fail;
18301 }
18302 if (arg1) (arg1)->m_controlDown = arg2;
18303
18304 Py_INCREF(Py_None); resultobj = Py_None;
18305 return resultobj;
18306 fail:
18307 return NULL;
18308 }
18309
18310
18311 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18312 PyObject *resultobj;
18313 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18314 bool result;
18315 PyObject * obj0 = 0 ;
18316 char *kwnames[] = {
18317 (char *) "self", NULL
18318 };
18319
18320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18322 if (SWIG_arg_fail(1)) SWIG_fail;
18323 result = (bool) ((arg1)->m_controlDown);
18324
18325 {
18326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18327 }
18328 return resultobj;
18329 fail:
18330 return NULL;
18331 }
18332
18333
18334 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18335 PyObject *resultobj;
18336 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18337 bool arg2 ;
18338 PyObject * obj0 = 0 ;
18339 PyObject * obj1 = 0 ;
18340 char *kwnames[] = {
18341 (char *) "self",(char *) "m_shiftDown", NULL
18342 };
18343
18344 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18345 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18346 if (SWIG_arg_fail(1)) SWIG_fail;
18347 {
18348 arg2 = (bool)(SWIG_As_bool(obj1));
18349 if (SWIG_arg_fail(2)) SWIG_fail;
18350 }
18351 if (arg1) (arg1)->m_shiftDown = arg2;
18352
18353 Py_INCREF(Py_None); resultobj = Py_None;
18354 return resultobj;
18355 fail:
18356 return NULL;
18357 }
18358
18359
18360 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18361 PyObject *resultobj;
18362 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18363 bool result;
18364 PyObject * obj0 = 0 ;
18365 char *kwnames[] = {
18366 (char *) "self", NULL
18367 };
18368
18369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18371 if (SWIG_arg_fail(1)) SWIG_fail;
18372 result = (bool) ((arg1)->m_shiftDown);
18373
18374 {
18375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18376 }
18377 return resultobj;
18378 fail:
18379 return NULL;
18380 }
18381
18382
18383 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18384 PyObject *resultobj;
18385 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18386 bool arg2 ;
18387 PyObject * obj0 = 0 ;
18388 PyObject * obj1 = 0 ;
18389 char *kwnames[] = {
18390 (char *) "self",(char *) "m_altDown", NULL
18391 };
18392
18393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
18394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18395 if (SWIG_arg_fail(1)) SWIG_fail;
18396 {
18397 arg2 = (bool)(SWIG_As_bool(obj1));
18398 if (SWIG_arg_fail(2)) SWIG_fail;
18399 }
18400 if (arg1) (arg1)->m_altDown = arg2;
18401
18402 Py_INCREF(Py_None); resultobj = Py_None;
18403 return resultobj;
18404 fail:
18405 return NULL;
18406 }
18407
18408
18409 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18410 PyObject *resultobj;
18411 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18412 bool result;
18413 PyObject * obj0 = 0 ;
18414 char *kwnames[] = {
18415 (char *) "self", NULL
18416 };
18417
18418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
18419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18420 if (SWIG_arg_fail(1)) SWIG_fail;
18421 result = (bool) ((arg1)->m_altDown);
18422
18423 {
18424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18425 }
18426 return resultobj;
18427 fail:
18428 return NULL;
18429 }
18430
18431
18432 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18433 PyObject *resultobj;
18434 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18435 bool arg2 ;
18436 PyObject * obj0 = 0 ;
18437 PyObject * obj1 = 0 ;
18438 char *kwnames[] = {
18439 (char *) "self",(char *) "m_metaDown", NULL
18440 };
18441
18442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
18443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18444 if (SWIG_arg_fail(1)) SWIG_fail;
18445 {
18446 arg2 = (bool)(SWIG_As_bool(obj1));
18447 if (SWIG_arg_fail(2)) SWIG_fail;
18448 }
18449 if (arg1) (arg1)->m_metaDown = arg2;
18450
18451 Py_INCREF(Py_None); resultobj = Py_None;
18452 return resultobj;
18453 fail:
18454 return NULL;
18455 }
18456
18457
18458 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18459 PyObject *resultobj;
18460 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18461 bool result;
18462 PyObject * obj0 = 0 ;
18463 char *kwnames[] = {
18464 (char *) "self", NULL
18465 };
18466
18467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
18468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18469 if (SWIG_arg_fail(1)) SWIG_fail;
18470 result = (bool) ((arg1)->m_metaDown);
18471
18472 {
18473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18474 }
18475 return resultobj;
18476 fail:
18477 return NULL;
18478 }
18479
18480
18481 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
18482 PyObject *resultobj;
18483 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18484 int arg2 ;
18485 PyObject * obj0 = 0 ;
18486 PyObject * obj1 = 0 ;
18487 char *kwnames[] = {
18488 (char *) "self",(char *) "m_wheelRotation", NULL
18489 };
18490
18491 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
18492 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18493 if (SWIG_arg_fail(1)) SWIG_fail;
18494 {
18495 arg2 = (int)(SWIG_As_int(obj1));
18496 if (SWIG_arg_fail(2)) SWIG_fail;
18497 }
18498 if (arg1) (arg1)->m_wheelRotation = arg2;
18499
18500 Py_INCREF(Py_None); resultobj = Py_None;
18501 return resultobj;
18502 fail:
18503 return NULL;
18504 }
18505
18506
18507 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
18508 PyObject *resultobj;
18509 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18510 int result;
18511 PyObject * obj0 = 0 ;
18512 char *kwnames[] = {
18513 (char *) "self", NULL
18514 };
18515
18516 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18517 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18518 if (SWIG_arg_fail(1)) SWIG_fail;
18519 result = (int) ((arg1)->m_wheelRotation);
18520
18521 {
18522 resultobj = SWIG_From_int((int)(result));
18523 }
18524 return resultobj;
18525 fail:
18526 return NULL;
18527 }
18528
18529
18530 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18531 PyObject *resultobj;
18532 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18533 int arg2 ;
18534 PyObject * obj0 = 0 ;
18535 PyObject * obj1 = 0 ;
18536 char *kwnames[] = {
18537 (char *) "self",(char *) "m_wheelDelta", NULL
18538 };
18539
18540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18542 if (SWIG_arg_fail(1)) SWIG_fail;
18543 {
18544 arg2 = (int)(SWIG_As_int(obj1));
18545 if (SWIG_arg_fail(2)) SWIG_fail;
18546 }
18547 if (arg1) (arg1)->m_wheelDelta = arg2;
18548
18549 Py_INCREF(Py_None); resultobj = Py_None;
18550 return resultobj;
18551 fail:
18552 return NULL;
18553 }
18554
18555
18556 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18557 PyObject *resultobj;
18558 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18559 int result;
18560 PyObject * obj0 = 0 ;
18561 char *kwnames[] = {
18562 (char *) "self", NULL
18563 };
18564
18565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18566 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18567 if (SWIG_arg_fail(1)) SWIG_fail;
18568 result = (int) ((arg1)->m_wheelDelta);
18569
18570 {
18571 resultobj = SWIG_From_int((int)(result));
18572 }
18573 return resultobj;
18574 fail:
18575 return NULL;
18576 }
18577
18578
18579 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18580 PyObject *resultobj;
18581 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18582 int arg2 ;
18583 PyObject * obj0 = 0 ;
18584 PyObject * obj1 = 0 ;
18585 char *kwnames[] = {
18586 (char *) "self",(char *) "m_linesPerAction", NULL
18587 };
18588
18589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18591 if (SWIG_arg_fail(1)) SWIG_fail;
18592 {
18593 arg2 = (int)(SWIG_As_int(obj1));
18594 if (SWIG_arg_fail(2)) SWIG_fail;
18595 }
18596 if (arg1) (arg1)->m_linesPerAction = arg2;
18597
18598 Py_INCREF(Py_None); resultobj = Py_None;
18599 return resultobj;
18600 fail:
18601 return NULL;
18602 }
18603
18604
18605 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18606 PyObject *resultobj;
18607 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18608 int result;
18609 PyObject * obj0 = 0 ;
18610 char *kwnames[] = {
18611 (char *) "self", NULL
18612 };
18613
18614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18615 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18616 if (SWIG_arg_fail(1)) SWIG_fail;
18617 result = (int) ((arg1)->m_linesPerAction);
18618
18619 {
18620 resultobj = SWIG_From_int((int)(result));
18621 }
18622 return resultobj;
18623 fail:
18624 return NULL;
18625 }
18626
18627
18628 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18629 PyObject *obj;
18630 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18631 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18632 Py_INCREF(obj);
18633 return Py_BuildValue((char *)"");
18634 }
18635 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18636 PyObject *resultobj;
18637 int arg1 = (int) 0 ;
18638 int arg2 = (int) 0 ;
18639 wxSetCursorEvent *result;
18640 PyObject * obj0 = 0 ;
18641 PyObject * obj1 = 0 ;
18642 char *kwnames[] = {
18643 (char *) "x",(char *) "y", NULL
18644 };
18645
18646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18647 if (obj0) {
18648 {
18649 arg1 = (int)(SWIG_As_int(obj0));
18650 if (SWIG_arg_fail(1)) SWIG_fail;
18651 }
18652 }
18653 if (obj1) {
18654 {
18655 arg2 = (int)(SWIG_As_int(obj1));
18656 if (SWIG_arg_fail(2)) SWIG_fail;
18657 }
18658 }
18659 {
18660 PyThreadState* __tstate = wxPyBeginAllowThreads();
18661 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18662
18663 wxPyEndAllowThreads(__tstate);
18664 if (PyErr_Occurred()) SWIG_fail;
18665 }
18666 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18667 return resultobj;
18668 fail:
18669 return NULL;
18670 }
18671
18672
18673 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18674 PyObject *resultobj;
18675 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18676 int result;
18677 PyObject * obj0 = 0 ;
18678 char *kwnames[] = {
18679 (char *) "self", NULL
18680 };
18681
18682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18683 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18684 if (SWIG_arg_fail(1)) SWIG_fail;
18685 {
18686 PyThreadState* __tstate = wxPyBeginAllowThreads();
18687 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18688
18689 wxPyEndAllowThreads(__tstate);
18690 if (PyErr_Occurred()) SWIG_fail;
18691 }
18692 {
18693 resultobj = SWIG_From_int((int)(result));
18694 }
18695 return resultobj;
18696 fail:
18697 return NULL;
18698 }
18699
18700
18701 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18702 PyObject *resultobj;
18703 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18704 int result;
18705 PyObject * obj0 = 0 ;
18706 char *kwnames[] = {
18707 (char *) "self", NULL
18708 };
18709
18710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18712 if (SWIG_arg_fail(1)) SWIG_fail;
18713 {
18714 PyThreadState* __tstate = wxPyBeginAllowThreads();
18715 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18716
18717 wxPyEndAllowThreads(__tstate);
18718 if (PyErr_Occurred()) SWIG_fail;
18719 }
18720 {
18721 resultobj = SWIG_From_int((int)(result));
18722 }
18723 return resultobj;
18724 fail:
18725 return NULL;
18726 }
18727
18728
18729 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18730 PyObject *resultobj;
18731 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18732 wxCursor *arg2 = 0 ;
18733 PyObject * obj0 = 0 ;
18734 PyObject * obj1 = 0 ;
18735 char *kwnames[] = {
18736 (char *) "self",(char *) "cursor", NULL
18737 };
18738
18739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18741 if (SWIG_arg_fail(1)) SWIG_fail;
18742 {
18743 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18744 if (SWIG_arg_fail(2)) SWIG_fail;
18745 if (arg2 == NULL) {
18746 SWIG_null_ref("wxCursor");
18747 }
18748 if (SWIG_arg_fail(2)) SWIG_fail;
18749 }
18750 {
18751 PyThreadState* __tstate = wxPyBeginAllowThreads();
18752 (arg1)->SetCursor((wxCursor const &)*arg2);
18753
18754 wxPyEndAllowThreads(__tstate);
18755 if (PyErr_Occurred()) SWIG_fail;
18756 }
18757 Py_INCREF(Py_None); resultobj = Py_None;
18758 return resultobj;
18759 fail:
18760 return NULL;
18761 }
18762
18763
18764 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18765 PyObject *resultobj;
18766 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18767 wxCursor *result;
18768 PyObject * obj0 = 0 ;
18769 char *kwnames[] = {
18770 (char *) "self", NULL
18771 };
18772
18773 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18774 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18775 if (SWIG_arg_fail(1)) SWIG_fail;
18776 {
18777 PyThreadState* __tstate = wxPyBeginAllowThreads();
18778 {
18779 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18780 result = (wxCursor *) &_result_ref;
18781 }
18782
18783 wxPyEndAllowThreads(__tstate);
18784 if (PyErr_Occurred()) SWIG_fail;
18785 }
18786 {
18787 wxCursor* resultptr = new wxCursor(*result);
18788 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18789 }
18790 return resultobj;
18791 fail:
18792 return NULL;
18793 }
18794
18795
18796 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18797 PyObject *resultobj;
18798 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18799 bool result;
18800 PyObject * obj0 = 0 ;
18801 char *kwnames[] = {
18802 (char *) "self", NULL
18803 };
18804
18805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18807 if (SWIG_arg_fail(1)) SWIG_fail;
18808 {
18809 PyThreadState* __tstate = wxPyBeginAllowThreads();
18810 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18811
18812 wxPyEndAllowThreads(__tstate);
18813 if (PyErr_Occurred()) SWIG_fail;
18814 }
18815 {
18816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18817 }
18818 return resultobj;
18819 fail:
18820 return NULL;
18821 }
18822
18823
18824 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18825 PyObject *obj;
18826 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18827 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18828 Py_INCREF(obj);
18829 return Py_BuildValue((char *)"");
18830 }
18831 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18832 PyObject *resultobj;
18833 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18834 wxKeyEvent *result;
18835 PyObject * obj0 = 0 ;
18836 char *kwnames[] = {
18837 (char *) "eventType", NULL
18838 };
18839
18840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18841 if (obj0) {
18842 {
18843 arg1 = (wxEventType)(SWIG_As_int(obj0));
18844 if (SWIG_arg_fail(1)) SWIG_fail;
18845 }
18846 }
18847 {
18848 PyThreadState* __tstate = wxPyBeginAllowThreads();
18849 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18850
18851 wxPyEndAllowThreads(__tstate);
18852 if (PyErr_Occurred()) SWIG_fail;
18853 }
18854 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18855 return resultobj;
18856 fail:
18857 return NULL;
18858 }
18859
18860
18861 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18862 PyObject *resultobj;
18863 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18864 bool result;
18865 PyObject * obj0 = 0 ;
18866 char *kwnames[] = {
18867 (char *) "self", NULL
18868 };
18869
18870 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18871 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18872 if (SWIG_arg_fail(1)) SWIG_fail;
18873 {
18874 PyThreadState* __tstate = wxPyBeginAllowThreads();
18875 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18876
18877 wxPyEndAllowThreads(__tstate);
18878 if (PyErr_Occurred()) SWIG_fail;
18879 }
18880 {
18881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18882 }
18883 return resultobj;
18884 fail:
18885 return NULL;
18886 }
18887
18888
18889 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18890 PyObject *resultobj;
18891 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18892 bool result;
18893 PyObject * obj0 = 0 ;
18894 char *kwnames[] = {
18895 (char *) "self", NULL
18896 };
18897
18898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18900 if (SWIG_arg_fail(1)) SWIG_fail;
18901 {
18902 PyThreadState* __tstate = wxPyBeginAllowThreads();
18903 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18904
18905 wxPyEndAllowThreads(__tstate);
18906 if (PyErr_Occurred()) SWIG_fail;
18907 }
18908 {
18909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18910 }
18911 return resultobj;
18912 fail:
18913 return NULL;
18914 }
18915
18916
18917 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
18918 PyObject *resultobj;
18919 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18920 bool result;
18921 PyObject * obj0 = 0 ;
18922 char *kwnames[] = {
18923 (char *) "self", NULL
18924 };
18925
18926 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
18927 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18928 if (SWIG_arg_fail(1)) SWIG_fail;
18929 {
18930 PyThreadState* __tstate = wxPyBeginAllowThreads();
18931 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
18932
18933 wxPyEndAllowThreads(__tstate);
18934 if (PyErr_Occurred()) SWIG_fail;
18935 }
18936 {
18937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18938 }
18939 return resultobj;
18940 fail:
18941 return NULL;
18942 }
18943
18944
18945 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
18946 PyObject *resultobj;
18947 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18948 bool result;
18949 PyObject * obj0 = 0 ;
18950 char *kwnames[] = {
18951 (char *) "self", NULL
18952 };
18953
18954 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
18955 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18956 if (SWIG_arg_fail(1)) SWIG_fail;
18957 {
18958 PyThreadState* __tstate = wxPyBeginAllowThreads();
18959 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18960
18961 wxPyEndAllowThreads(__tstate);
18962 if (PyErr_Occurred()) SWIG_fail;
18963 }
18964 {
18965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18966 }
18967 return resultobj;
18968 fail:
18969 return NULL;
18970 }
18971
18972
18973 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18974 PyObject *resultobj;
18975 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18976 bool result;
18977 PyObject * obj0 = 0 ;
18978 char *kwnames[] = {
18979 (char *) "self", NULL
18980 };
18981
18982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18984 if (SWIG_arg_fail(1)) SWIG_fail;
18985 {
18986 PyThreadState* __tstate = wxPyBeginAllowThreads();
18987 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18988
18989 wxPyEndAllowThreads(__tstate);
18990 if (PyErr_Occurred()) SWIG_fail;
18991 }
18992 {
18993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18994 }
18995 return resultobj;
18996 fail:
18997 return NULL;
18998 }
18999
19000
19001 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
19002 PyObject *resultobj;
19003 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19004 bool result;
19005 PyObject * obj0 = 0 ;
19006 char *kwnames[] = {
19007 (char *) "self", NULL
19008 };
19009
19010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
19011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19012 if (SWIG_arg_fail(1)) SWIG_fail;
19013 {
19014 PyThreadState* __tstate = wxPyBeginAllowThreads();
19015 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
19016
19017 wxPyEndAllowThreads(__tstate);
19018 if (PyErr_Occurred()) SWIG_fail;
19019 }
19020 {
19021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19022 }
19023 return resultobj;
19024 fail:
19025 return NULL;
19026 }
19027
19028
19029 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19030 PyObject *resultobj;
19031 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19032 int result;
19033 PyObject * obj0 = 0 ;
19034 char *kwnames[] = {
19035 (char *) "self", NULL
19036 };
19037
19038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
19039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19040 if (SWIG_arg_fail(1)) SWIG_fail;
19041 {
19042 PyThreadState* __tstate = wxPyBeginAllowThreads();
19043 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
19044
19045 wxPyEndAllowThreads(__tstate);
19046 if (PyErr_Occurred()) SWIG_fail;
19047 }
19048 {
19049 resultobj = SWIG_From_int((int)(result));
19050 }
19051 return resultobj;
19052 fail:
19053 return NULL;
19054 }
19055
19056
19057 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
19058 PyObject *resultobj;
19059 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19060 int result;
19061 PyObject * obj0 = 0 ;
19062 char *kwnames[] = {
19063 (char *) "self", NULL
19064 };
19065
19066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
19067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19068 if (SWIG_arg_fail(1)) SWIG_fail;
19069 {
19070 PyThreadState* __tstate = wxPyBeginAllowThreads();
19071 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
19072
19073 wxPyEndAllowThreads(__tstate);
19074 if (PyErr_Occurred()) SWIG_fail;
19075 }
19076 {
19077 resultobj = SWIG_From_int((int)(result));
19078 }
19079 return resultobj;
19080 fail:
19081 return NULL;
19082 }
19083
19084
19085 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
19086 PyObject *resultobj;
19087 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19088 unsigned int result;
19089 PyObject * obj0 = 0 ;
19090 char *kwnames[] = {
19091 (char *) "self", NULL
19092 };
19093
19094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
19095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19096 if (SWIG_arg_fail(1)) SWIG_fail;
19097 {
19098 PyThreadState* __tstate = wxPyBeginAllowThreads();
19099 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
19100
19101 wxPyEndAllowThreads(__tstate);
19102 if (PyErr_Occurred()) SWIG_fail;
19103 }
19104 {
19105 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19106 }
19107 return resultobj;
19108 fail:
19109 return NULL;
19110 }
19111
19112
19113 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
19114 PyObject *resultobj;
19115 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19116 unsigned int result;
19117 PyObject * obj0 = 0 ;
19118 char *kwnames[] = {
19119 (char *) "self", NULL
19120 };
19121
19122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
19123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19124 if (SWIG_arg_fail(1)) SWIG_fail;
19125 {
19126 PyThreadState* __tstate = wxPyBeginAllowThreads();
19127 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
19128
19129 wxPyEndAllowThreads(__tstate);
19130 if (PyErr_Occurred()) SWIG_fail;
19131 }
19132 {
19133 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19134 }
19135 return resultobj;
19136 fail:
19137 return NULL;
19138 }
19139
19140
19141 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19142 PyObject *resultobj;
19143 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19144 wxPoint result;
19145 PyObject * obj0 = 0 ;
19146 char *kwnames[] = {
19147 (char *) "self", NULL
19148 };
19149
19150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
19151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19152 if (SWIG_arg_fail(1)) SWIG_fail;
19153 {
19154 PyThreadState* __tstate = wxPyBeginAllowThreads();
19155 result = (arg1)->GetPosition();
19156
19157 wxPyEndAllowThreads(__tstate);
19158 if (PyErr_Occurred()) SWIG_fail;
19159 }
19160 {
19161 wxPoint * resultptr;
19162 resultptr = new wxPoint((wxPoint &)(result));
19163 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19164 }
19165 return resultobj;
19166 fail:
19167 return NULL;
19168 }
19169
19170
19171 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
19172 PyObject *resultobj;
19173 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19174 long *arg2 = (long *) 0 ;
19175 long *arg3 = (long *) 0 ;
19176 long temp2 ;
19177 int res2 = 0 ;
19178 long temp3 ;
19179 int res3 = 0 ;
19180 PyObject * obj0 = 0 ;
19181 char *kwnames[] = {
19182 (char *) "self", NULL
19183 };
19184
19185 arg2 = &temp2; res2 = SWIG_NEWOBJ;
19186 arg3 = &temp3; res3 = SWIG_NEWOBJ;
19187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
19188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19189 if (SWIG_arg_fail(1)) SWIG_fail;
19190 {
19191 PyThreadState* __tstate = wxPyBeginAllowThreads();
19192 (arg1)->GetPosition(arg2,arg3);
19193
19194 wxPyEndAllowThreads(__tstate);
19195 if (PyErr_Occurred()) SWIG_fail;
19196 }
19197 Py_INCREF(Py_None); resultobj = Py_None;
19198 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
19199 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
19200 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
19201 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
19202 return resultobj;
19203 fail:
19204 return NULL;
19205 }
19206
19207
19208 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
19209 PyObject *resultobj;
19210 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19211 int result;
19212 PyObject * obj0 = 0 ;
19213 char *kwnames[] = {
19214 (char *) "self", NULL
19215 };
19216
19217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
19218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19219 if (SWIG_arg_fail(1)) SWIG_fail;
19220 {
19221 PyThreadState* __tstate = wxPyBeginAllowThreads();
19222 result = (int)((wxKeyEvent const *)arg1)->GetX();
19223
19224 wxPyEndAllowThreads(__tstate);
19225 if (PyErr_Occurred()) SWIG_fail;
19226 }
19227 {
19228 resultobj = SWIG_From_int((int)(result));
19229 }
19230 return resultobj;
19231 fail:
19232 return NULL;
19233 }
19234
19235
19236 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
19237 PyObject *resultobj;
19238 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19239 int result;
19240 PyObject * obj0 = 0 ;
19241 char *kwnames[] = {
19242 (char *) "self", NULL
19243 };
19244
19245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
19246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19247 if (SWIG_arg_fail(1)) SWIG_fail;
19248 {
19249 PyThreadState* __tstate = wxPyBeginAllowThreads();
19250 result = (int)((wxKeyEvent const *)arg1)->GetY();
19251
19252 wxPyEndAllowThreads(__tstate);
19253 if (PyErr_Occurred()) SWIG_fail;
19254 }
19255 {
19256 resultobj = SWIG_From_int((int)(result));
19257 }
19258 return resultobj;
19259 fail:
19260 return NULL;
19261 }
19262
19263
19264 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
19265 PyObject *resultobj;
19266 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19267 int arg2 ;
19268 PyObject * obj0 = 0 ;
19269 PyObject * obj1 = 0 ;
19270 char *kwnames[] = {
19271 (char *) "self",(char *) "m_x", NULL
19272 };
19273
19274 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
19275 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19276 if (SWIG_arg_fail(1)) SWIG_fail;
19277 {
19278 arg2 = (int)(SWIG_As_int(obj1));
19279 if (SWIG_arg_fail(2)) SWIG_fail;
19280 }
19281 if (arg1) (arg1)->m_x = arg2;
19282
19283 Py_INCREF(Py_None); resultobj = Py_None;
19284 return resultobj;
19285 fail:
19286 return NULL;
19287 }
19288
19289
19290 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
19291 PyObject *resultobj;
19292 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19293 int result;
19294 PyObject * obj0 = 0 ;
19295 char *kwnames[] = {
19296 (char *) "self", NULL
19297 };
19298
19299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
19300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19301 if (SWIG_arg_fail(1)) SWIG_fail;
19302 result = (int) ((arg1)->m_x);
19303
19304 {
19305 resultobj = SWIG_From_int((int)(result));
19306 }
19307 return resultobj;
19308 fail:
19309 return NULL;
19310 }
19311
19312
19313 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
19314 PyObject *resultobj;
19315 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19316 int arg2 ;
19317 PyObject * obj0 = 0 ;
19318 PyObject * obj1 = 0 ;
19319 char *kwnames[] = {
19320 (char *) "self",(char *) "m_y", NULL
19321 };
19322
19323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
19324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19325 if (SWIG_arg_fail(1)) SWIG_fail;
19326 {
19327 arg2 = (int)(SWIG_As_int(obj1));
19328 if (SWIG_arg_fail(2)) SWIG_fail;
19329 }
19330 if (arg1) (arg1)->m_y = arg2;
19331
19332 Py_INCREF(Py_None); resultobj = Py_None;
19333 return resultobj;
19334 fail:
19335 return NULL;
19336 }
19337
19338
19339 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
19340 PyObject *resultobj;
19341 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19342 int result;
19343 PyObject * obj0 = 0 ;
19344 char *kwnames[] = {
19345 (char *) "self", NULL
19346 };
19347
19348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
19349 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19350 if (SWIG_arg_fail(1)) SWIG_fail;
19351 result = (int) ((arg1)->m_y);
19352
19353 {
19354 resultobj = SWIG_From_int((int)(result));
19355 }
19356 return resultobj;
19357 fail:
19358 return NULL;
19359 }
19360
19361
19362 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19363 PyObject *resultobj;
19364 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19365 long arg2 ;
19366 PyObject * obj0 = 0 ;
19367 PyObject * obj1 = 0 ;
19368 char *kwnames[] = {
19369 (char *) "self",(char *) "m_keyCode", NULL
19370 };
19371
19372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
19373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19374 if (SWIG_arg_fail(1)) SWIG_fail;
19375 {
19376 arg2 = (long)(SWIG_As_long(obj1));
19377 if (SWIG_arg_fail(2)) SWIG_fail;
19378 }
19379 if (arg1) (arg1)->m_keyCode = arg2;
19380
19381 Py_INCREF(Py_None); resultobj = Py_None;
19382 return resultobj;
19383 fail:
19384 return NULL;
19385 }
19386
19387
19388 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19389 PyObject *resultobj;
19390 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19391 long result;
19392 PyObject * obj0 = 0 ;
19393 char *kwnames[] = {
19394 (char *) "self", NULL
19395 };
19396
19397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
19398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19399 if (SWIG_arg_fail(1)) SWIG_fail;
19400 result = (long) ((arg1)->m_keyCode);
19401
19402 {
19403 resultobj = SWIG_From_long((long)(result));
19404 }
19405 return resultobj;
19406 fail:
19407 return NULL;
19408 }
19409
19410
19411 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19412 PyObject *resultobj;
19413 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19414 bool arg2 ;
19415 PyObject * obj0 = 0 ;
19416 PyObject * obj1 = 0 ;
19417 char *kwnames[] = {
19418 (char *) "self",(char *) "m_controlDown", NULL
19419 };
19420
19421 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
19422 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19423 if (SWIG_arg_fail(1)) SWIG_fail;
19424 {
19425 arg2 = (bool)(SWIG_As_bool(obj1));
19426 if (SWIG_arg_fail(2)) SWIG_fail;
19427 }
19428 if (arg1) (arg1)->m_controlDown = arg2;
19429
19430 Py_INCREF(Py_None); resultobj = Py_None;
19431 return resultobj;
19432 fail:
19433 return NULL;
19434 }
19435
19436
19437 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19438 PyObject *resultobj;
19439 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19440 bool result;
19441 PyObject * obj0 = 0 ;
19442 char *kwnames[] = {
19443 (char *) "self", NULL
19444 };
19445
19446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
19447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19448 if (SWIG_arg_fail(1)) SWIG_fail;
19449 result = (bool) ((arg1)->m_controlDown);
19450
19451 {
19452 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19453 }
19454 return resultobj;
19455 fail:
19456 return NULL;
19457 }
19458
19459
19460 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19461 PyObject *resultobj;
19462 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19463 bool arg2 ;
19464 PyObject * obj0 = 0 ;
19465 PyObject * obj1 = 0 ;
19466 char *kwnames[] = {
19467 (char *) "self",(char *) "m_shiftDown", NULL
19468 };
19469
19470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
19471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19472 if (SWIG_arg_fail(1)) SWIG_fail;
19473 {
19474 arg2 = (bool)(SWIG_As_bool(obj1));
19475 if (SWIG_arg_fail(2)) SWIG_fail;
19476 }
19477 if (arg1) (arg1)->m_shiftDown = arg2;
19478
19479 Py_INCREF(Py_None); resultobj = Py_None;
19480 return resultobj;
19481 fail:
19482 return NULL;
19483 }
19484
19485
19486 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19487 PyObject *resultobj;
19488 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19489 bool result;
19490 PyObject * obj0 = 0 ;
19491 char *kwnames[] = {
19492 (char *) "self", NULL
19493 };
19494
19495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
19496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19497 if (SWIG_arg_fail(1)) SWIG_fail;
19498 result = (bool) ((arg1)->m_shiftDown);
19499
19500 {
19501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19502 }
19503 return resultobj;
19504 fail:
19505 return NULL;
19506 }
19507
19508
19509 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19510 PyObject *resultobj;
19511 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19512 bool arg2 ;
19513 PyObject * obj0 = 0 ;
19514 PyObject * obj1 = 0 ;
19515 char *kwnames[] = {
19516 (char *) "self",(char *) "m_altDown", NULL
19517 };
19518
19519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19521 if (SWIG_arg_fail(1)) SWIG_fail;
19522 {
19523 arg2 = (bool)(SWIG_As_bool(obj1));
19524 if (SWIG_arg_fail(2)) SWIG_fail;
19525 }
19526 if (arg1) (arg1)->m_altDown = arg2;
19527
19528 Py_INCREF(Py_None); resultobj = Py_None;
19529 return resultobj;
19530 fail:
19531 return NULL;
19532 }
19533
19534
19535 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19536 PyObject *resultobj;
19537 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19538 bool result;
19539 PyObject * obj0 = 0 ;
19540 char *kwnames[] = {
19541 (char *) "self", NULL
19542 };
19543
19544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19546 if (SWIG_arg_fail(1)) SWIG_fail;
19547 result = (bool) ((arg1)->m_altDown);
19548
19549 {
19550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19551 }
19552 return resultobj;
19553 fail:
19554 return NULL;
19555 }
19556
19557
19558 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19559 PyObject *resultobj;
19560 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19561 bool arg2 ;
19562 PyObject * obj0 = 0 ;
19563 PyObject * obj1 = 0 ;
19564 char *kwnames[] = {
19565 (char *) "self",(char *) "m_metaDown", NULL
19566 };
19567
19568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19570 if (SWIG_arg_fail(1)) SWIG_fail;
19571 {
19572 arg2 = (bool)(SWIG_As_bool(obj1));
19573 if (SWIG_arg_fail(2)) SWIG_fail;
19574 }
19575 if (arg1) (arg1)->m_metaDown = arg2;
19576
19577 Py_INCREF(Py_None); resultobj = Py_None;
19578 return resultobj;
19579 fail:
19580 return NULL;
19581 }
19582
19583
19584 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19585 PyObject *resultobj;
19586 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19587 bool result;
19588 PyObject * obj0 = 0 ;
19589 char *kwnames[] = {
19590 (char *) "self", NULL
19591 };
19592
19593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19595 if (SWIG_arg_fail(1)) SWIG_fail;
19596 result = (bool) ((arg1)->m_metaDown);
19597
19598 {
19599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19600 }
19601 return resultobj;
19602 fail:
19603 return NULL;
19604 }
19605
19606
19607 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19608 PyObject *resultobj;
19609 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19610 bool arg2 ;
19611 PyObject * obj0 = 0 ;
19612 PyObject * obj1 = 0 ;
19613 char *kwnames[] = {
19614 (char *) "self",(char *) "m_scanCode", NULL
19615 };
19616
19617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19619 if (SWIG_arg_fail(1)) SWIG_fail;
19620 {
19621 arg2 = (bool)(SWIG_As_bool(obj1));
19622 if (SWIG_arg_fail(2)) SWIG_fail;
19623 }
19624 if (arg1) (arg1)->m_scanCode = arg2;
19625
19626 Py_INCREF(Py_None); resultobj = Py_None;
19627 return resultobj;
19628 fail:
19629 return NULL;
19630 }
19631
19632
19633 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19634 PyObject *resultobj;
19635 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19636 bool result;
19637 PyObject * obj0 = 0 ;
19638 char *kwnames[] = {
19639 (char *) "self", NULL
19640 };
19641
19642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19644 if (SWIG_arg_fail(1)) SWIG_fail;
19645 result = (bool) ((arg1)->m_scanCode);
19646
19647 {
19648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19649 }
19650 return resultobj;
19651 fail:
19652 return NULL;
19653 }
19654
19655
19656 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19657 PyObject *resultobj;
19658 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19659 unsigned int arg2 ;
19660 PyObject * obj0 = 0 ;
19661 PyObject * obj1 = 0 ;
19662 char *kwnames[] = {
19663 (char *) "self",(char *) "m_rawCode", NULL
19664 };
19665
19666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19668 if (SWIG_arg_fail(1)) SWIG_fail;
19669 {
19670 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19671 if (SWIG_arg_fail(2)) SWIG_fail;
19672 }
19673 if (arg1) (arg1)->m_rawCode = arg2;
19674
19675 Py_INCREF(Py_None); resultobj = Py_None;
19676 return resultobj;
19677 fail:
19678 return NULL;
19679 }
19680
19681
19682 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19683 PyObject *resultobj;
19684 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19685 unsigned int result;
19686 PyObject * obj0 = 0 ;
19687 char *kwnames[] = {
19688 (char *) "self", NULL
19689 };
19690
19691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19693 if (SWIG_arg_fail(1)) SWIG_fail;
19694 result = (unsigned int) ((arg1)->m_rawCode);
19695
19696 {
19697 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19698 }
19699 return resultobj;
19700 fail:
19701 return NULL;
19702 }
19703
19704
19705 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19706 PyObject *resultobj;
19707 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19708 unsigned int arg2 ;
19709 PyObject * obj0 = 0 ;
19710 PyObject * obj1 = 0 ;
19711 char *kwnames[] = {
19712 (char *) "self",(char *) "m_rawFlags", NULL
19713 };
19714
19715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19717 if (SWIG_arg_fail(1)) SWIG_fail;
19718 {
19719 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19720 if (SWIG_arg_fail(2)) SWIG_fail;
19721 }
19722 if (arg1) (arg1)->m_rawFlags = arg2;
19723
19724 Py_INCREF(Py_None); resultobj = Py_None;
19725 return resultobj;
19726 fail:
19727 return NULL;
19728 }
19729
19730
19731 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19732 PyObject *resultobj;
19733 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19734 unsigned int result;
19735 PyObject * obj0 = 0 ;
19736 char *kwnames[] = {
19737 (char *) "self", NULL
19738 };
19739
19740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19742 if (SWIG_arg_fail(1)) SWIG_fail;
19743 result = (unsigned int) ((arg1)->m_rawFlags);
19744
19745 {
19746 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19747 }
19748 return resultobj;
19749 fail:
19750 return NULL;
19751 }
19752
19753
19754 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19755 PyObject *obj;
19756 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19757 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19758 Py_INCREF(obj);
19759 return Py_BuildValue((char *)"");
19760 }
19761 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19762 PyObject *resultobj;
19763 wxSize const &arg1_defvalue = wxDefaultSize ;
19764 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19765 int arg2 = (int) 0 ;
19766 wxSizeEvent *result;
19767 wxSize temp1 ;
19768 PyObject * obj0 = 0 ;
19769 PyObject * obj1 = 0 ;
19770 char *kwnames[] = {
19771 (char *) "sz",(char *) "winid", NULL
19772 };
19773
19774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19775 if (obj0) {
19776 {
19777 arg1 = &temp1;
19778 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19779 }
19780 }
19781 if (obj1) {
19782 {
19783 arg2 = (int)(SWIG_As_int(obj1));
19784 if (SWIG_arg_fail(2)) SWIG_fail;
19785 }
19786 }
19787 {
19788 PyThreadState* __tstate = wxPyBeginAllowThreads();
19789 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19790
19791 wxPyEndAllowThreads(__tstate);
19792 if (PyErr_Occurred()) SWIG_fail;
19793 }
19794 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19795 return resultobj;
19796 fail:
19797 return NULL;
19798 }
19799
19800
19801 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19802 PyObject *resultobj;
19803 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19804 wxSize result;
19805 PyObject * obj0 = 0 ;
19806 char *kwnames[] = {
19807 (char *) "self", NULL
19808 };
19809
19810 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19811 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19812 if (SWIG_arg_fail(1)) SWIG_fail;
19813 {
19814 PyThreadState* __tstate = wxPyBeginAllowThreads();
19815 result = ((wxSizeEvent const *)arg1)->GetSize();
19816
19817 wxPyEndAllowThreads(__tstate);
19818 if (PyErr_Occurred()) SWIG_fail;
19819 }
19820 {
19821 wxSize * resultptr;
19822 resultptr = new wxSize((wxSize &)(result));
19823 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19824 }
19825 return resultobj;
19826 fail:
19827 return NULL;
19828 }
19829
19830
19831 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19832 PyObject *resultobj;
19833 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19834 wxRect result;
19835 PyObject * obj0 = 0 ;
19836 char *kwnames[] = {
19837 (char *) "self", NULL
19838 };
19839
19840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19842 if (SWIG_arg_fail(1)) SWIG_fail;
19843 {
19844 PyThreadState* __tstate = wxPyBeginAllowThreads();
19845 result = ((wxSizeEvent const *)arg1)->GetRect();
19846
19847 wxPyEndAllowThreads(__tstate);
19848 if (PyErr_Occurred()) SWIG_fail;
19849 }
19850 {
19851 wxRect * resultptr;
19852 resultptr = new wxRect((wxRect &)(result));
19853 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19854 }
19855 return resultobj;
19856 fail:
19857 return NULL;
19858 }
19859
19860
19861 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19862 PyObject *resultobj;
19863 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19864 wxRect arg2 ;
19865 PyObject * obj0 = 0 ;
19866 PyObject * obj1 = 0 ;
19867 char *kwnames[] = {
19868 (char *) "self",(char *) "rect", NULL
19869 };
19870
19871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19873 if (SWIG_arg_fail(1)) SWIG_fail;
19874 {
19875 wxRect * argp;
19876 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19877 if (SWIG_arg_fail(2)) SWIG_fail;
19878 if (argp == NULL) {
19879 SWIG_null_ref("wxRect");
19880 }
19881 if (SWIG_arg_fail(2)) SWIG_fail;
19882 arg2 = *argp;
19883 }
19884 {
19885 PyThreadState* __tstate = wxPyBeginAllowThreads();
19886 (arg1)->SetRect(arg2);
19887
19888 wxPyEndAllowThreads(__tstate);
19889 if (PyErr_Occurred()) SWIG_fail;
19890 }
19891 Py_INCREF(Py_None); resultobj = Py_None;
19892 return resultobj;
19893 fail:
19894 return NULL;
19895 }
19896
19897
19898 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19899 PyObject *resultobj;
19900 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19901 wxSize arg2 ;
19902 PyObject * obj0 = 0 ;
19903 PyObject * obj1 = 0 ;
19904 char *kwnames[] = {
19905 (char *) "self",(char *) "size", NULL
19906 };
19907
19908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19910 if (SWIG_arg_fail(1)) SWIG_fail;
19911 {
19912 wxSize * argp;
19913 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19914 if (SWIG_arg_fail(2)) SWIG_fail;
19915 if (argp == NULL) {
19916 SWIG_null_ref("wxSize");
19917 }
19918 if (SWIG_arg_fail(2)) SWIG_fail;
19919 arg2 = *argp;
19920 }
19921 {
19922 PyThreadState* __tstate = wxPyBeginAllowThreads();
19923 wxSizeEvent_SetSize(arg1,arg2);
19924
19925 wxPyEndAllowThreads(__tstate);
19926 if (PyErr_Occurred()) SWIG_fail;
19927 }
19928 Py_INCREF(Py_None); resultobj = Py_None;
19929 return resultobj;
19930 fail:
19931 return NULL;
19932 }
19933
19934
19935 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
19936 PyObject *resultobj;
19937 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19938 wxSize *arg2 = (wxSize *) 0 ;
19939 PyObject * obj0 = 0 ;
19940 PyObject * obj1 = 0 ;
19941 char *kwnames[] = {
19942 (char *) "self",(char *) "m_size", NULL
19943 };
19944
19945 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
19946 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19947 if (SWIG_arg_fail(1)) SWIG_fail;
19948 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
19949 if (SWIG_arg_fail(2)) SWIG_fail;
19950 if (arg1) (arg1)->m_size = *arg2;
19951
19952 Py_INCREF(Py_None); resultobj = Py_None;
19953 return resultobj;
19954 fail:
19955 return NULL;
19956 }
19957
19958
19959 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19960 PyObject *resultobj;
19961 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19962 wxSize *result;
19963 PyObject * obj0 = 0 ;
19964 char *kwnames[] = {
19965 (char *) "self", NULL
19966 };
19967
19968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19970 if (SWIG_arg_fail(1)) SWIG_fail;
19971 result = (wxSize *)& ((arg1)->m_size);
19972
19973 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19974 return resultobj;
19975 fail:
19976 return NULL;
19977 }
19978
19979
19980 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19981 PyObject *resultobj;
19982 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19983 wxRect *arg2 = (wxRect *) 0 ;
19984 PyObject * obj0 = 0 ;
19985 PyObject * obj1 = 0 ;
19986 char *kwnames[] = {
19987 (char *) "self",(char *) "m_rect", NULL
19988 };
19989
19990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19992 if (SWIG_arg_fail(1)) SWIG_fail;
19993 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19994 if (SWIG_arg_fail(2)) SWIG_fail;
19995 if (arg1) (arg1)->m_rect = *arg2;
19996
19997 Py_INCREF(Py_None); resultobj = Py_None;
19998 return resultobj;
19999 fail:
20000 return NULL;
20001 }
20002
20003
20004 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
20005 PyObject *resultobj;
20006 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
20007 wxRect *result;
20008 PyObject * obj0 = 0 ;
20009 char *kwnames[] = {
20010 (char *) "self", NULL
20011 };
20012
20013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
20014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
20015 if (SWIG_arg_fail(1)) SWIG_fail;
20016 result = (wxRect *)& ((arg1)->m_rect);
20017
20018 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
20019 return resultobj;
20020 fail:
20021 return NULL;
20022 }
20023
20024
20025 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
20026 PyObject *obj;
20027 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20028 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
20029 Py_INCREF(obj);
20030 return Py_BuildValue((char *)"");
20031 }
20032 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20033 PyObject *resultobj;
20034 wxPoint const &arg1_defvalue = wxDefaultPosition ;
20035 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
20036 int arg2 = (int) 0 ;
20037 wxMoveEvent *result;
20038 wxPoint temp1 ;
20039 PyObject * obj0 = 0 ;
20040 PyObject * obj1 = 0 ;
20041 char *kwnames[] = {
20042 (char *) "pos",(char *) "winid", NULL
20043 };
20044
20045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
20046 if (obj0) {
20047 {
20048 arg1 = &temp1;
20049 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
20050 }
20051 }
20052 if (obj1) {
20053 {
20054 arg2 = (int)(SWIG_As_int(obj1));
20055 if (SWIG_arg_fail(2)) SWIG_fail;
20056 }
20057 }
20058 {
20059 PyThreadState* __tstate = wxPyBeginAllowThreads();
20060 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
20061
20062 wxPyEndAllowThreads(__tstate);
20063 if (PyErr_Occurred()) SWIG_fail;
20064 }
20065 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
20066 return resultobj;
20067 fail:
20068 return NULL;
20069 }
20070
20071
20072 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20073 PyObject *resultobj;
20074 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20075 wxPoint result;
20076 PyObject * obj0 = 0 ;
20077 char *kwnames[] = {
20078 (char *) "self", NULL
20079 };
20080
20081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
20082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20083 if (SWIG_arg_fail(1)) SWIG_fail;
20084 {
20085 PyThreadState* __tstate = wxPyBeginAllowThreads();
20086 result = ((wxMoveEvent const *)arg1)->GetPosition();
20087
20088 wxPyEndAllowThreads(__tstate);
20089 if (PyErr_Occurred()) SWIG_fail;
20090 }
20091 {
20092 wxPoint * resultptr;
20093 resultptr = new wxPoint((wxPoint &)(result));
20094 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20095 }
20096 return resultobj;
20097 fail:
20098 return NULL;
20099 }
20100
20101
20102 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20103 PyObject *resultobj;
20104 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20105 wxRect result;
20106 PyObject * obj0 = 0 ;
20107 char *kwnames[] = {
20108 (char *) "self", NULL
20109 };
20110
20111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
20112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20113 if (SWIG_arg_fail(1)) SWIG_fail;
20114 {
20115 PyThreadState* __tstate = wxPyBeginAllowThreads();
20116 result = ((wxMoveEvent const *)arg1)->GetRect();
20117
20118 wxPyEndAllowThreads(__tstate);
20119 if (PyErr_Occurred()) SWIG_fail;
20120 }
20121 {
20122 wxRect * resultptr;
20123 resultptr = new wxRect((wxRect &)(result));
20124 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
20125 }
20126 return resultobj;
20127 fail:
20128 return NULL;
20129 }
20130
20131
20132 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
20133 PyObject *resultobj;
20134 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20135 wxRect *arg2 = 0 ;
20136 wxRect temp2 ;
20137 PyObject * obj0 = 0 ;
20138 PyObject * obj1 = 0 ;
20139 char *kwnames[] = {
20140 (char *) "self",(char *) "rect", NULL
20141 };
20142
20143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
20144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20145 if (SWIG_arg_fail(1)) SWIG_fail;
20146 {
20147 arg2 = &temp2;
20148 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
20149 }
20150 {
20151 PyThreadState* __tstate = wxPyBeginAllowThreads();
20152 (arg1)->SetRect((wxRect const &)*arg2);
20153
20154 wxPyEndAllowThreads(__tstate);
20155 if (PyErr_Occurred()) SWIG_fail;
20156 }
20157 Py_INCREF(Py_None); resultobj = Py_None;
20158 return resultobj;
20159 fail:
20160 return NULL;
20161 }
20162
20163
20164 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20165 PyObject *resultobj;
20166 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
20167 wxPoint *arg2 = 0 ;
20168 wxPoint temp2 ;
20169 PyObject * obj0 = 0 ;
20170 PyObject * obj1 = 0 ;
20171 char *kwnames[] = {
20172 (char *) "self",(char *) "pos", NULL
20173 };
20174
20175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
20176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
20177 if (SWIG_arg_fail(1)) SWIG_fail;
20178 {
20179 arg2 = &temp2;
20180 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
20181 }
20182 {
20183 PyThreadState* __tstate = wxPyBeginAllowThreads();
20184 (arg1)->SetPosition((wxPoint const &)*arg2);
20185
20186 wxPyEndAllowThreads(__tstate);
20187 if (PyErr_Occurred()) SWIG_fail;
20188 }
20189 Py_INCREF(Py_None); resultobj = Py_None;
20190 return resultobj;
20191 fail:
20192 return NULL;
20193 }
20194
20195
20196 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
20197 PyObject *obj;
20198 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20199 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
20200 Py_INCREF(obj);
20201 return Py_BuildValue((char *)"");
20202 }
20203 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20204 PyObject *resultobj;
20205 int arg1 = (int) 0 ;
20206 wxPaintEvent *result;
20207 PyObject * obj0 = 0 ;
20208 char *kwnames[] = {
20209 (char *) "Id", NULL
20210 };
20211
20212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
20213 if (obj0) {
20214 {
20215 arg1 = (int)(SWIG_As_int(obj0));
20216 if (SWIG_arg_fail(1)) SWIG_fail;
20217 }
20218 }
20219 {
20220 PyThreadState* __tstate = wxPyBeginAllowThreads();
20221 result = (wxPaintEvent *)new wxPaintEvent(arg1);
20222
20223 wxPyEndAllowThreads(__tstate);
20224 if (PyErr_Occurred()) SWIG_fail;
20225 }
20226 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
20227 return resultobj;
20228 fail:
20229 return NULL;
20230 }
20231
20232
20233 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
20234 PyObject *obj;
20235 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20236 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
20237 Py_INCREF(obj);
20238 return Py_BuildValue((char *)"");
20239 }
20240 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20241 PyObject *resultobj;
20242 int arg1 = (int) 0 ;
20243 wxNcPaintEvent *result;
20244 PyObject * obj0 = 0 ;
20245 char *kwnames[] = {
20246 (char *) "winid", NULL
20247 };
20248
20249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
20250 if (obj0) {
20251 {
20252 arg1 = (int)(SWIG_As_int(obj0));
20253 if (SWIG_arg_fail(1)) SWIG_fail;
20254 }
20255 }
20256 {
20257 PyThreadState* __tstate = wxPyBeginAllowThreads();
20258 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
20259
20260 wxPyEndAllowThreads(__tstate);
20261 if (PyErr_Occurred()) SWIG_fail;
20262 }
20263 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
20264 return resultobj;
20265 fail:
20266 return NULL;
20267 }
20268
20269
20270 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
20271 PyObject *obj;
20272 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20273 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
20274 Py_INCREF(obj);
20275 return Py_BuildValue((char *)"");
20276 }
20277 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20278 PyObject *resultobj;
20279 int arg1 = (int) 0 ;
20280 wxDC *arg2 = (wxDC *) NULL ;
20281 wxEraseEvent *result;
20282 PyObject * obj0 = 0 ;
20283 PyObject * obj1 = 0 ;
20284 char *kwnames[] = {
20285 (char *) "Id",(char *) "dc", NULL
20286 };
20287
20288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
20289 if (obj0) {
20290 {
20291 arg1 = (int)(SWIG_As_int(obj0));
20292 if (SWIG_arg_fail(1)) SWIG_fail;
20293 }
20294 }
20295 if (obj1) {
20296 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
20297 if (SWIG_arg_fail(2)) SWIG_fail;
20298 }
20299 {
20300 PyThreadState* __tstate = wxPyBeginAllowThreads();
20301 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
20302
20303 wxPyEndAllowThreads(__tstate);
20304 if (PyErr_Occurred()) SWIG_fail;
20305 }
20306 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
20307 return resultobj;
20308 fail:
20309 return NULL;
20310 }
20311
20312
20313 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
20314 PyObject *resultobj;
20315 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
20316 wxDC *result;
20317 PyObject * obj0 = 0 ;
20318 char *kwnames[] = {
20319 (char *) "self", NULL
20320 };
20321
20322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
20323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
20324 if (SWIG_arg_fail(1)) SWIG_fail;
20325 {
20326 PyThreadState* __tstate = wxPyBeginAllowThreads();
20327 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
20328
20329 wxPyEndAllowThreads(__tstate);
20330 if (PyErr_Occurred()) SWIG_fail;
20331 }
20332 {
20333 resultobj = wxPyMake_wxObject(result, 0);
20334 }
20335 return resultobj;
20336 fail:
20337 return NULL;
20338 }
20339
20340
20341 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
20342 PyObject *obj;
20343 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20344 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
20345 Py_INCREF(obj);
20346 return Py_BuildValue((char *)"");
20347 }
20348 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20349 PyObject *resultobj;
20350 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20351 int arg2 = (int) 0 ;
20352 wxFocusEvent *result;
20353 PyObject * obj0 = 0 ;
20354 PyObject * obj1 = 0 ;
20355 char *kwnames[] = {
20356 (char *) "type",(char *) "winid", NULL
20357 };
20358
20359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
20360 if (obj0) {
20361 {
20362 arg1 = (wxEventType)(SWIG_As_int(obj0));
20363 if (SWIG_arg_fail(1)) SWIG_fail;
20364 }
20365 }
20366 if (obj1) {
20367 {
20368 arg2 = (int)(SWIG_As_int(obj1));
20369 if (SWIG_arg_fail(2)) SWIG_fail;
20370 }
20371 }
20372 {
20373 PyThreadState* __tstate = wxPyBeginAllowThreads();
20374 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
20375
20376 wxPyEndAllowThreads(__tstate);
20377 if (PyErr_Occurred()) SWIG_fail;
20378 }
20379 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
20380 return resultobj;
20381 fail:
20382 return NULL;
20383 }
20384
20385
20386 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20387 PyObject *resultobj;
20388 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20389 wxWindow *result;
20390 PyObject * obj0 = 0 ;
20391 char *kwnames[] = {
20392 (char *) "self", NULL
20393 };
20394
20395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20397 if (SWIG_arg_fail(1)) SWIG_fail;
20398 {
20399 PyThreadState* __tstate = wxPyBeginAllowThreads();
20400 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
20401
20402 wxPyEndAllowThreads(__tstate);
20403 if (PyErr_Occurred()) SWIG_fail;
20404 }
20405 {
20406 resultobj = wxPyMake_wxObject(result, 0);
20407 }
20408 return resultobj;
20409 fail:
20410 return NULL;
20411 }
20412
20413
20414 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20415 PyObject *resultobj;
20416 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
20417 wxWindow *arg2 = (wxWindow *) 0 ;
20418 PyObject * obj0 = 0 ;
20419 PyObject * obj1 = 0 ;
20420 char *kwnames[] = {
20421 (char *) "self",(char *) "win", NULL
20422 };
20423
20424 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
20425 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20426 if (SWIG_arg_fail(1)) SWIG_fail;
20427 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20428 if (SWIG_arg_fail(2)) SWIG_fail;
20429 {
20430 PyThreadState* __tstate = wxPyBeginAllowThreads();
20431 (arg1)->SetWindow(arg2);
20432
20433 wxPyEndAllowThreads(__tstate);
20434 if (PyErr_Occurred()) SWIG_fail;
20435 }
20436 Py_INCREF(Py_None); resultobj = Py_None;
20437 return resultobj;
20438 fail:
20439 return NULL;
20440 }
20441
20442
20443 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
20444 PyObject *obj;
20445 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20446 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
20447 Py_INCREF(obj);
20448 return Py_BuildValue((char *)"");
20449 }
20450 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20451 PyObject *resultobj;
20452 wxWindow *arg1 = (wxWindow *) NULL ;
20453 wxChildFocusEvent *result;
20454 PyObject * obj0 = 0 ;
20455 char *kwnames[] = {
20456 (char *) "win", NULL
20457 };
20458
20459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
20460 if (obj0) {
20461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
20462 if (SWIG_arg_fail(1)) SWIG_fail;
20463 }
20464 {
20465 PyThreadState* __tstate = wxPyBeginAllowThreads();
20466 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
20467
20468 wxPyEndAllowThreads(__tstate);
20469 if (PyErr_Occurred()) SWIG_fail;
20470 }
20471 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
20472 return resultobj;
20473 fail:
20474 return NULL;
20475 }
20476
20477
20478 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
20479 PyObject *resultobj;
20480 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
20481 wxWindow *result;
20482 PyObject * obj0 = 0 ;
20483 char *kwnames[] = {
20484 (char *) "self", NULL
20485 };
20486
20487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
20488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
20489 if (SWIG_arg_fail(1)) SWIG_fail;
20490 {
20491 PyThreadState* __tstate = wxPyBeginAllowThreads();
20492 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
20493
20494 wxPyEndAllowThreads(__tstate);
20495 if (PyErr_Occurred()) SWIG_fail;
20496 }
20497 {
20498 resultobj = wxPyMake_wxObject(result, 0);
20499 }
20500 return resultobj;
20501 fail:
20502 return NULL;
20503 }
20504
20505
20506 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
20507 PyObject *obj;
20508 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20509 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
20510 Py_INCREF(obj);
20511 return Py_BuildValue((char *)"");
20512 }
20513 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20514 PyObject *resultobj;
20515 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20516 bool arg2 = (bool) true ;
20517 int arg3 = (int) 0 ;
20518 wxActivateEvent *result;
20519 PyObject * obj0 = 0 ;
20520 PyObject * obj1 = 0 ;
20521 PyObject * obj2 = 0 ;
20522 char *kwnames[] = {
20523 (char *) "type",(char *) "active",(char *) "Id", NULL
20524 };
20525
20526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20527 if (obj0) {
20528 {
20529 arg1 = (wxEventType)(SWIG_As_int(obj0));
20530 if (SWIG_arg_fail(1)) SWIG_fail;
20531 }
20532 }
20533 if (obj1) {
20534 {
20535 arg2 = (bool)(SWIG_As_bool(obj1));
20536 if (SWIG_arg_fail(2)) SWIG_fail;
20537 }
20538 }
20539 if (obj2) {
20540 {
20541 arg3 = (int)(SWIG_As_int(obj2));
20542 if (SWIG_arg_fail(3)) SWIG_fail;
20543 }
20544 }
20545 {
20546 PyThreadState* __tstate = wxPyBeginAllowThreads();
20547 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20548
20549 wxPyEndAllowThreads(__tstate);
20550 if (PyErr_Occurred()) SWIG_fail;
20551 }
20552 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20553 return resultobj;
20554 fail:
20555 return NULL;
20556 }
20557
20558
20559 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20560 PyObject *resultobj;
20561 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20562 bool result;
20563 PyObject * obj0 = 0 ;
20564 char *kwnames[] = {
20565 (char *) "self", NULL
20566 };
20567
20568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20570 if (SWIG_arg_fail(1)) SWIG_fail;
20571 {
20572 PyThreadState* __tstate = wxPyBeginAllowThreads();
20573 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20574
20575 wxPyEndAllowThreads(__tstate);
20576 if (PyErr_Occurred()) SWIG_fail;
20577 }
20578 {
20579 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20580 }
20581 return resultobj;
20582 fail:
20583 return NULL;
20584 }
20585
20586
20587 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20588 PyObject *obj;
20589 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20590 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20591 Py_INCREF(obj);
20592 return Py_BuildValue((char *)"");
20593 }
20594 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20595 PyObject *resultobj;
20596 int arg1 = (int) 0 ;
20597 wxInitDialogEvent *result;
20598 PyObject * obj0 = 0 ;
20599 char *kwnames[] = {
20600 (char *) "Id", NULL
20601 };
20602
20603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20604 if (obj0) {
20605 {
20606 arg1 = (int)(SWIG_As_int(obj0));
20607 if (SWIG_arg_fail(1)) SWIG_fail;
20608 }
20609 }
20610 {
20611 PyThreadState* __tstate = wxPyBeginAllowThreads();
20612 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20613
20614 wxPyEndAllowThreads(__tstate);
20615 if (PyErr_Occurred()) SWIG_fail;
20616 }
20617 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20618 return resultobj;
20619 fail:
20620 return NULL;
20621 }
20622
20623
20624 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20625 PyObject *obj;
20626 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20627 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20628 Py_INCREF(obj);
20629 return Py_BuildValue((char *)"");
20630 }
20631 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20632 PyObject *resultobj;
20633 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20634 int arg2 = (int) 0 ;
20635 wxMenu *arg3 = (wxMenu *) NULL ;
20636 wxMenuEvent *result;
20637 PyObject * obj0 = 0 ;
20638 PyObject * obj1 = 0 ;
20639 PyObject * obj2 = 0 ;
20640 char *kwnames[] = {
20641 (char *) "type",(char *) "winid",(char *) "menu", NULL
20642 };
20643
20644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20645 if (obj0) {
20646 {
20647 arg1 = (wxEventType)(SWIG_As_int(obj0));
20648 if (SWIG_arg_fail(1)) SWIG_fail;
20649 }
20650 }
20651 if (obj1) {
20652 {
20653 arg2 = (int)(SWIG_As_int(obj1));
20654 if (SWIG_arg_fail(2)) SWIG_fail;
20655 }
20656 }
20657 if (obj2) {
20658 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20659 if (SWIG_arg_fail(3)) SWIG_fail;
20660 }
20661 {
20662 PyThreadState* __tstate = wxPyBeginAllowThreads();
20663 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20664
20665 wxPyEndAllowThreads(__tstate);
20666 if (PyErr_Occurred()) SWIG_fail;
20667 }
20668 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20669 return resultobj;
20670 fail:
20671 return NULL;
20672 }
20673
20674
20675 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20676 PyObject *resultobj;
20677 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20678 int result;
20679 PyObject * obj0 = 0 ;
20680 char *kwnames[] = {
20681 (char *) "self", NULL
20682 };
20683
20684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20686 if (SWIG_arg_fail(1)) SWIG_fail;
20687 {
20688 PyThreadState* __tstate = wxPyBeginAllowThreads();
20689 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20690
20691 wxPyEndAllowThreads(__tstate);
20692 if (PyErr_Occurred()) SWIG_fail;
20693 }
20694 {
20695 resultobj = SWIG_From_int((int)(result));
20696 }
20697 return resultobj;
20698 fail:
20699 return NULL;
20700 }
20701
20702
20703 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20704 PyObject *resultobj;
20705 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20706 bool result;
20707 PyObject * obj0 = 0 ;
20708 char *kwnames[] = {
20709 (char *) "self", NULL
20710 };
20711
20712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20714 if (SWIG_arg_fail(1)) SWIG_fail;
20715 {
20716 PyThreadState* __tstate = wxPyBeginAllowThreads();
20717 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20718
20719 wxPyEndAllowThreads(__tstate);
20720 if (PyErr_Occurred()) SWIG_fail;
20721 }
20722 {
20723 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20724 }
20725 return resultobj;
20726 fail:
20727 return NULL;
20728 }
20729
20730
20731 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20732 PyObject *resultobj;
20733 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20734 wxMenu *result;
20735 PyObject * obj0 = 0 ;
20736 char *kwnames[] = {
20737 (char *) "self", NULL
20738 };
20739
20740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20742 if (SWIG_arg_fail(1)) SWIG_fail;
20743 {
20744 PyThreadState* __tstate = wxPyBeginAllowThreads();
20745 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20746
20747 wxPyEndAllowThreads(__tstate);
20748 if (PyErr_Occurred()) SWIG_fail;
20749 }
20750 {
20751 resultobj = wxPyMake_wxObject(result, 0);
20752 }
20753 return resultobj;
20754 fail:
20755 return NULL;
20756 }
20757
20758
20759 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20760 PyObject *obj;
20761 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20762 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20763 Py_INCREF(obj);
20764 return Py_BuildValue((char *)"");
20765 }
20766 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20767 PyObject *resultobj;
20768 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20769 int arg2 = (int) 0 ;
20770 wxCloseEvent *result;
20771 PyObject * obj0 = 0 ;
20772 PyObject * obj1 = 0 ;
20773 char *kwnames[] = {
20774 (char *) "type",(char *) "winid", NULL
20775 };
20776
20777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20778 if (obj0) {
20779 {
20780 arg1 = (wxEventType)(SWIG_As_int(obj0));
20781 if (SWIG_arg_fail(1)) SWIG_fail;
20782 }
20783 }
20784 if (obj1) {
20785 {
20786 arg2 = (int)(SWIG_As_int(obj1));
20787 if (SWIG_arg_fail(2)) SWIG_fail;
20788 }
20789 }
20790 {
20791 PyThreadState* __tstate = wxPyBeginAllowThreads();
20792 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20793
20794 wxPyEndAllowThreads(__tstate);
20795 if (PyErr_Occurred()) SWIG_fail;
20796 }
20797 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20798 return resultobj;
20799 fail:
20800 return NULL;
20801 }
20802
20803
20804 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20805 PyObject *resultobj;
20806 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20807 bool arg2 ;
20808 PyObject * obj0 = 0 ;
20809 PyObject * obj1 = 0 ;
20810 char *kwnames[] = {
20811 (char *) "self",(char *) "logOff", NULL
20812 };
20813
20814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20816 if (SWIG_arg_fail(1)) SWIG_fail;
20817 {
20818 arg2 = (bool)(SWIG_As_bool(obj1));
20819 if (SWIG_arg_fail(2)) SWIG_fail;
20820 }
20821 {
20822 PyThreadState* __tstate = wxPyBeginAllowThreads();
20823 (arg1)->SetLoggingOff(arg2);
20824
20825 wxPyEndAllowThreads(__tstate);
20826 if (PyErr_Occurred()) SWIG_fail;
20827 }
20828 Py_INCREF(Py_None); resultobj = Py_None;
20829 return resultobj;
20830 fail:
20831 return NULL;
20832 }
20833
20834
20835 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20836 PyObject *resultobj;
20837 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20838 bool result;
20839 PyObject * obj0 = 0 ;
20840 char *kwnames[] = {
20841 (char *) "self", NULL
20842 };
20843
20844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20846 if (SWIG_arg_fail(1)) SWIG_fail;
20847 {
20848 PyThreadState* __tstate = wxPyBeginAllowThreads();
20849 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20850
20851 wxPyEndAllowThreads(__tstate);
20852 if (PyErr_Occurred()) SWIG_fail;
20853 }
20854 {
20855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20856 }
20857 return resultobj;
20858 fail:
20859 return NULL;
20860 }
20861
20862
20863 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20864 PyObject *resultobj;
20865 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20866 bool arg2 = (bool) true ;
20867 PyObject * obj0 = 0 ;
20868 PyObject * obj1 = 0 ;
20869 char *kwnames[] = {
20870 (char *) "self",(char *) "veto", NULL
20871 };
20872
20873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20875 if (SWIG_arg_fail(1)) SWIG_fail;
20876 if (obj1) {
20877 {
20878 arg2 = (bool)(SWIG_As_bool(obj1));
20879 if (SWIG_arg_fail(2)) SWIG_fail;
20880 }
20881 }
20882 {
20883 PyThreadState* __tstate = wxPyBeginAllowThreads();
20884 (arg1)->Veto(arg2);
20885
20886 wxPyEndAllowThreads(__tstate);
20887 if (PyErr_Occurred()) SWIG_fail;
20888 }
20889 Py_INCREF(Py_None); resultobj = Py_None;
20890 return resultobj;
20891 fail:
20892 return NULL;
20893 }
20894
20895
20896 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20897 PyObject *resultobj;
20898 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20899 bool result;
20900 PyObject * obj0 = 0 ;
20901 char *kwnames[] = {
20902 (char *) "self", NULL
20903 };
20904
20905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20907 if (SWIG_arg_fail(1)) SWIG_fail;
20908 {
20909 PyThreadState* __tstate = wxPyBeginAllowThreads();
20910 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20911
20912 wxPyEndAllowThreads(__tstate);
20913 if (PyErr_Occurred()) SWIG_fail;
20914 }
20915 {
20916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20917 }
20918 return resultobj;
20919 fail:
20920 return NULL;
20921 }
20922
20923
20924 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20925 PyObject *resultobj;
20926 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20927 bool arg2 ;
20928 PyObject * obj0 = 0 ;
20929 PyObject * obj1 = 0 ;
20930 char *kwnames[] = {
20931 (char *) "self",(char *) "canVeto", NULL
20932 };
20933
20934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
20935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20936 if (SWIG_arg_fail(1)) SWIG_fail;
20937 {
20938 arg2 = (bool)(SWIG_As_bool(obj1));
20939 if (SWIG_arg_fail(2)) SWIG_fail;
20940 }
20941 {
20942 PyThreadState* __tstate = wxPyBeginAllowThreads();
20943 (arg1)->SetCanVeto(arg2);
20944
20945 wxPyEndAllowThreads(__tstate);
20946 if (PyErr_Occurred()) SWIG_fail;
20947 }
20948 Py_INCREF(Py_None); resultobj = Py_None;
20949 return resultobj;
20950 fail:
20951 return NULL;
20952 }
20953
20954
20955 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20956 PyObject *resultobj;
20957 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20958 bool result;
20959 PyObject * obj0 = 0 ;
20960 char *kwnames[] = {
20961 (char *) "self", NULL
20962 };
20963
20964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
20965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20966 if (SWIG_arg_fail(1)) SWIG_fail;
20967 {
20968 PyThreadState* __tstate = wxPyBeginAllowThreads();
20969 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
20970
20971 wxPyEndAllowThreads(__tstate);
20972 if (PyErr_Occurred()) SWIG_fail;
20973 }
20974 {
20975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20976 }
20977 return resultobj;
20978 fail:
20979 return NULL;
20980 }
20981
20982
20983 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20984 PyObject *obj;
20985 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20986 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20987 Py_INCREF(obj);
20988 return Py_BuildValue((char *)"");
20989 }
20990 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20991 PyObject *resultobj;
20992 int arg1 = (int) 0 ;
20993 bool arg2 = (bool) false ;
20994 wxShowEvent *result;
20995 PyObject * obj0 = 0 ;
20996 PyObject * obj1 = 0 ;
20997 char *kwnames[] = {
20998 (char *) "winid",(char *) "show", NULL
20999 };
21000
21001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
21002 if (obj0) {
21003 {
21004 arg1 = (int)(SWIG_As_int(obj0));
21005 if (SWIG_arg_fail(1)) SWIG_fail;
21006 }
21007 }
21008 if (obj1) {
21009 {
21010 arg2 = (bool)(SWIG_As_bool(obj1));
21011 if (SWIG_arg_fail(2)) SWIG_fail;
21012 }
21013 }
21014 {
21015 PyThreadState* __tstate = wxPyBeginAllowThreads();
21016 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
21017
21018 wxPyEndAllowThreads(__tstate);
21019 if (PyErr_Occurred()) SWIG_fail;
21020 }
21021 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
21022 return resultobj;
21023 fail:
21024 return NULL;
21025 }
21026
21027
21028 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21029 PyObject *resultobj;
21030 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21031 bool arg2 ;
21032 PyObject * obj0 = 0 ;
21033 PyObject * obj1 = 0 ;
21034 char *kwnames[] = {
21035 (char *) "self",(char *) "show", NULL
21036 };
21037
21038 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
21039 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21040 if (SWIG_arg_fail(1)) SWIG_fail;
21041 {
21042 arg2 = (bool)(SWIG_As_bool(obj1));
21043 if (SWIG_arg_fail(2)) SWIG_fail;
21044 }
21045 {
21046 PyThreadState* __tstate = wxPyBeginAllowThreads();
21047 (arg1)->SetShow(arg2);
21048
21049 wxPyEndAllowThreads(__tstate);
21050 if (PyErr_Occurred()) SWIG_fail;
21051 }
21052 Py_INCREF(Py_None); resultobj = Py_None;
21053 return resultobj;
21054 fail:
21055 return NULL;
21056 }
21057
21058
21059 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
21060 PyObject *resultobj;
21061 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
21062 bool result;
21063 PyObject * obj0 = 0 ;
21064 char *kwnames[] = {
21065 (char *) "self", NULL
21066 };
21067
21068 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
21069 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
21070 if (SWIG_arg_fail(1)) SWIG_fail;
21071 {
21072 PyThreadState* __tstate = wxPyBeginAllowThreads();
21073 result = (bool)((wxShowEvent const *)arg1)->GetShow();
21074
21075 wxPyEndAllowThreads(__tstate);
21076 if (PyErr_Occurred()) SWIG_fail;
21077 }
21078 {
21079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21080 }
21081 return resultobj;
21082 fail:
21083 return NULL;
21084 }
21085
21086
21087 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
21088 PyObject *obj;
21089 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21090 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
21091 Py_INCREF(obj);
21092 return Py_BuildValue((char *)"");
21093 }
21094 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21095 PyObject *resultobj;
21096 int arg1 = (int) 0 ;
21097 bool arg2 = (bool) true ;
21098 wxIconizeEvent *result;
21099 PyObject * obj0 = 0 ;
21100 PyObject * obj1 = 0 ;
21101 char *kwnames[] = {
21102 (char *) "id",(char *) "iconized", NULL
21103 };
21104
21105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
21106 if (obj0) {
21107 {
21108 arg1 = (int)(SWIG_As_int(obj0));
21109 if (SWIG_arg_fail(1)) SWIG_fail;
21110 }
21111 }
21112 if (obj1) {
21113 {
21114 arg2 = (bool)(SWIG_As_bool(obj1));
21115 if (SWIG_arg_fail(2)) SWIG_fail;
21116 }
21117 }
21118 {
21119 PyThreadState* __tstate = wxPyBeginAllowThreads();
21120 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
21121
21122 wxPyEndAllowThreads(__tstate);
21123 if (PyErr_Occurred()) SWIG_fail;
21124 }
21125 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
21126 return resultobj;
21127 fail:
21128 return NULL;
21129 }
21130
21131
21132 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
21133 PyObject *resultobj;
21134 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
21135 bool result;
21136 PyObject * obj0 = 0 ;
21137 char *kwnames[] = {
21138 (char *) "self", NULL
21139 };
21140
21141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
21142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
21143 if (SWIG_arg_fail(1)) SWIG_fail;
21144 {
21145 PyThreadState* __tstate = wxPyBeginAllowThreads();
21146 result = (bool)(arg1)->Iconized();
21147
21148 wxPyEndAllowThreads(__tstate);
21149 if (PyErr_Occurred()) SWIG_fail;
21150 }
21151 {
21152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21153 }
21154 return resultobj;
21155 fail:
21156 return NULL;
21157 }
21158
21159
21160 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
21161 PyObject *obj;
21162 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21163 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
21164 Py_INCREF(obj);
21165 return Py_BuildValue((char *)"");
21166 }
21167 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21168 PyObject *resultobj;
21169 int arg1 = (int) 0 ;
21170 wxMaximizeEvent *result;
21171 PyObject * obj0 = 0 ;
21172 char *kwnames[] = {
21173 (char *) "id", NULL
21174 };
21175
21176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
21177 if (obj0) {
21178 {
21179 arg1 = (int)(SWIG_As_int(obj0));
21180 if (SWIG_arg_fail(1)) SWIG_fail;
21181 }
21182 }
21183 {
21184 PyThreadState* __tstate = wxPyBeginAllowThreads();
21185 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
21186
21187 wxPyEndAllowThreads(__tstate);
21188 if (PyErr_Occurred()) SWIG_fail;
21189 }
21190 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
21191 return resultobj;
21192 fail:
21193 return NULL;
21194 }
21195
21196
21197 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
21198 PyObject *obj;
21199 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21200 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
21201 Py_INCREF(obj);
21202 return Py_BuildValue((char *)"");
21203 }
21204 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
21205 PyObject *resultobj;
21206 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21207 wxPoint result;
21208 PyObject * obj0 = 0 ;
21209 char *kwnames[] = {
21210 (char *) "self", NULL
21211 };
21212
21213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
21214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21215 if (SWIG_arg_fail(1)) SWIG_fail;
21216 {
21217 PyThreadState* __tstate = wxPyBeginAllowThreads();
21218 result = (arg1)->GetPosition();
21219
21220 wxPyEndAllowThreads(__tstate);
21221 if (PyErr_Occurred()) SWIG_fail;
21222 }
21223 {
21224 wxPoint * resultptr;
21225 resultptr = new wxPoint((wxPoint &)(result));
21226 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
21227 }
21228 return resultobj;
21229 fail:
21230 return NULL;
21231 }
21232
21233
21234 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21235 PyObject *resultobj;
21236 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21237 int result;
21238 PyObject * obj0 = 0 ;
21239 char *kwnames[] = {
21240 (char *) "self", NULL
21241 };
21242
21243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
21244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21245 if (SWIG_arg_fail(1)) SWIG_fail;
21246 {
21247 PyThreadState* __tstate = wxPyBeginAllowThreads();
21248 result = (int)(arg1)->GetNumberOfFiles();
21249
21250 wxPyEndAllowThreads(__tstate);
21251 if (PyErr_Occurred()) SWIG_fail;
21252 }
21253 {
21254 resultobj = SWIG_From_int((int)(result));
21255 }
21256 return resultobj;
21257 fail:
21258 return NULL;
21259 }
21260
21261
21262 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
21263 PyObject *resultobj;
21264 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
21265 PyObject *result;
21266 PyObject * obj0 = 0 ;
21267 char *kwnames[] = {
21268 (char *) "self", NULL
21269 };
21270
21271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
21272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
21273 if (SWIG_arg_fail(1)) SWIG_fail;
21274 {
21275 PyThreadState* __tstate = wxPyBeginAllowThreads();
21276 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
21277
21278 wxPyEndAllowThreads(__tstate);
21279 if (PyErr_Occurred()) SWIG_fail;
21280 }
21281 resultobj = result;
21282 return resultobj;
21283 fail:
21284 return NULL;
21285 }
21286
21287
21288 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
21289 PyObject *obj;
21290 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21291 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
21292 Py_INCREF(obj);
21293 return Py_BuildValue((char *)"");
21294 }
21295 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21296 PyObject *resultobj;
21297 int arg1 = (int) 0 ;
21298 wxUpdateUIEvent *result;
21299 PyObject * obj0 = 0 ;
21300 char *kwnames[] = {
21301 (char *) "commandId", NULL
21302 };
21303
21304 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
21305 if (obj0) {
21306 {
21307 arg1 = (int)(SWIG_As_int(obj0));
21308 if (SWIG_arg_fail(1)) SWIG_fail;
21309 }
21310 }
21311 {
21312 PyThreadState* __tstate = wxPyBeginAllowThreads();
21313 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
21314
21315 wxPyEndAllowThreads(__tstate);
21316 if (PyErr_Occurred()) SWIG_fail;
21317 }
21318 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
21319 return resultobj;
21320 fail:
21321 return NULL;
21322 }
21323
21324
21325 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21326 PyObject *resultobj;
21327 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21328 bool result;
21329 PyObject * obj0 = 0 ;
21330 char *kwnames[] = {
21331 (char *) "self", NULL
21332 };
21333
21334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
21335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21336 if (SWIG_arg_fail(1)) SWIG_fail;
21337 {
21338 PyThreadState* __tstate = wxPyBeginAllowThreads();
21339 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
21340
21341 wxPyEndAllowThreads(__tstate);
21342 if (PyErr_Occurred()) SWIG_fail;
21343 }
21344 {
21345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21346 }
21347 return resultobj;
21348 fail:
21349 return NULL;
21350 }
21351
21352
21353 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21354 PyObject *resultobj;
21355 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21356 bool result;
21357 PyObject * obj0 = 0 ;
21358 char *kwnames[] = {
21359 (char *) "self", NULL
21360 };
21361
21362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
21363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21364 if (SWIG_arg_fail(1)) SWIG_fail;
21365 {
21366 PyThreadState* __tstate = wxPyBeginAllowThreads();
21367 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
21368
21369 wxPyEndAllowThreads(__tstate);
21370 if (PyErr_Occurred()) SWIG_fail;
21371 }
21372 {
21373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21374 }
21375 return resultobj;
21376 fail:
21377 return NULL;
21378 }
21379
21380
21381 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
21382 PyObject *resultobj;
21383 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21384 wxString result;
21385 PyObject * obj0 = 0 ;
21386 char *kwnames[] = {
21387 (char *) "self", NULL
21388 };
21389
21390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
21391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21392 if (SWIG_arg_fail(1)) SWIG_fail;
21393 {
21394 PyThreadState* __tstate = wxPyBeginAllowThreads();
21395 result = ((wxUpdateUIEvent const *)arg1)->GetText();
21396
21397 wxPyEndAllowThreads(__tstate);
21398 if (PyErr_Occurred()) SWIG_fail;
21399 }
21400 {
21401 #if wxUSE_UNICODE
21402 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21403 #else
21404 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21405 #endif
21406 }
21407 return resultobj;
21408 fail:
21409 return NULL;
21410 }
21411
21412
21413 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
21414 PyObject *resultobj;
21415 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21416 bool result;
21417 PyObject * obj0 = 0 ;
21418 char *kwnames[] = {
21419 (char *) "self", NULL
21420 };
21421
21422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
21423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21424 if (SWIG_arg_fail(1)) SWIG_fail;
21425 {
21426 PyThreadState* __tstate = wxPyBeginAllowThreads();
21427 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
21428
21429 wxPyEndAllowThreads(__tstate);
21430 if (PyErr_Occurred()) SWIG_fail;
21431 }
21432 {
21433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21434 }
21435 return resultobj;
21436 fail:
21437 return NULL;
21438 }
21439
21440
21441 static PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
21442 PyObject *resultobj;
21443 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21444 bool result;
21445 PyObject * obj0 = 0 ;
21446 char *kwnames[] = {
21447 (char *) "self", NULL
21448 };
21449
21450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
21451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21452 if (SWIG_arg_fail(1)) SWIG_fail;
21453 {
21454 PyThreadState* __tstate = wxPyBeginAllowThreads();
21455 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
21456
21457 wxPyEndAllowThreads(__tstate);
21458 if (PyErr_Occurred()) SWIG_fail;
21459 }
21460 {
21461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21462 }
21463 return resultobj;
21464 fail:
21465 return NULL;
21466 }
21467
21468
21469 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
21470 PyObject *resultobj;
21471 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21472 bool result;
21473 PyObject * obj0 = 0 ;
21474 char *kwnames[] = {
21475 (char *) "self", NULL
21476 };
21477
21478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
21479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21480 if (SWIG_arg_fail(1)) SWIG_fail;
21481 {
21482 PyThreadState* __tstate = wxPyBeginAllowThreads();
21483 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
21484
21485 wxPyEndAllowThreads(__tstate);
21486 if (PyErr_Occurred()) SWIG_fail;
21487 }
21488 {
21489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21490 }
21491 return resultobj;
21492 fail:
21493 return NULL;
21494 }
21495
21496
21497 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
21498 PyObject *resultobj;
21499 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21500 bool arg2 ;
21501 PyObject * obj0 = 0 ;
21502 PyObject * obj1 = 0 ;
21503 char *kwnames[] = {
21504 (char *) "self",(char *) "check", NULL
21505 };
21506
21507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
21508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21509 if (SWIG_arg_fail(1)) SWIG_fail;
21510 {
21511 arg2 = (bool)(SWIG_As_bool(obj1));
21512 if (SWIG_arg_fail(2)) SWIG_fail;
21513 }
21514 {
21515 PyThreadState* __tstate = wxPyBeginAllowThreads();
21516 (arg1)->Check(arg2);
21517
21518 wxPyEndAllowThreads(__tstate);
21519 if (PyErr_Occurred()) SWIG_fail;
21520 }
21521 Py_INCREF(Py_None); resultobj = Py_None;
21522 return resultobj;
21523 fail:
21524 return NULL;
21525 }
21526
21527
21528 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21529 PyObject *resultobj;
21530 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21531 bool arg2 ;
21532 PyObject * obj0 = 0 ;
21533 PyObject * obj1 = 0 ;
21534 char *kwnames[] = {
21535 (char *) "self",(char *) "enable", NULL
21536 };
21537
21538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21540 if (SWIG_arg_fail(1)) SWIG_fail;
21541 {
21542 arg2 = (bool)(SWIG_As_bool(obj1));
21543 if (SWIG_arg_fail(2)) SWIG_fail;
21544 }
21545 {
21546 PyThreadState* __tstate = wxPyBeginAllowThreads();
21547 (arg1)->Enable(arg2);
21548
21549 wxPyEndAllowThreads(__tstate);
21550 if (PyErr_Occurred()) SWIG_fail;
21551 }
21552 Py_INCREF(Py_None); resultobj = Py_None;
21553 return resultobj;
21554 fail:
21555 return NULL;
21556 }
21557
21558
21559 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21560 PyObject *resultobj;
21561 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21562 wxString *arg2 = 0 ;
21563 bool temp2 = false ;
21564 PyObject * obj0 = 0 ;
21565 PyObject * obj1 = 0 ;
21566 char *kwnames[] = {
21567 (char *) "self",(char *) "text", NULL
21568 };
21569
21570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21572 if (SWIG_arg_fail(1)) SWIG_fail;
21573 {
21574 arg2 = wxString_in_helper(obj1);
21575 if (arg2 == NULL) SWIG_fail;
21576 temp2 = true;
21577 }
21578 {
21579 PyThreadState* __tstate = wxPyBeginAllowThreads();
21580 (arg1)->SetText((wxString const &)*arg2);
21581
21582 wxPyEndAllowThreads(__tstate);
21583 if (PyErr_Occurred()) SWIG_fail;
21584 }
21585 Py_INCREF(Py_None); resultobj = Py_None;
21586 {
21587 if (temp2)
21588 delete arg2;
21589 }
21590 return resultobj;
21591 fail:
21592 {
21593 if (temp2)
21594 delete arg2;
21595 }
21596 return NULL;
21597 }
21598
21599
21600 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21601 PyObject *resultobj;
21602 long arg1 ;
21603 PyObject * obj0 = 0 ;
21604 char *kwnames[] = {
21605 (char *) "updateInterval", NULL
21606 };
21607
21608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21609 {
21610 arg1 = (long)(SWIG_As_long(obj0));
21611 if (SWIG_arg_fail(1)) SWIG_fail;
21612 }
21613 {
21614 PyThreadState* __tstate = wxPyBeginAllowThreads();
21615 wxUpdateUIEvent::SetUpdateInterval(arg1);
21616
21617 wxPyEndAllowThreads(__tstate);
21618 if (PyErr_Occurred()) SWIG_fail;
21619 }
21620 Py_INCREF(Py_None); resultobj = Py_None;
21621 return resultobj;
21622 fail:
21623 return NULL;
21624 }
21625
21626
21627 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21628 PyObject *resultobj;
21629 long result;
21630 char *kwnames[] = {
21631 NULL
21632 };
21633
21634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21635 {
21636 PyThreadState* __tstate = wxPyBeginAllowThreads();
21637 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21638
21639 wxPyEndAllowThreads(__tstate);
21640 if (PyErr_Occurred()) SWIG_fail;
21641 }
21642 {
21643 resultobj = SWIG_From_long((long)(result));
21644 }
21645 return resultobj;
21646 fail:
21647 return NULL;
21648 }
21649
21650
21651 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21652 PyObject *resultobj;
21653 wxWindow *arg1 = (wxWindow *) 0 ;
21654 bool result;
21655 PyObject * obj0 = 0 ;
21656 char *kwnames[] = {
21657 (char *) "win", NULL
21658 };
21659
21660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21662 if (SWIG_arg_fail(1)) SWIG_fail;
21663 {
21664 PyThreadState* __tstate = wxPyBeginAllowThreads();
21665 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21666
21667 wxPyEndAllowThreads(__tstate);
21668 if (PyErr_Occurred()) SWIG_fail;
21669 }
21670 {
21671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21672 }
21673 return resultobj;
21674 fail:
21675 return NULL;
21676 }
21677
21678
21679 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21680 PyObject *resultobj;
21681 char *kwnames[] = {
21682 NULL
21683 };
21684
21685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21686 {
21687 PyThreadState* __tstate = wxPyBeginAllowThreads();
21688 wxUpdateUIEvent::ResetUpdateTime();
21689
21690 wxPyEndAllowThreads(__tstate);
21691 if (PyErr_Occurred()) SWIG_fail;
21692 }
21693 Py_INCREF(Py_None); resultobj = Py_None;
21694 return resultobj;
21695 fail:
21696 return NULL;
21697 }
21698
21699
21700 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21701 PyObject *resultobj;
21702 wxUpdateUIMode arg1 ;
21703 PyObject * obj0 = 0 ;
21704 char *kwnames[] = {
21705 (char *) "mode", NULL
21706 };
21707
21708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21709 {
21710 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21711 if (SWIG_arg_fail(1)) SWIG_fail;
21712 }
21713 {
21714 PyThreadState* __tstate = wxPyBeginAllowThreads();
21715 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21716
21717 wxPyEndAllowThreads(__tstate);
21718 if (PyErr_Occurred()) SWIG_fail;
21719 }
21720 Py_INCREF(Py_None); resultobj = Py_None;
21721 return resultobj;
21722 fail:
21723 return NULL;
21724 }
21725
21726
21727 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21728 PyObject *resultobj;
21729 wxUpdateUIMode result;
21730 char *kwnames[] = {
21731 NULL
21732 };
21733
21734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21735 {
21736 PyThreadState* __tstate = wxPyBeginAllowThreads();
21737 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21738
21739 wxPyEndAllowThreads(__tstate);
21740 if (PyErr_Occurred()) SWIG_fail;
21741 }
21742 resultobj = SWIG_From_int((result));
21743 return resultobj;
21744 fail:
21745 return NULL;
21746 }
21747
21748
21749 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21750 PyObject *obj;
21751 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21752 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21753 Py_INCREF(obj);
21754 return Py_BuildValue((char *)"");
21755 }
21756 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21757 PyObject *resultobj;
21758 wxSysColourChangedEvent *result;
21759 char *kwnames[] = {
21760 NULL
21761 };
21762
21763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21764 {
21765 PyThreadState* __tstate = wxPyBeginAllowThreads();
21766 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21767
21768 wxPyEndAllowThreads(__tstate);
21769 if (PyErr_Occurred()) SWIG_fail;
21770 }
21771 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21772 return resultobj;
21773 fail:
21774 return NULL;
21775 }
21776
21777
21778 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21779 PyObject *obj;
21780 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21781 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21782 Py_INCREF(obj);
21783 return Py_BuildValue((char *)"");
21784 }
21785 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21786 PyObject *resultobj;
21787 int arg1 = (int) 0 ;
21788 wxWindow *arg2 = (wxWindow *) NULL ;
21789 wxMouseCaptureChangedEvent *result;
21790 PyObject * obj0 = 0 ;
21791 PyObject * obj1 = 0 ;
21792 char *kwnames[] = {
21793 (char *) "winid",(char *) "gainedCapture", NULL
21794 };
21795
21796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21797 if (obj0) {
21798 {
21799 arg1 = (int)(SWIG_As_int(obj0));
21800 if (SWIG_arg_fail(1)) SWIG_fail;
21801 }
21802 }
21803 if (obj1) {
21804 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21805 if (SWIG_arg_fail(2)) SWIG_fail;
21806 }
21807 {
21808 PyThreadState* __tstate = wxPyBeginAllowThreads();
21809 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21810
21811 wxPyEndAllowThreads(__tstate);
21812 if (PyErr_Occurred()) SWIG_fail;
21813 }
21814 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21815 return resultobj;
21816 fail:
21817 return NULL;
21818 }
21819
21820
21821 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21822 PyObject *resultobj;
21823 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21824 wxWindow *result;
21825 PyObject * obj0 = 0 ;
21826 char *kwnames[] = {
21827 (char *) "self", NULL
21828 };
21829
21830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21832 if (SWIG_arg_fail(1)) SWIG_fail;
21833 {
21834 PyThreadState* __tstate = wxPyBeginAllowThreads();
21835 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21836
21837 wxPyEndAllowThreads(__tstate);
21838 if (PyErr_Occurred()) SWIG_fail;
21839 }
21840 {
21841 resultobj = wxPyMake_wxObject(result, 0);
21842 }
21843 return resultobj;
21844 fail:
21845 return NULL;
21846 }
21847
21848
21849 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21850 PyObject *obj;
21851 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21852 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21853 Py_INCREF(obj);
21854 return Py_BuildValue((char *)"");
21855 }
21856 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21857 PyObject *resultobj;
21858 wxDisplayChangedEvent *result;
21859 char *kwnames[] = {
21860 NULL
21861 };
21862
21863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21864 {
21865 PyThreadState* __tstate = wxPyBeginAllowThreads();
21866 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21867
21868 wxPyEndAllowThreads(__tstate);
21869 if (PyErr_Occurred()) SWIG_fail;
21870 }
21871 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21872 return resultobj;
21873 fail:
21874 return NULL;
21875 }
21876
21877
21878 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21879 PyObject *obj;
21880 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21881 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21882 Py_INCREF(obj);
21883 return Py_BuildValue((char *)"");
21884 }
21885 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21886 PyObject *resultobj;
21887 int arg1 = (int) 0 ;
21888 wxPaletteChangedEvent *result;
21889 PyObject * obj0 = 0 ;
21890 char *kwnames[] = {
21891 (char *) "id", NULL
21892 };
21893
21894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21895 if (obj0) {
21896 {
21897 arg1 = (int)(SWIG_As_int(obj0));
21898 if (SWIG_arg_fail(1)) SWIG_fail;
21899 }
21900 }
21901 {
21902 PyThreadState* __tstate = wxPyBeginAllowThreads();
21903 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21904
21905 wxPyEndAllowThreads(__tstate);
21906 if (PyErr_Occurred()) SWIG_fail;
21907 }
21908 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21909 return resultobj;
21910 fail:
21911 return NULL;
21912 }
21913
21914
21915 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21916 PyObject *resultobj;
21917 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21918 wxWindow *arg2 = (wxWindow *) 0 ;
21919 PyObject * obj0 = 0 ;
21920 PyObject * obj1 = 0 ;
21921 char *kwnames[] = {
21922 (char *) "self",(char *) "win", NULL
21923 };
21924
21925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
21926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21927 if (SWIG_arg_fail(1)) SWIG_fail;
21928 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21929 if (SWIG_arg_fail(2)) SWIG_fail;
21930 {
21931 PyThreadState* __tstate = wxPyBeginAllowThreads();
21932 (arg1)->SetChangedWindow(arg2);
21933
21934 wxPyEndAllowThreads(__tstate);
21935 if (PyErr_Occurred()) SWIG_fail;
21936 }
21937 Py_INCREF(Py_None); resultobj = Py_None;
21938 return resultobj;
21939 fail:
21940 return NULL;
21941 }
21942
21943
21944 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21945 PyObject *resultobj;
21946 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21947 wxWindow *result;
21948 PyObject * obj0 = 0 ;
21949 char *kwnames[] = {
21950 (char *) "self", NULL
21951 };
21952
21953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21955 if (SWIG_arg_fail(1)) SWIG_fail;
21956 {
21957 PyThreadState* __tstate = wxPyBeginAllowThreads();
21958 result = (wxWindow *)(arg1)->GetChangedWindow();
21959
21960 wxPyEndAllowThreads(__tstate);
21961 if (PyErr_Occurred()) SWIG_fail;
21962 }
21963 {
21964 resultobj = wxPyMake_wxObject(result, 0);
21965 }
21966 return resultobj;
21967 fail:
21968 return NULL;
21969 }
21970
21971
21972 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21973 PyObject *obj;
21974 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21975 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21976 Py_INCREF(obj);
21977 return Py_BuildValue((char *)"");
21978 }
21979 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21980 PyObject *resultobj;
21981 int arg1 = (int) 0 ;
21982 wxQueryNewPaletteEvent *result;
21983 PyObject * obj0 = 0 ;
21984 char *kwnames[] = {
21985 (char *) "winid", NULL
21986 };
21987
21988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21989 if (obj0) {
21990 {
21991 arg1 = (int)(SWIG_As_int(obj0));
21992 if (SWIG_arg_fail(1)) SWIG_fail;
21993 }
21994 }
21995 {
21996 PyThreadState* __tstate = wxPyBeginAllowThreads();
21997 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21998
21999 wxPyEndAllowThreads(__tstate);
22000 if (PyErr_Occurred()) SWIG_fail;
22001 }
22002 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
22003 return resultobj;
22004 fail:
22005 return NULL;
22006 }
22007
22008
22009 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22010 PyObject *resultobj;
22011 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22012 bool arg2 ;
22013 PyObject * obj0 = 0 ;
22014 PyObject * obj1 = 0 ;
22015 char *kwnames[] = {
22016 (char *) "self",(char *) "realized", NULL
22017 };
22018
22019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
22020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22021 if (SWIG_arg_fail(1)) SWIG_fail;
22022 {
22023 arg2 = (bool)(SWIG_As_bool(obj1));
22024 if (SWIG_arg_fail(2)) SWIG_fail;
22025 }
22026 {
22027 PyThreadState* __tstate = wxPyBeginAllowThreads();
22028 (arg1)->SetPaletteRealized(arg2);
22029
22030 wxPyEndAllowThreads(__tstate);
22031 if (PyErr_Occurred()) SWIG_fail;
22032 }
22033 Py_INCREF(Py_None); resultobj = Py_None;
22034 return resultobj;
22035 fail:
22036 return NULL;
22037 }
22038
22039
22040 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
22041 PyObject *resultobj;
22042 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
22043 bool result;
22044 PyObject * obj0 = 0 ;
22045 char *kwnames[] = {
22046 (char *) "self", NULL
22047 };
22048
22049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
22050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
22051 if (SWIG_arg_fail(1)) SWIG_fail;
22052 {
22053 PyThreadState* __tstate = wxPyBeginAllowThreads();
22054 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
22055
22056 wxPyEndAllowThreads(__tstate);
22057 if (PyErr_Occurred()) SWIG_fail;
22058 }
22059 {
22060 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22061 }
22062 return resultobj;
22063 fail:
22064 return NULL;
22065 }
22066
22067
22068 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
22069 PyObject *obj;
22070 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22071 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
22072 Py_INCREF(obj);
22073 return Py_BuildValue((char *)"");
22074 }
22075 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22076 PyObject *resultobj;
22077 wxNavigationKeyEvent *result;
22078 char *kwnames[] = {
22079 NULL
22080 };
22081
22082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
22083 {
22084 PyThreadState* __tstate = wxPyBeginAllowThreads();
22085 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
22086
22087 wxPyEndAllowThreads(__tstate);
22088 if (PyErr_Occurred()) SWIG_fail;
22089 }
22090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
22091 return resultobj;
22092 fail:
22093 return NULL;
22094 }
22095
22096
22097 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22098 PyObject *resultobj;
22099 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22100 bool result;
22101 PyObject * obj0 = 0 ;
22102 char *kwnames[] = {
22103 (char *) "self", NULL
22104 };
22105
22106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
22107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22108 if (SWIG_arg_fail(1)) SWIG_fail;
22109 {
22110 PyThreadState* __tstate = wxPyBeginAllowThreads();
22111 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
22112
22113 wxPyEndAllowThreads(__tstate);
22114 if (PyErr_Occurred()) SWIG_fail;
22115 }
22116 {
22117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22118 }
22119 return resultobj;
22120 fail:
22121 return NULL;
22122 }
22123
22124
22125 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
22126 PyObject *resultobj;
22127 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22128 bool arg2 ;
22129 PyObject * obj0 = 0 ;
22130 PyObject * obj1 = 0 ;
22131 char *kwnames[] = {
22132 (char *) "self",(char *) "forward", NULL
22133 };
22134
22135 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
22136 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22137 if (SWIG_arg_fail(1)) SWIG_fail;
22138 {
22139 arg2 = (bool)(SWIG_As_bool(obj1));
22140 if (SWIG_arg_fail(2)) SWIG_fail;
22141 }
22142 {
22143 PyThreadState* __tstate = wxPyBeginAllowThreads();
22144 (arg1)->SetDirection(arg2);
22145
22146 wxPyEndAllowThreads(__tstate);
22147 if (PyErr_Occurred()) SWIG_fail;
22148 }
22149 Py_INCREF(Py_None); resultobj = Py_None;
22150 return resultobj;
22151 fail:
22152 return NULL;
22153 }
22154
22155
22156 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22157 PyObject *resultobj;
22158 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22159 bool result;
22160 PyObject * obj0 = 0 ;
22161 char *kwnames[] = {
22162 (char *) "self", NULL
22163 };
22164
22165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
22166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22167 if (SWIG_arg_fail(1)) SWIG_fail;
22168 {
22169 PyThreadState* __tstate = wxPyBeginAllowThreads();
22170 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
22171
22172 wxPyEndAllowThreads(__tstate);
22173 if (PyErr_Occurred()) SWIG_fail;
22174 }
22175 {
22176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22177 }
22178 return resultobj;
22179 fail:
22180 return NULL;
22181 }
22182
22183
22184 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
22185 PyObject *resultobj;
22186 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22187 bool arg2 ;
22188 PyObject * obj0 = 0 ;
22189 PyObject * obj1 = 0 ;
22190 char *kwnames[] = {
22191 (char *) "self",(char *) "ischange", NULL
22192 };
22193
22194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
22195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22196 if (SWIG_arg_fail(1)) SWIG_fail;
22197 {
22198 arg2 = (bool)(SWIG_As_bool(obj1));
22199 if (SWIG_arg_fail(2)) SWIG_fail;
22200 }
22201 {
22202 PyThreadState* __tstate = wxPyBeginAllowThreads();
22203 (arg1)->SetWindowChange(arg2);
22204
22205 wxPyEndAllowThreads(__tstate);
22206 if (PyErr_Occurred()) SWIG_fail;
22207 }
22208 Py_INCREF(Py_None); resultobj = Py_None;
22209 return resultobj;
22210 fail:
22211 return NULL;
22212 }
22213
22214
22215 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22216 PyObject *resultobj;
22217 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22218 bool result;
22219 PyObject * obj0 = 0 ;
22220 char *kwnames[] = {
22221 (char *) "self", NULL
22222 };
22223
22224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
22225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22226 if (SWIG_arg_fail(1)) SWIG_fail;
22227 {
22228 PyThreadState* __tstate = wxPyBeginAllowThreads();
22229 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
22230
22231 wxPyEndAllowThreads(__tstate);
22232 if (PyErr_Occurred()) SWIG_fail;
22233 }
22234 {
22235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22236 }
22237 return resultobj;
22238 fail:
22239 return NULL;
22240 }
22241
22242
22243 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
22244 PyObject *resultobj;
22245 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22246 bool arg2 ;
22247 PyObject * obj0 = 0 ;
22248 PyObject * obj1 = 0 ;
22249 char *kwnames[] = {
22250 (char *) "self",(char *) "bIs", NULL
22251 };
22252
22253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
22254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22255 if (SWIG_arg_fail(1)) SWIG_fail;
22256 {
22257 arg2 = (bool)(SWIG_As_bool(obj1));
22258 if (SWIG_arg_fail(2)) SWIG_fail;
22259 }
22260 {
22261 PyThreadState* __tstate = wxPyBeginAllowThreads();
22262 (arg1)->SetFromTab(arg2);
22263
22264 wxPyEndAllowThreads(__tstate);
22265 if (PyErr_Occurred()) SWIG_fail;
22266 }
22267 Py_INCREF(Py_None); resultobj = Py_None;
22268 return resultobj;
22269 fail:
22270 return NULL;
22271 }
22272
22273
22274 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
22275 PyObject *resultobj;
22276 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22277 long arg2 ;
22278 PyObject * obj0 = 0 ;
22279 PyObject * obj1 = 0 ;
22280 char *kwnames[] = {
22281 (char *) "self",(char *) "flags", NULL
22282 };
22283
22284 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
22285 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22286 if (SWIG_arg_fail(1)) SWIG_fail;
22287 {
22288 arg2 = (long)(SWIG_As_long(obj1));
22289 if (SWIG_arg_fail(2)) SWIG_fail;
22290 }
22291 {
22292 PyThreadState* __tstate = wxPyBeginAllowThreads();
22293 (arg1)->SetFlags(arg2);
22294
22295 wxPyEndAllowThreads(__tstate);
22296 if (PyErr_Occurred()) SWIG_fail;
22297 }
22298 Py_INCREF(Py_None); resultobj = Py_None;
22299 return resultobj;
22300 fail:
22301 return NULL;
22302 }
22303
22304
22305 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22306 PyObject *resultobj;
22307 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22308 wxWindow *result;
22309 PyObject * obj0 = 0 ;
22310 char *kwnames[] = {
22311 (char *) "self", NULL
22312 };
22313
22314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
22315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22316 if (SWIG_arg_fail(1)) SWIG_fail;
22317 {
22318 PyThreadState* __tstate = wxPyBeginAllowThreads();
22319 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
22320
22321 wxPyEndAllowThreads(__tstate);
22322 if (PyErr_Occurred()) SWIG_fail;
22323 }
22324 {
22325 resultobj = wxPyMake_wxObject(result, 0);
22326 }
22327 return resultobj;
22328 fail:
22329 return NULL;
22330 }
22331
22332
22333 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
22334 PyObject *resultobj;
22335 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
22336 wxWindow *arg2 = (wxWindow *) 0 ;
22337 PyObject * obj0 = 0 ;
22338 PyObject * obj1 = 0 ;
22339 char *kwnames[] = {
22340 (char *) "self",(char *) "win", NULL
22341 };
22342
22343 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
22344 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
22345 if (SWIG_arg_fail(1)) SWIG_fail;
22346 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22347 if (SWIG_arg_fail(2)) SWIG_fail;
22348 {
22349 PyThreadState* __tstate = wxPyBeginAllowThreads();
22350 (arg1)->SetCurrentFocus(arg2);
22351
22352 wxPyEndAllowThreads(__tstate);
22353 if (PyErr_Occurred()) SWIG_fail;
22354 }
22355 Py_INCREF(Py_None); resultobj = Py_None;
22356 return resultobj;
22357 fail:
22358 return NULL;
22359 }
22360
22361
22362 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
22363 PyObject *obj;
22364 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22365 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
22366 Py_INCREF(obj);
22367 return Py_BuildValue((char *)"");
22368 }
22369 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22370 PyObject *resultobj;
22371 wxWindow *arg1 = (wxWindow *) NULL ;
22372 wxWindowCreateEvent *result;
22373 PyObject * obj0 = 0 ;
22374 char *kwnames[] = {
22375 (char *) "win", NULL
22376 };
22377
22378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
22379 if (obj0) {
22380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22381 if (SWIG_arg_fail(1)) SWIG_fail;
22382 }
22383 {
22384 PyThreadState* __tstate = wxPyBeginAllowThreads();
22385 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
22386
22387 wxPyEndAllowThreads(__tstate);
22388 if (PyErr_Occurred()) SWIG_fail;
22389 }
22390 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
22391 return resultobj;
22392 fail:
22393 return NULL;
22394 }
22395
22396
22397 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22398 PyObject *resultobj;
22399 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
22400 wxWindow *result;
22401 PyObject * obj0 = 0 ;
22402 char *kwnames[] = {
22403 (char *) "self", NULL
22404 };
22405
22406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
22407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
22408 if (SWIG_arg_fail(1)) SWIG_fail;
22409 {
22410 PyThreadState* __tstate = wxPyBeginAllowThreads();
22411 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
22412
22413 wxPyEndAllowThreads(__tstate);
22414 if (PyErr_Occurred()) SWIG_fail;
22415 }
22416 {
22417 resultobj = wxPyMake_wxObject(result, 0);
22418 }
22419 return resultobj;
22420 fail:
22421 return NULL;
22422 }
22423
22424
22425 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
22426 PyObject *obj;
22427 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22428 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
22429 Py_INCREF(obj);
22430 return Py_BuildValue((char *)"");
22431 }
22432 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22433 PyObject *resultobj;
22434 wxWindow *arg1 = (wxWindow *) NULL ;
22435 wxWindowDestroyEvent *result;
22436 PyObject * obj0 = 0 ;
22437 char *kwnames[] = {
22438 (char *) "win", NULL
22439 };
22440
22441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
22442 if (obj0) {
22443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22444 if (SWIG_arg_fail(1)) SWIG_fail;
22445 }
22446 {
22447 PyThreadState* __tstate = wxPyBeginAllowThreads();
22448 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
22449
22450 wxPyEndAllowThreads(__tstate);
22451 if (PyErr_Occurred()) SWIG_fail;
22452 }
22453 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
22454 return resultobj;
22455 fail:
22456 return NULL;
22457 }
22458
22459
22460 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
22461 PyObject *resultobj;
22462 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
22463 wxWindow *result;
22464 PyObject * obj0 = 0 ;
22465 char *kwnames[] = {
22466 (char *) "self", NULL
22467 };
22468
22469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
22470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
22471 if (SWIG_arg_fail(1)) SWIG_fail;
22472 {
22473 PyThreadState* __tstate = wxPyBeginAllowThreads();
22474 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
22475
22476 wxPyEndAllowThreads(__tstate);
22477 if (PyErr_Occurred()) SWIG_fail;
22478 }
22479 {
22480 resultobj = wxPyMake_wxObject(result, 0);
22481 }
22482 return resultobj;
22483 fail:
22484 return NULL;
22485 }
22486
22487
22488 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
22489 PyObject *obj;
22490 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22491 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
22492 Py_INCREF(obj);
22493 return Py_BuildValue((char *)"");
22494 }
22495 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22496 PyObject *resultobj;
22497 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22498 int arg2 = (int) 0 ;
22499 wxPoint const &arg3_defvalue = wxDefaultPosition ;
22500 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
22501 wxContextMenuEvent *result;
22502 wxPoint temp3 ;
22503 PyObject * obj0 = 0 ;
22504 PyObject * obj1 = 0 ;
22505 PyObject * obj2 = 0 ;
22506 char *kwnames[] = {
22507 (char *) "type",(char *) "winid",(char *) "pt", NULL
22508 };
22509
22510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22511 if (obj0) {
22512 {
22513 arg1 = (wxEventType)(SWIG_As_int(obj0));
22514 if (SWIG_arg_fail(1)) SWIG_fail;
22515 }
22516 }
22517 if (obj1) {
22518 {
22519 arg2 = (int)(SWIG_As_int(obj1));
22520 if (SWIG_arg_fail(2)) SWIG_fail;
22521 }
22522 }
22523 if (obj2) {
22524 {
22525 arg3 = &temp3;
22526 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22527 }
22528 }
22529 {
22530 PyThreadState* __tstate = wxPyBeginAllowThreads();
22531 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22532
22533 wxPyEndAllowThreads(__tstate);
22534 if (PyErr_Occurred()) SWIG_fail;
22535 }
22536 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22537 return resultobj;
22538 fail:
22539 return NULL;
22540 }
22541
22542
22543 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22544 PyObject *resultobj;
22545 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22546 wxPoint *result;
22547 PyObject * obj0 = 0 ;
22548 char *kwnames[] = {
22549 (char *) "self", NULL
22550 };
22551
22552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22554 if (SWIG_arg_fail(1)) SWIG_fail;
22555 {
22556 PyThreadState* __tstate = wxPyBeginAllowThreads();
22557 {
22558 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22559 result = (wxPoint *) &_result_ref;
22560 }
22561
22562 wxPyEndAllowThreads(__tstate);
22563 if (PyErr_Occurred()) SWIG_fail;
22564 }
22565 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22566 return resultobj;
22567 fail:
22568 return NULL;
22569 }
22570
22571
22572 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22573 PyObject *resultobj;
22574 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22575 wxPoint *arg2 = 0 ;
22576 wxPoint temp2 ;
22577 PyObject * obj0 = 0 ;
22578 PyObject * obj1 = 0 ;
22579 char *kwnames[] = {
22580 (char *) "self",(char *) "pos", NULL
22581 };
22582
22583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22585 if (SWIG_arg_fail(1)) SWIG_fail;
22586 {
22587 arg2 = &temp2;
22588 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22589 }
22590 {
22591 PyThreadState* __tstate = wxPyBeginAllowThreads();
22592 (arg1)->SetPosition((wxPoint const &)*arg2);
22593
22594 wxPyEndAllowThreads(__tstate);
22595 if (PyErr_Occurred()) SWIG_fail;
22596 }
22597 Py_INCREF(Py_None); resultobj = Py_None;
22598 return resultobj;
22599 fail:
22600 return NULL;
22601 }
22602
22603
22604 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22605 PyObject *obj;
22606 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22607 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22608 Py_INCREF(obj);
22609 return Py_BuildValue((char *)"");
22610 }
22611 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22612 PyObject *resultobj;
22613 wxIdleEvent *result;
22614 char *kwnames[] = {
22615 NULL
22616 };
22617
22618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22619 {
22620 PyThreadState* __tstate = wxPyBeginAllowThreads();
22621 result = (wxIdleEvent *)new wxIdleEvent();
22622
22623 wxPyEndAllowThreads(__tstate);
22624 if (PyErr_Occurred()) SWIG_fail;
22625 }
22626 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22627 return resultobj;
22628 fail:
22629 return NULL;
22630 }
22631
22632
22633 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22634 PyObject *resultobj;
22635 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22636 bool arg2 = (bool) true ;
22637 PyObject * obj0 = 0 ;
22638 PyObject * obj1 = 0 ;
22639 char *kwnames[] = {
22640 (char *) "self",(char *) "needMore", NULL
22641 };
22642
22643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22645 if (SWIG_arg_fail(1)) SWIG_fail;
22646 if (obj1) {
22647 {
22648 arg2 = (bool)(SWIG_As_bool(obj1));
22649 if (SWIG_arg_fail(2)) SWIG_fail;
22650 }
22651 }
22652 {
22653 PyThreadState* __tstate = wxPyBeginAllowThreads();
22654 (arg1)->RequestMore(arg2);
22655
22656 wxPyEndAllowThreads(__tstate);
22657 if (PyErr_Occurred()) SWIG_fail;
22658 }
22659 Py_INCREF(Py_None); resultobj = Py_None;
22660 return resultobj;
22661 fail:
22662 return NULL;
22663 }
22664
22665
22666 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22667 PyObject *resultobj;
22668 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22669 bool result;
22670 PyObject * obj0 = 0 ;
22671 char *kwnames[] = {
22672 (char *) "self", NULL
22673 };
22674
22675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22677 if (SWIG_arg_fail(1)) SWIG_fail;
22678 {
22679 PyThreadState* __tstate = wxPyBeginAllowThreads();
22680 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22681
22682 wxPyEndAllowThreads(__tstate);
22683 if (PyErr_Occurred()) SWIG_fail;
22684 }
22685 {
22686 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22687 }
22688 return resultobj;
22689 fail:
22690 return NULL;
22691 }
22692
22693
22694 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22695 PyObject *resultobj;
22696 wxIdleMode arg1 ;
22697 PyObject * obj0 = 0 ;
22698 char *kwnames[] = {
22699 (char *) "mode", NULL
22700 };
22701
22702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22703 {
22704 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22705 if (SWIG_arg_fail(1)) SWIG_fail;
22706 }
22707 {
22708 PyThreadState* __tstate = wxPyBeginAllowThreads();
22709 wxIdleEvent::SetMode((wxIdleMode )arg1);
22710
22711 wxPyEndAllowThreads(__tstate);
22712 if (PyErr_Occurred()) SWIG_fail;
22713 }
22714 Py_INCREF(Py_None); resultobj = Py_None;
22715 return resultobj;
22716 fail:
22717 return NULL;
22718 }
22719
22720
22721 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22722 PyObject *resultobj;
22723 wxIdleMode result;
22724 char *kwnames[] = {
22725 NULL
22726 };
22727
22728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22729 {
22730 PyThreadState* __tstate = wxPyBeginAllowThreads();
22731 result = (wxIdleMode)wxIdleEvent::GetMode();
22732
22733 wxPyEndAllowThreads(__tstate);
22734 if (PyErr_Occurred()) SWIG_fail;
22735 }
22736 resultobj = SWIG_From_int((result));
22737 return resultobj;
22738 fail:
22739 return NULL;
22740 }
22741
22742
22743 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22744 PyObject *resultobj;
22745 wxWindow *arg1 = (wxWindow *) 0 ;
22746 bool result;
22747 PyObject * obj0 = 0 ;
22748 char *kwnames[] = {
22749 (char *) "win", NULL
22750 };
22751
22752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22754 if (SWIG_arg_fail(1)) SWIG_fail;
22755 {
22756 PyThreadState* __tstate = wxPyBeginAllowThreads();
22757 result = (bool)wxIdleEvent::CanSend(arg1);
22758
22759 wxPyEndAllowThreads(__tstate);
22760 if (PyErr_Occurred()) SWIG_fail;
22761 }
22762 {
22763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22764 }
22765 return resultobj;
22766 fail:
22767 return NULL;
22768 }
22769
22770
22771 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22772 PyObject *obj;
22773 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22774 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22775 Py_INCREF(obj);
22776 return Py_BuildValue((char *)"");
22777 }
22778 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22779 PyObject *resultobj;
22780 int arg1 = (int) 0 ;
22781 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22782 wxPyEvent *result;
22783 PyObject * obj0 = 0 ;
22784 PyObject * obj1 = 0 ;
22785 char *kwnames[] = {
22786 (char *) "winid",(char *) "eventType", NULL
22787 };
22788
22789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22790 if (obj0) {
22791 {
22792 arg1 = (int)(SWIG_As_int(obj0));
22793 if (SWIG_arg_fail(1)) SWIG_fail;
22794 }
22795 }
22796 if (obj1) {
22797 {
22798 arg2 = (wxEventType)(SWIG_As_int(obj1));
22799 if (SWIG_arg_fail(2)) SWIG_fail;
22800 }
22801 }
22802 {
22803 PyThreadState* __tstate = wxPyBeginAllowThreads();
22804 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22805
22806 wxPyEndAllowThreads(__tstate);
22807 if (PyErr_Occurred()) SWIG_fail;
22808 }
22809 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22810 return resultobj;
22811 fail:
22812 return NULL;
22813 }
22814
22815
22816 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22817 PyObject *resultobj;
22818 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22819 PyObject * obj0 = 0 ;
22820 char *kwnames[] = {
22821 (char *) "self", NULL
22822 };
22823
22824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22825 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22826 if (SWIG_arg_fail(1)) SWIG_fail;
22827 {
22828 PyThreadState* __tstate = wxPyBeginAllowThreads();
22829 delete arg1;
22830
22831 wxPyEndAllowThreads(__tstate);
22832 if (PyErr_Occurred()) SWIG_fail;
22833 }
22834 Py_INCREF(Py_None); resultobj = Py_None;
22835 return resultobj;
22836 fail:
22837 return NULL;
22838 }
22839
22840
22841 static PyObject *_wrap_PyEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22842 PyObject *resultobj;
22843 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22844 PyObject *arg2 = (PyObject *) 0 ;
22845 PyObject * obj0 = 0 ;
22846 PyObject * obj1 = 0 ;
22847 char *kwnames[] = {
22848 (char *) "self",(char *) "self", NULL
22849 };
22850
22851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
22852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22853 if (SWIG_arg_fail(1)) SWIG_fail;
22854 arg2 = obj1;
22855 {
22856 PyThreadState* __tstate = wxPyBeginAllowThreads();
22857 (arg1)->SetSelf(arg2);
22858
22859 wxPyEndAllowThreads(__tstate);
22860 if (PyErr_Occurred()) SWIG_fail;
22861 }
22862 Py_INCREF(Py_None); resultobj = Py_None;
22863 return resultobj;
22864 fail:
22865 return NULL;
22866 }
22867
22868
22869 static PyObject *_wrap_PyEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22870 PyObject *resultobj;
22871 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22872 PyObject *result;
22873 PyObject * obj0 = 0 ;
22874 char *kwnames[] = {
22875 (char *) "self", NULL
22876 };
22877
22878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent__GetSelf",kwnames,&obj0)) goto fail;
22879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22880 if (SWIG_arg_fail(1)) SWIG_fail;
22881 {
22882 PyThreadState* __tstate = wxPyBeginAllowThreads();
22883 result = (PyObject *)(arg1)->GetSelf();
22884
22885 wxPyEndAllowThreads(__tstate);
22886 if (PyErr_Occurred()) SWIG_fail;
22887 }
22888 resultobj = result;
22889 return resultobj;
22890 fail:
22891 return NULL;
22892 }
22893
22894
22895 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22896 PyObject *obj;
22897 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22898 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22899 Py_INCREF(obj);
22900 return Py_BuildValue((char *)"");
22901 }
22902 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22903 PyObject *resultobj;
22904 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22905 int arg2 = (int) 0 ;
22906 wxPyCommandEvent *result;
22907 PyObject * obj0 = 0 ;
22908 PyObject * obj1 = 0 ;
22909 char *kwnames[] = {
22910 (char *) "eventType",(char *) "id", NULL
22911 };
22912
22913 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22914 if (obj0) {
22915 {
22916 arg1 = (wxEventType)(SWIG_As_int(obj0));
22917 if (SWIG_arg_fail(1)) SWIG_fail;
22918 }
22919 }
22920 if (obj1) {
22921 {
22922 arg2 = (int)(SWIG_As_int(obj1));
22923 if (SWIG_arg_fail(2)) SWIG_fail;
22924 }
22925 }
22926 {
22927 PyThreadState* __tstate = wxPyBeginAllowThreads();
22928 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
22929
22930 wxPyEndAllowThreads(__tstate);
22931 if (PyErr_Occurred()) SWIG_fail;
22932 }
22933 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
22934 return resultobj;
22935 fail:
22936 return NULL;
22937 }
22938
22939
22940 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22941 PyObject *resultobj;
22942 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22943 PyObject * obj0 = 0 ;
22944 char *kwnames[] = {
22945 (char *) "self", NULL
22946 };
22947
22948 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
22949 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22950 if (SWIG_arg_fail(1)) SWIG_fail;
22951 {
22952 PyThreadState* __tstate = wxPyBeginAllowThreads();
22953 delete arg1;
22954
22955 wxPyEndAllowThreads(__tstate);
22956 if (PyErr_Occurred()) SWIG_fail;
22957 }
22958 Py_INCREF(Py_None); resultobj = Py_None;
22959 return resultobj;
22960 fail:
22961 return NULL;
22962 }
22963
22964
22965 static PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22966 PyObject *resultobj;
22967 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22968 PyObject *arg2 = (PyObject *) 0 ;
22969 PyObject * obj0 = 0 ;
22970 PyObject * obj1 = 0 ;
22971 char *kwnames[] = {
22972 (char *) "self",(char *) "self", NULL
22973 };
22974
22975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) goto fail;
22976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22977 if (SWIG_arg_fail(1)) SWIG_fail;
22978 arg2 = obj1;
22979 {
22980 PyThreadState* __tstate = wxPyBeginAllowThreads();
22981 (arg1)->SetSelf(arg2);
22982
22983 wxPyEndAllowThreads(__tstate);
22984 if (PyErr_Occurred()) SWIG_fail;
22985 }
22986 Py_INCREF(Py_None); resultobj = Py_None;
22987 return resultobj;
22988 fail:
22989 return NULL;
22990 }
22991
22992
22993 static PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22994 PyObject *resultobj;
22995 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22996 PyObject *result;
22997 PyObject * obj0 = 0 ;
22998 char *kwnames[] = {
22999 (char *) "self", NULL
23000 };
23001
23002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent__GetSelf",kwnames,&obj0)) goto fail;
23003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
23004 if (SWIG_arg_fail(1)) SWIG_fail;
23005 {
23006 PyThreadState* __tstate = wxPyBeginAllowThreads();
23007 result = (PyObject *)(arg1)->GetSelf();
23008
23009 wxPyEndAllowThreads(__tstate);
23010 if (PyErr_Occurred()) SWIG_fail;
23011 }
23012 resultobj = result;
23013 return resultobj;
23014 fail:
23015 return NULL;
23016 }
23017
23018
23019 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
23020 PyObject *obj;
23021 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23022 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
23023 Py_INCREF(obj);
23024 return Py_BuildValue((char *)"");
23025 }
23026 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
23027 PyObject *resultobj;
23028 wxWindow *arg1 = (wxWindow *) 0 ;
23029 wxDateTime *arg2 = 0 ;
23030 wxEventType arg3 ;
23031 wxDateEvent *result;
23032 PyObject * obj0 = 0 ;
23033 PyObject * obj1 = 0 ;
23034 PyObject * obj2 = 0 ;
23035 char *kwnames[] = {
23036 (char *) "win",(char *) "dt",(char *) "type", NULL
23037 };
23038
23039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
23040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23041 if (SWIG_arg_fail(1)) SWIG_fail;
23042 {
23043 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23044 if (SWIG_arg_fail(2)) SWIG_fail;
23045 if (arg2 == NULL) {
23046 SWIG_null_ref("wxDateTime");
23047 }
23048 if (SWIG_arg_fail(2)) SWIG_fail;
23049 }
23050 {
23051 arg3 = (wxEventType)(SWIG_As_int(obj2));
23052 if (SWIG_arg_fail(3)) SWIG_fail;
23053 }
23054 {
23055 PyThreadState* __tstate = wxPyBeginAllowThreads();
23056 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
23057
23058 wxPyEndAllowThreads(__tstate);
23059 if (PyErr_Occurred()) SWIG_fail;
23060 }
23061 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
23062 return resultobj;
23063 fail:
23064 return NULL;
23065 }
23066
23067
23068 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23069 PyObject *resultobj;
23070 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23071 wxDateTime *result;
23072 PyObject * obj0 = 0 ;
23073 char *kwnames[] = {
23074 (char *) "self", NULL
23075 };
23076
23077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
23078 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23079 if (SWIG_arg_fail(1)) SWIG_fail;
23080 {
23081 PyThreadState* __tstate = wxPyBeginAllowThreads();
23082 {
23083 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
23084 result = (wxDateTime *) &_result_ref;
23085 }
23086
23087 wxPyEndAllowThreads(__tstate);
23088 if (PyErr_Occurred()) SWIG_fail;
23089 }
23090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
23091 return resultobj;
23092 fail:
23093 return NULL;
23094 }
23095
23096
23097 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
23098 PyObject *resultobj;
23099 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
23100 wxDateTime *arg2 = 0 ;
23101 PyObject * obj0 = 0 ;
23102 PyObject * obj1 = 0 ;
23103 char *kwnames[] = {
23104 (char *) "self",(char *) "date", NULL
23105 };
23106
23107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
23108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
23109 if (SWIG_arg_fail(1)) SWIG_fail;
23110 {
23111 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
23112 if (SWIG_arg_fail(2)) SWIG_fail;
23113 if (arg2 == NULL) {
23114 SWIG_null_ref("wxDateTime");
23115 }
23116 if (SWIG_arg_fail(2)) SWIG_fail;
23117 }
23118 {
23119 PyThreadState* __tstate = wxPyBeginAllowThreads();
23120 (arg1)->SetDate((wxDateTime const &)*arg2);
23121
23122 wxPyEndAllowThreads(__tstate);
23123 if (PyErr_Occurred()) SWIG_fail;
23124 }
23125 Py_INCREF(Py_None); resultobj = Py_None;
23126 return resultobj;
23127 fail:
23128 return NULL;
23129 }
23130
23131
23132 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
23133 PyObject *obj;
23134 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23135 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
23136 Py_INCREF(obj);
23137 return Py_BuildValue((char *)"");
23138 }
23139 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23140 PyObject *resultobj;
23141 wxPyApp *result;
23142 char *kwnames[] = {
23143 NULL
23144 };
23145
23146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
23147 {
23148 PyThreadState* __tstate = wxPyBeginAllowThreads();
23149 result = (wxPyApp *)new_wxPyApp();
23150
23151 wxPyEndAllowThreads(__tstate);
23152 if (PyErr_Occurred()) SWIG_fail;
23153 }
23154 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
23155 return resultobj;
23156 fail:
23157 return NULL;
23158 }
23159
23160
23161 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
23162 PyObject *resultobj;
23163 wxPyApp *arg1 = (wxPyApp *) 0 ;
23164 PyObject * obj0 = 0 ;
23165 char *kwnames[] = {
23166 (char *) "self", NULL
23167 };
23168
23169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
23170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23171 if (SWIG_arg_fail(1)) SWIG_fail;
23172 {
23173 PyThreadState* __tstate = wxPyBeginAllowThreads();
23174 delete arg1;
23175
23176 wxPyEndAllowThreads(__tstate);
23177 if (PyErr_Occurred()) SWIG_fail;
23178 }
23179 Py_INCREF(Py_None); resultobj = Py_None;
23180 return resultobj;
23181 fail:
23182 return NULL;
23183 }
23184
23185
23186 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
23187 PyObject *resultobj;
23188 wxPyApp *arg1 = (wxPyApp *) 0 ;
23189 PyObject *arg2 = (PyObject *) 0 ;
23190 PyObject *arg3 = (PyObject *) 0 ;
23191 bool arg4 ;
23192 PyObject * obj0 = 0 ;
23193 PyObject * obj1 = 0 ;
23194 PyObject * obj2 = 0 ;
23195 PyObject * obj3 = 0 ;
23196 char *kwnames[] = {
23197 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
23198 };
23199
23200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
23201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23202 if (SWIG_arg_fail(1)) SWIG_fail;
23203 arg2 = obj1;
23204 arg3 = obj2;
23205 {
23206 arg4 = (bool)(SWIG_As_bool(obj3));
23207 if (SWIG_arg_fail(4)) SWIG_fail;
23208 }
23209 {
23210 PyThreadState* __tstate = wxPyBeginAllowThreads();
23211 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
23212
23213 wxPyEndAllowThreads(__tstate);
23214 if (PyErr_Occurred()) SWIG_fail;
23215 }
23216 Py_INCREF(Py_None); resultobj = Py_None;
23217 return resultobj;
23218 fail:
23219 return NULL;
23220 }
23221
23222
23223 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23224 PyObject *resultobj;
23225 wxPyApp *arg1 = (wxPyApp *) 0 ;
23226 wxString result;
23227 PyObject * obj0 = 0 ;
23228 char *kwnames[] = {
23229 (char *) "self", NULL
23230 };
23231
23232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
23233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23234 if (SWIG_arg_fail(1)) SWIG_fail;
23235 {
23236 PyThreadState* __tstate = wxPyBeginAllowThreads();
23237 result = ((wxPyApp const *)arg1)->GetAppName();
23238
23239 wxPyEndAllowThreads(__tstate);
23240 if (PyErr_Occurred()) SWIG_fail;
23241 }
23242 {
23243 #if wxUSE_UNICODE
23244 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23245 #else
23246 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23247 #endif
23248 }
23249 return resultobj;
23250 fail:
23251 return NULL;
23252 }
23253
23254
23255 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
23256 PyObject *resultobj;
23257 wxPyApp *arg1 = (wxPyApp *) 0 ;
23258 wxString *arg2 = 0 ;
23259 bool temp2 = false ;
23260 PyObject * obj0 = 0 ;
23261 PyObject * obj1 = 0 ;
23262 char *kwnames[] = {
23263 (char *) "self",(char *) "name", NULL
23264 };
23265
23266 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) 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 arg2 = wxString_in_helper(obj1);
23271 if (arg2 == NULL) SWIG_fail;
23272 temp2 = true;
23273 }
23274 {
23275 PyThreadState* __tstate = wxPyBeginAllowThreads();
23276 (arg1)->SetAppName((wxString const &)*arg2);
23277
23278 wxPyEndAllowThreads(__tstate);
23279 if (PyErr_Occurred()) SWIG_fail;
23280 }
23281 Py_INCREF(Py_None); resultobj = Py_None;
23282 {
23283 if (temp2)
23284 delete arg2;
23285 }
23286 return resultobj;
23287 fail:
23288 {
23289 if (temp2)
23290 delete arg2;
23291 }
23292 return NULL;
23293 }
23294
23295
23296 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23297 PyObject *resultobj;
23298 wxPyApp *arg1 = (wxPyApp *) 0 ;
23299 wxString result;
23300 PyObject * obj0 = 0 ;
23301 char *kwnames[] = {
23302 (char *) "self", NULL
23303 };
23304
23305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
23306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23307 if (SWIG_arg_fail(1)) SWIG_fail;
23308 {
23309 PyThreadState* __tstate = wxPyBeginAllowThreads();
23310 result = ((wxPyApp const *)arg1)->GetClassName();
23311
23312 wxPyEndAllowThreads(__tstate);
23313 if (PyErr_Occurred()) SWIG_fail;
23314 }
23315 {
23316 #if wxUSE_UNICODE
23317 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23318 #else
23319 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23320 #endif
23321 }
23322 return resultobj;
23323 fail:
23324 return NULL;
23325 }
23326
23327
23328 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
23329 PyObject *resultobj;
23330 wxPyApp *arg1 = (wxPyApp *) 0 ;
23331 wxString *arg2 = 0 ;
23332 bool temp2 = false ;
23333 PyObject * obj0 = 0 ;
23334 PyObject * obj1 = 0 ;
23335 char *kwnames[] = {
23336 (char *) "self",(char *) "name", NULL
23337 };
23338
23339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
23340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23341 if (SWIG_arg_fail(1)) SWIG_fail;
23342 {
23343 arg2 = wxString_in_helper(obj1);
23344 if (arg2 == NULL) SWIG_fail;
23345 temp2 = true;
23346 }
23347 {
23348 PyThreadState* __tstate = wxPyBeginAllowThreads();
23349 (arg1)->SetClassName((wxString const &)*arg2);
23350
23351 wxPyEndAllowThreads(__tstate);
23352 if (PyErr_Occurred()) SWIG_fail;
23353 }
23354 Py_INCREF(Py_None); resultobj = Py_None;
23355 {
23356 if (temp2)
23357 delete arg2;
23358 }
23359 return resultobj;
23360 fail:
23361 {
23362 if (temp2)
23363 delete arg2;
23364 }
23365 return NULL;
23366 }
23367
23368
23369 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23370 PyObject *resultobj;
23371 wxPyApp *arg1 = (wxPyApp *) 0 ;
23372 wxString *result;
23373 PyObject * obj0 = 0 ;
23374 char *kwnames[] = {
23375 (char *) "self", NULL
23376 };
23377
23378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
23379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23380 if (SWIG_arg_fail(1)) SWIG_fail;
23381 {
23382 PyThreadState* __tstate = wxPyBeginAllowThreads();
23383 {
23384 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
23385 result = (wxString *) &_result_ref;
23386 }
23387
23388 wxPyEndAllowThreads(__tstate);
23389 if (PyErr_Occurred()) SWIG_fail;
23390 }
23391 {
23392 #if wxUSE_UNICODE
23393 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
23394 #else
23395 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
23396 #endif
23397 }
23398 return resultobj;
23399 fail:
23400 return NULL;
23401 }
23402
23403
23404 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
23405 PyObject *resultobj;
23406 wxPyApp *arg1 = (wxPyApp *) 0 ;
23407 wxString *arg2 = 0 ;
23408 bool temp2 = false ;
23409 PyObject * obj0 = 0 ;
23410 PyObject * obj1 = 0 ;
23411 char *kwnames[] = {
23412 (char *) "self",(char *) "name", NULL
23413 };
23414
23415 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
23416 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23417 if (SWIG_arg_fail(1)) SWIG_fail;
23418 {
23419 arg2 = wxString_in_helper(obj1);
23420 if (arg2 == NULL) SWIG_fail;
23421 temp2 = true;
23422 }
23423 {
23424 PyThreadState* __tstate = wxPyBeginAllowThreads();
23425 (arg1)->SetVendorName((wxString const &)*arg2);
23426
23427 wxPyEndAllowThreads(__tstate);
23428 if (PyErr_Occurred()) SWIG_fail;
23429 }
23430 Py_INCREF(Py_None); resultobj = Py_None;
23431 {
23432 if (temp2)
23433 delete arg2;
23434 }
23435 return resultobj;
23436 fail:
23437 {
23438 if (temp2)
23439 delete arg2;
23440 }
23441 return NULL;
23442 }
23443
23444
23445 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
23446 PyObject *resultobj;
23447 wxPyApp *arg1 = (wxPyApp *) 0 ;
23448 wxAppTraits *result;
23449 PyObject * obj0 = 0 ;
23450 char *kwnames[] = {
23451 (char *) "self", NULL
23452 };
23453
23454 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
23455 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23456 if (SWIG_arg_fail(1)) SWIG_fail;
23457 {
23458 PyThreadState* __tstate = wxPyBeginAllowThreads();
23459 result = (wxAppTraits *)(arg1)->GetTraits();
23460
23461 wxPyEndAllowThreads(__tstate);
23462 if (PyErr_Occurred()) SWIG_fail;
23463 }
23464 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
23465 return resultobj;
23466 fail:
23467 return NULL;
23468 }
23469
23470
23471 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23472 PyObject *resultobj;
23473 wxPyApp *arg1 = (wxPyApp *) 0 ;
23474 PyObject * obj0 = 0 ;
23475 char *kwnames[] = {
23476 (char *) "self", NULL
23477 };
23478
23479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
23480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23481 if (SWIG_arg_fail(1)) SWIG_fail;
23482 {
23483 PyThreadState* __tstate = wxPyBeginAllowThreads();
23484 (arg1)->ProcessPendingEvents();
23485
23486 wxPyEndAllowThreads(__tstate);
23487 if (PyErr_Occurred()) SWIG_fail;
23488 }
23489 Py_INCREF(Py_None); resultobj = Py_None;
23490 return resultobj;
23491 fail:
23492 return NULL;
23493 }
23494
23495
23496 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23497 PyObject *resultobj;
23498 wxPyApp *arg1 = (wxPyApp *) 0 ;
23499 bool arg2 = (bool) false ;
23500 bool result;
23501 PyObject * obj0 = 0 ;
23502 PyObject * obj1 = 0 ;
23503 char *kwnames[] = {
23504 (char *) "self",(char *) "onlyIfNeeded", NULL
23505 };
23506
23507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
23508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23509 if (SWIG_arg_fail(1)) SWIG_fail;
23510 if (obj1) {
23511 {
23512 arg2 = (bool)(SWIG_As_bool(obj1));
23513 if (SWIG_arg_fail(2)) SWIG_fail;
23514 }
23515 }
23516 {
23517 PyThreadState* __tstate = wxPyBeginAllowThreads();
23518 result = (bool)(arg1)->Yield(arg2);
23519
23520 wxPyEndAllowThreads(__tstate);
23521 if (PyErr_Occurred()) SWIG_fail;
23522 }
23523 {
23524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23525 }
23526 return resultobj;
23527 fail:
23528 return NULL;
23529 }
23530
23531
23532 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23533 PyObject *resultobj;
23534 wxPyApp *arg1 = (wxPyApp *) 0 ;
23535 PyObject * obj0 = 0 ;
23536 char *kwnames[] = {
23537 (char *) "self", NULL
23538 };
23539
23540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23542 if (SWIG_arg_fail(1)) SWIG_fail;
23543 {
23544 PyThreadState* __tstate = wxPyBeginAllowThreads();
23545 (arg1)->WakeUpIdle();
23546
23547 wxPyEndAllowThreads(__tstate);
23548 if (PyErr_Occurred()) SWIG_fail;
23549 }
23550 Py_INCREF(Py_None); resultobj = Py_None;
23551 return resultobj;
23552 fail:
23553 return NULL;
23554 }
23555
23556
23557 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23558 PyObject *resultobj;
23559 bool result;
23560 char *kwnames[] = {
23561 NULL
23562 };
23563
23564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23565 {
23566 PyThreadState* __tstate = wxPyBeginAllowThreads();
23567 result = (bool)wxPyApp::IsMainLoopRunning();
23568
23569 wxPyEndAllowThreads(__tstate);
23570 if (PyErr_Occurred()) SWIG_fail;
23571 }
23572 {
23573 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23574 }
23575 return resultobj;
23576 fail:
23577 return NULL;
23578 }
23579
23580
23581 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23582 PyObject *resultobj;
23583 wxPyApp *arg1 = (wxPyApp *) 0 ;
23584 int result;
23585 PyObject * obj0 = 0 ;
23586 char *kwnames[] = {
23587 (char *) "self", NULL
23588 };
23589
23590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23592 if (SWIG_arg_fail(1)) SWIG_fail;
23593 {
23594 PyThreadState* __tstate = wxPyBeginAllowThreads();
23595 result = (int)(arg1)->MainLoop();
23596
23597 wxPyEndAllowThreads(__tstate);
23598 if (PyErr_Occurred()) SWIG_fail;
23599 }
23600 {
23601 resultobj = SWIG_From_int((int)(result));
23602 }
23603 return resultobj;
23604 fail:
23605 return NULL;
23606 }
23607
23608
23609 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23610 PyObject *resultobj;
23611 wxPyApp *arg1 = (wxPyApp *) 0 ;
23612 PyObject * obj0 = 0 ;
23613 char *kwnames[] = {
23614 (char *) "self", NULL
23615 };
23616
23617 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23618 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23619 if (SWIG_arg_fail(1)) SWIG_fail;
23620 {
23621 PyThreadState* __tstate = wxPyBeginAllowThreads();
23622 (arg1)->Exit();
23623
23624 wxPyEndAllowThreads(__tstate);
23625 if (PyErr_Occurred()) SWIG_fail;
23626 }
23627 Py_INCREF(Py_None); resultobj = Py_None;
23628 return resultobj;
23629 fail:
23630 return NULL;
23631 }
23632
23633
23634 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23635 PyObject *resultobj;
23636 wxPyApp *arg1 = (wxPyApp *) 0 ;
23637 PyObject * obj0 = 0 ;
23638 char *kwnames[] = {
23639 (char *) "self", NULL
23640 };
23641
23642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23644 if (SWIG_arg_fail(1)) SWIG_fail;
23645 {
23646 PyThreadState* __tstate = wxPyBeginAllowThreads();
23647 (arg1)->ExitMainLoop();
23648
23649 wxPyEndAllowThreads(__tstate);
23650 if (PyErr_Occurred()) SWIG_fail;
23651 }
23652 Py_INCREF(Py_None); resultobj = Py_None;
23653 return resultobj;
23654 fail:
23655 return NULL;
23656 }
23657
23658
23659 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23660 PyObject *resultobj;
23661 wxPyApp *arg1 = (wxPyApp *) 0 ;
23662 bool result;
23663 PyObject * obj0 = 0 ;
23664 char *kwnames[] = {
23665 (char *) "self", NULL
23666 };
23667
23668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23670 if (SWIG_arg_fail(1)) SWIG_fail;
23671 {
23672 PyThreadState* __tstate = wxPyBeginAllowThreads();
23673 result = (bool)(arg1)->Pending();
23674
23675 wxPyEndAllowThreads(__tstate);
23676 if (PyErr_Occurred()) SWIG_fail;
23677 }
23678 {
23679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23680 }
23681 return resultobj;
23682 fail:
23683 return NULL;
23684 }
23685
23686
23687 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23688 PyObject *resultobj;
23689 wxPyApp *arg1 = (wxPyApp *) 0 ;
23690 bool result;
23691 PyObject * obj0 = 0 ;
23692 char *kwnames[] = {
23693 (char *) "self", NULL
23694 };
23695
23696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23698 if (SWIG_arg_fail(1)) SWIG_fail;
23699 {
23700 PyThreadState* __tstate = wxPyBeginAllowThreads();
23701 result = (bool)(arg1)->Dispatch();
23702
23703 wxPyEndAllowThreads(__tstate);
23704 if (PyErr_Occurred()) SWIG_fail;
23705 }
23706 {
23707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23708 }
23709 return resultobj;
23710 fail:
23711 return NULL;
23712 }
23713
23714
23715 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23716 PyObject *resultobj;
23717 wxPyApp *arg1 = (wxPyApp *) 0 ;
23718 bool result;
23719 PyObject * obj0 = 0 ;
23720 char *kwnames[] = {
23721 (char *) "self", NULL
23722 };
23723
23724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23726 if (SWIG_arg_fail(1)) SWIG_fail;
23727 {
23728 PyThreadState* __tstate = wxPyBeginAllowThreads();
23729 result = (bool)(arg1)->ProcessIdle();
23730
23731 wxPyEndAllowThreads(__tstate);
23732 if (PyErr_Occurred()) SWIG_fail;
23733 }
23734 {
23735 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23736 }
23737 return resultobj;
23738 fail:
23739 return NULL;
23740 }
23741
23742
23743 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23744 PyObject *resultobj;
23745 wxPyApp *arg1 = (wxPyApp *) 0 ;
23746 wxWindow *arg2 = (wxWindow *) 0 ;
23747 wxIdleEvent *arg3 = 0 ;
23748 bool result;
23749 PyObject * obj0 = 0 ;
23750 PyObject * obj1 = 0 ;
23751 PyObject * obj2 = 0 ;
23752 char *kwnames[] = {
23753 (char *) "self",(char *) "win",(char *) "event", NULL
23754 };
23755
23756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23758 if (SWIG_arg_fail(1)) SWIG_fail;
23759 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23760 if (SWIG_arg_fail(2)) SWIG_fail;
23761 {
23762 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23763 if (SWIG_arg_fail(3)) SWIG_fail;
23764 if (arg3 == NULL) {
23765 SWIG_null_ref("wxIdleEvent");
23766 }
23767 if (SWIG_arg_fail(3)) SWIG_fail;
23768 }
23769 {
23770 PyThreadState* __tstate = wxPyBeginAllowThreads();
23771 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23772
23773 wxPyEndAllowThreads(__tstate);
23774 if (PyErr_Occurred()) SWIG_fail;
23775 }
23776 {
23777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23778 }
23779 return resultobj;
23780 fail:
23781 return NULL;
23782 }
23783
23784
23785 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23786 PyObject *resultobj;
23787 wxPyApp *arg1 = (wxPyApp *) 0 ;
23788 bool result;
23789 PyObject * obj0 = 0 ;
23790 char *kwnames[] = {
23791 (char *) "self", NULL
23792 };
23793
23794 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23795 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23796 if (SWIG_arg_fail(1)) SWIG_fail;
23797 {
23798 PyThreadState* __tstate = wxPyBeginAllowThreads();
23799 result = (bool)((wxPyApp const *)arg1)->IsActive();
23800
23801 wxPyEndAllowThreads(__tstate);
23802 if (PyErr_Occurred()) SWIG_fail;
23803 }
23804 {
23805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23806 }
23807 return resultobj;
23808 fail:
23809 return NULL;
23810 }
23811
23812
23813 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23814 PyObject *resultobj;
23815 wxPyApp *arg1 = (wxPyApp *) 0 ;
23816 wxWindow *arg2 = (wxWindow *) 0 ;
23817 PyObject * obj0 = 0 ;
23818 PyObject * obj1 = 0 ;
23819 char *kwnames[] = {
23820 (char *) "self",(char *) "win", NULL
23821 };
23822
23823 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23824 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23825 if (SWIG_arg_fail(1)) SWIG_fail;
23826 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23827 if (SWIG_arg_fail(2)) SWIG_fail;
23828 {
23829 PyThreadState* __tstate = wxPyBeginAllowThreads();
23830 (arg1)->SetTopWindow(arg2);
23831
23832 wxPyEndAllowThreads(__tstate);
23833 if (PyErr_Occurred()) SWIG_fail;
23834 }
23835 Py_INCREF(Py_None); resultobj = Py_None;
23836 return resultobj;
23837 fail:
23838 return NULL;
23839 }
23840
23841
23842 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23843 PyObject *resultobj;
23844 wxPyApp *arg1 = (wxPyApp *) 0 ;
23845 wxWindow *result;
23846 PyObject * obj0 = 0 ;
23847 char *kwnames[] = {
23848 (char *) "self", NULL
23849 };
23850
23851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23853 if (SWIG_arg_fail(1)) SWIG_fail;
23854 {
23855 PyThreadState* __tstate = wxPyBeginAllowThreads();
23856 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23857
23858 wxPyEndAllowThreads(__tstate);
23859 if (PyErr_Occurred()) SWIG_fail;
23860 }
23861 {
23862 resultobj = wxPyMake_wxObject(result, 0);
23863 }
23864 return resultobj;
23865 fail:
23866 return NULL;
23867 }
23868
23869
23870 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23871 PyObject *resultobj;
23872 wxPyApp *arg1 = (wxPyApp *) 0 ;
23873 bool arg2 ;
23874 PyObject * obj0 = 0 ;
23875 PyObject * obj1 = 0 ;
23876 char *kwnames[] = {
23877 (char *) "self",(char *) "flag", NULL
23878 };
23879
23880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23882 if (SWIG_arg_fail(1)) SWIG_fail;
23883 {
23884 arg2 = (bool)(SWIG_As_bool(obj1));
23885 if (SWIG_arg_fail(2)) SWIG_fail;
23886 }
23887 {
23888 PyThreadState* __tstate = wxPyBeginAllowThreads();
23889 (arg1)->SetExitOnFrameDelete(arg2);
23890
23891 wxPyEndAllowThreads(__tstate);
23892 if (PyErr_Occurred()) SWIG_fail;
23893 }
23894 Py_INCREF(Py_None); resultobj = Py_None;
23895 return resultobj;
23896 fail:
23897 return NULL;
23898 }
23899
23900
23901 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23902 PyObject *resultobj;
23903 wxPyApp *arg1 = (wxPyApp *) 0 ;
23904 bool result;
23905 PyObject * obj0 = 0 ;
23906 char *kwnames[] = {
23907 (char *) "self", NULL
23908 };
23909
23910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
23911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23912 if (SWIG_arg_fail(1)) SWIG_fail;
23913 {
23914 PyThreadState* __tstate = wxPyBeginAllowThreads();
23915 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23916
23917 wxPyEndAllowThreads(__tstate);
23918 if (PyErr_Occurred()) SWIG_fail;
23919 }
23920 {
23921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23922 }
23923 return resultobj;
23924 fail:
23925 return NULL;
23926 }
23927
23928
23929 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23930 PyObject *resultobj;
23931 wxPyApp *arg1 = (wxPyApp *) 0 ;
23932 bool arg2 ;
23933 PyObject * obj0 = 0 ;
23934 PyObject * obj1 = 0 ;
23935 char *kwnames[] = {
23936 (char *) "self",(char *) "flag", NULL
23937 };
23938
23939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
23940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23941 if (SWIG_arg_fail(1)) SWIG_fail;
23942 {
23943 arg2 = (bool)(SWIG_As_bool(obj1));
23944 if (SWIG_arg_fail(2)) SWIG_fail;
23945 }
23946 {
23947 PyThreadState* __tstate = wxPyBeginAllowThreads();
23948 (arg1)->SetUseBestVisual(arg2);
23949
23950 wxPyEndAllowThreads(__tstate);
23951 if (PyErr_Occurred()) SWIG_fail;
23952 }
23953 Py_INCREF(Py_None); resultobj = Py_None;
23954 return resultobj;
23955 fail:
23956 return NULL;
23957 }
23958
23959
23960 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23961 PyObject *resultobj;
23962 wxPyApp *arg1 = (wxPyApp *) 0 ;
23963 bool result;
23964 PyObject * obj0 = 0 ;
23965 char *kwnames[] = {
23966 (char *) "self", NULL
23967 };
23968
23969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23971 if (SWIG_arg_fail(1)) SWIG_fail;
23972 {
23973 PyThreadState* __tstate = wxPyBeginAllowThreads();
23974 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23975
23976 wxPyEndAllowThreads(__tstate);
23977 if (PyErr_Occurred()) SWIG_fail;
23978 }
23979 {
23980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23981 }
23982 return resultobj;
23983 fail:
23984 return NULL;
23985 }
23986
23987
23988 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23989 PyObject *resultobj;
23990 wxPyApp *arg1 = (wxPyApp *) 0 ;
23991 int arg2 ;
23992 PyObject * obj0 = 0 ;
23993 PyObject * obj1 = 0 ;
23994 char *kwnames[] = {
23995 (char *) "self",(char *) "mode", NULL
23996 };
23997
23998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24000 if (SWIG_arg_fail(1)) SWIG_fail;
24001 {
24002 arg2 = (int)(SWIG_As_int(obj1));
24003 if (SWIG_arg_fail(2)) SWIG_fail;
24004 }
24005 {
24006 PyThreadState* __tstate = wxPyBeginAllowThreads();
24007 (arg1)->SetPrintMode(arg2);
24008
24009 wxPyEndAllowThreads(__tstate);
24010 if (PyErr_Occurred()) SWIG_fail;
24011 }
24012 Py_INCREF(Py_None); resultobj = Py_None;
24013 return resultobj;
24014 fail:
24015 return NULL;
24016 }
24017
24018
24019 static PyObject *_wrap_PyApp_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
24020 PyObject *resultobj;
24021 wxPyApp *arg1 = (wxPyApp *) 0 ;
24022 int result;
24023 PyObject * obj0 = 0 ;
24024 char *kwnames[] = {
24025 (char *) "self", NULL
24026 };
24027
24028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
24029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24030 if (SWIG_arg_fail(1)) SWIG_fail;
24031 {
24032 PyThreadState* __tstate = wxPyBeginAllowThreads();
24033 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
24034
24035 wxPyEndAllowThreads(__tstate);
24036 if (PyErr_Occurred()) SWIG_fail;
24037 }
24038 {
24039 resultobj = SWIG_From_int((int)(result));
24040 }
24041 return resultobj;
24042 fail:
24043 return NULL;
24044 }
24045
24046
24047 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24048 PyObject *resultobj;
24049 wxPyApp *arg1 = (wxPyApp *) 0 ;
24050 int arg2 ;
24051 PyObject * obj0 = 0 ;
24052 PyObject * obj1 = 0 ;
24053 char *kwnames[] = {
24054 (char *) "self",(char *) "mode", NULL
24055 };
24056
24057 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
24058 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24059 if (SWIG_arg_fail(1)) SWIG_fail;
24060 {
24061 arg2 = (int)(SWIG_As_int(obj1));
24062 if (SWIG_arg_fail(2)) SWIG_fail;
24063 }
24064 {
24065 PyThreadState* __tstate = wxPyBeginAllowThreads();
24066 (arg1)->SetAssertMode(arg2);
24067
24068 wxPyEndAllowThreads(__tstate);
24069 if (PyErr_Occurred()) SWIG_fail;
24070 }
24071 Py_INCREF(Py_None); resultobj = Py_None;
24072 return resultobj;
24073 fail:
24074 return NULL;
24075 }
24076
24077
24078 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
24079 PyObject *resultobj;
24080 wxPyApp *arg1 = (wxPyApp *) 0 ;
24081 int result;
24082 PyObject * obj0 = 0 ;
24083 char *kwnames[] = {
24084 (char *) "self", NULL
24085 };
24086
24087 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
24088 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24089 if (SWIG_arg_fail(1)) SWIG_fail;
24090 {
24091 PyThreadState* __tstate = wxPyBeginAllowThreads();
24092 result = (int)(arg1)->GetAssertMode();
24093
24094 wxPyEndAllowThreads(__tstate);
24095 if (PyErr_Occurred()) SWIG_fail;
24096 }
24097 {
24098 resultobj = SWIG_From_int((int)(result));
24099 }
24100 return resultobj;
24101 fail:
24102 return NULL;
24103 }
24104
24105
24106 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24107 PyObject *resultobj;
24108 bool result;
24109 char *kwnames[] = {
24110 NULL
24111 };
24112
24113 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
24114 {
24115 PyThreadState* __tstate = wxPyBeginAllowThreads();
24116 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
24117
24118 wxPyEndAllowThreads(__tstate);
24119 if (PyErr_Occurred()) SWIG_fail;
24120 }
24121 {
24122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24123 }
24124 return resultobj;
24125 fail:
24126 return NULL;
24127 }
24128
24129
24130 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24131 PyObject *resultobj;
24132 long result;
24133 char *kwnames[] = {
24134 NULL
24135 };
24136
24137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
24138 {
24139 PyThreadState* __tstate = wxPyBeginAllowThreads();
24140 result = (long)wxPyApp::GetMacAboutMenuItemId();
24141
24142 wxPyEndAllowThreads(__tstate);
24143 if (PyErr_Occurred()) SWIG_fail;
24144 }
24145 {
24146 resultobj = SWIG_From_long((long)(result));
24147 }
24148 return resultobj;
24149 fail:
24150 return NULL;
24151 }
24152
24153
24154 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24155 PyObject *resultobj;
24156 long result;
24157 char *kwnames[] = {
24158 NULL
24159 };
24160
24161 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
24162 {
24163 PyThreadState* __tstate = wxPyBeginAllowThreads();
24164 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
24165
24166 wxPyEndAllowThreads(__tstate);
24167 if (PyErr_Occurred()) SWIG_fail;
24168 }
24169 {
24170 resultobj = SWIG_From_long((long)(result));
24171 }
24172 return resultobj;
24173 fail:
24174 return NULL;
24175 }
24176
24177
24178 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24179 PyObject *resultobj;
24180 long result;
24181 char *kwnames[] = {
24182 NULL
24183 };
24184
24185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
24186 {
24187 PyThreadState* __tstate = wxPyBeginAllowThreads();
24188 result = (long)wxPyApp::GetMacExitMenuItemId();
24189
24190 wxPyEndAllowThreads(__tstate);
24191 if (PyErr_Occurred()) SWIG_fail;
24192 }
24193 {
24194 resultobj = SWIG_From_long((long)(result));
24195 }
24196 return resultobj;
24197 fail:
24198 return NULL;
24199 }
24200
24201
24202 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24203 PyObject *resultobj;
24204 wxString result;
24205 char *kwnames[] = {
24206 NULL
24207 };
24208
24209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
24210 {
24211 PyThreadState* __tstate = wxPyBeginAllowThreads();
24212 result = wxPyApp::GetMacHelpMenuTitleName();
24213
24214 wxPyEndAllowThreads(__tstate);
24215 if (PyErr_Occurred()) SWIG_fail;
24216 }
24217 {
24218 #if wxUSE_UNICODE
24219 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24220 #else
24221 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24222 #endif
24223 }
24224 return resultobj;
24225 fail:
24226 return NULL;
24227 }
24228
24229
24230 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
24231 PyObject *resultobj;
24232 bool arg1 ;
24233 PyObject * obj0 = 0 ;
24234 char *kwnames[] = {
24235 (char *) "val", NULL
24236 };
24237
24238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
24239 {
24240 arg1 = (bool)(SWIG_As_bool(obj0));
24241 if (SWIG_arg_fail(1)) SWIG_fail;
24242 }
24243 {
24244 PyThreadState* __tstate = wxPyBeginAllowThreads();
24245 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
24246
24247 wxPyEndAllowThreads(__tstate);
24248 if (PyErr_Occurred()) SWIG_fail;
24249 }
24250 Py_INCREF(Py_None); resultobj = Py_None;
24251 return resultobj;
24252 fail:
24253 return NULL;
24254 }
24255
24256
24257 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24258 PyObject *resultobj;
24259 long arg1 ;
24260 PyObject * obj0 = 0 ;
24261 char *kwnames[] = {
24262 (char *) "val", NULL
24263 };
24264
24265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
24266 {
24267 arg1 = (long)(SWIG_As_long(obj0));
24268 if (SWIG_arg_fail(1)) SWIG_fail;
24269 }
24270 {
24271 PyThreadState* __tstate = wxPyBeginAllowThreads();
24272 wxPyApp::SetMacAboutMenuItemId(arg1);
24273
24274 wxPyEndAllowThreads(__tstate);
24275 if (PyErr_Occurred()) SWIG_fail;
24276 }
24277 Py_INCREF(Py_None); resultobj = Py_None;
24278 return resultobj;
24279 fail:
24280 return NULL;
24281 }
24282
24283
24284 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24285 PyObject *resultobj;
24286 long arg1 ;
24287 PyObject * obj0 = 0 ;
24288 char *kwnames[] = {
24289 (char *) "val", NULL
24290 };
24291
24292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
24293 {
24294 arg1 = (long)(SWIG_As_long(obj0));
24295 if (SWIG_arg_fail(1)) SWIG_fail;
24296 }
24297 {
24298 PyThreadState* __tstate = wxPyBeginAllowThreads();
24299 wxPyApp::SetMacPreferencesMenuItemId(arg1);
24300
24301 wxPyEndAllowThreads(__tstate);
24302 if (PyErr_Occurred()) SWIG_fail;
24303 }
24304 Py_INCREF(Py_None); resultobj = Py_None;
24305 return resultobj;
24306 fail:
24307 return NULL;
24308 }
24309
24310
24311 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
24312 PyObject *resultobj;
24313 long arg1 ;
24314 PyObject * obj0 = 0 ;
24315 char *kwnames[] = {
24316 (char *) "val", NULL
24317 };
24318
24319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
24320 {
24321 arg1 = (long)(SWIG_As_long(obj0));
24322 if (SWIG_arg_fail(1)) SWIG_fail;
24323 }
24324 {
24325 PyThreadState* __tstate = wxPyBeginAllowThreads();
24326 wxPyApp::SetMacExitMenuItemId(arg1);
24327
24328 wxPyEndAllowThreads(__tstate);
24329 if (PyErr_Occurred()) SWIG_fail;
24330 }
24331 Py_INCREF(Py_None); resultobj = Py_None;
24332 return resultobj;
24333 fail:
24334 return NULL;
24335 }
24336
24337
24338 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
24339 PyObject *resultobj;
24340 wxString *arg1 = 0 ;
24341 bool temp1 = false ;
24342 PyObject * obj0 = 0 ;
24343 char *kwnames[] = {
24344 (char *) "val", NULL
24345 };
24346
24347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
24348 {
24349 arg1 = wxString_in_helper(obj0);
24350 if (arg1 == NULL) SWIG_fail;
24351 temp1 = true;
24352 }
24353 {
24354 PyThreadState* __tstate = wxPyBeginAllowThreads();
24355 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
24356
24357 wxPyEndAllowThreads(__tstate);
24358 if (PyErr_Occurred()) SWIG_fail;
24359 }
24360 Py_INCREF(Py_None); resultobj = Py_None;
24361 {
24362 if (temp1)
24363 delete arg1;
24364 }
24365 return resultobj;
24366 fail:
24367 {
24368 if (temp1)
24369 delete arg1;
24370 }
24371 return NULL;
24372 }
24373
24374
24375 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
24376 PyObject *resultobj;
24377 wxPyApp *arg1 = (wxPyApp *) 0 ;
24378 PyObject * obj0 = 0 ;
24379 char *kwnames[] = {
24380 (char *) "self", NULL
24381 };
24382
24383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
24384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
24385 if (SWIG_arg_fail(1)) SWIG_fail;
24386 {
24387 PyThreadState* __tstate = wxPyBeginAllowThreads();
24388 (arg1)->_BootstrapApp();
24389
24390 wxPyEndAllowThreads(__tstate);
24391 if (PyErr_Occurred()) SWIG_fail;
24392 }
24393 Py_INCREF(Py_None); resultobj = Py_None;
24394 return resultobj;
24395 fail:
24396 return NULL;
24397 }
24398
24399
24400 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
24401 PyObject *resultobj;
24402 int result;
24403 char *kwnames[] = {
24404 NULL
24405 };
24406
24407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
24408 {
24409 PyThreadState* __tstate = wxPyBeginAllowThreads();
24410 result = (int)wxPyApp::GetComCtl32Version();
24411
24412 wxPyEndAllowThreads(__tstate);
24413 if (PyErr_Occurred()) SWIG_fail;
24414 }
24415 {
24416 resultobj = SWIG_From_int((int)(result));
24417 }
24418 return resultobj;
24419 fail:
24420 return NULL;
24421 }
24422
24423
24424 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
24425 PyObject *obj;
24426 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24427 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
24428 Py_INCREF(obj);
24429 return Py_BuildValue((char *)"");
24430 }
24431 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24432 PyObject *resultobj;
24433 char *kwnames[] = {
24434 NULL
24435 };
24436
24437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
24438 {
24439 PyThreadState* __tstate = wxPyBeginAllowThreads();
24440 wxExit();
24441
24442 wxPyEndAllowThreads(__tstate);
24443 if (PyErr_Occurred()) SWIG_fail;
24444 }
24445 Py_INCREF(Py_None); resultobj = Py_None;
24446 return resultobj;
24447 fail:
24448 return NULL;
24449 }
24450
24451
24452 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
24453 PyObject *resultobj;
24454 bool result;
24455 char *kwnames[] = {
24456 NULL
24457 };
24458
24459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
24460 {
24461 PyThreadState* __tstate = wxPyBeginAllowThreads();
24462 result = (bool)wxYield();
24463
24464 wxPyEndAllowThreads(__tstate);
24465 if (PyErr_Occurred()) SWIG_fail;
24466 }
24467 {
24468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24469 }
24470 return resultobj;
24471 fail:
24472 return NULL;
24473 }
24474
24475
24476 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
24477 PyObject *resultobj;
24478 bool result;
24479 char *kwnames[] = {
24480 NULL
24481 };
24482
24483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
24484 {
24485 PyThreadState* __tstate = wxPyBeginAllowThreads();
24486 result = (bool)wxYieldIfNeeded();
24487
24488 wxPyEndAllowThreads(__tstate);
24489 if (PyErr_Occurred()) SWIG_fail;
24490 }
24491 {
24492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24493 }
24494 return resultobj;
24495 fail:
24496 return NULL;
24497 }
24498
24499
24500 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
24501 PyObject *resultobj;
24502 wxWindow *arg1 = (wxWindow *) NULL ;
24503 bool arg2 = (bool) false ;
24504 bool result;
24505 PyObject * obj0 = 0 ;
24506 PyObject * obj1 = 0 ;
24507 char *kwnames[] = {
24508 (char *) "win",(char *) "onlyIfNeeded", NULL
24509 };
24510
24511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
24512 if (obj0) {
24513 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24514 if (SWIG_arg_fail(1)) SWIG_fail;
24515 }
24516 if (obj1) {
24517 {
24518 arg2 = (bool)(SWIG_As_bool(obj1));
24519 if (SWIG_arg_fail(2)) SWIG_fail;
24520 }
24521 }
24522 {
24523 PyThreadState* __tstate = wxPyBeginAllowThreads();
24524 result = (bool)wxSafeYield(arg1,arg2);
24525
24526 wxPyEndAllowThreads(__tstate);
24527 if (PyErr_Occurred()) SWIG_fail;
24528 }
24529 {
24530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24531 }
24532 return resultobj;
24533 fail:
24534 return NULL;
24535 }
24536
24537
24538 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24539 PyObject *resultobj;
24540 char *kwnames[] = {
24541 NULL
24542 };
24543
24544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24545 {
24546 PyThreadState* __tstate = wxPyBeginAllowThreads();
24547 wxWakeUpIdle();
24548
24549 wxPyEndAllowThreads(__tstate);
24550 if (PyErr_Occurred()) SWIG_fail;
24551 }
24552 Py_INCREF(Py_None); resultobj = Py_None;
24553 return resultobj;
24554 fail:
24555 return NULL;
24556 }
24557
24558
24559 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24560 PyObject *resultobj;
24561 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24562 wxEvent *arg2 = 0 ;
24563 PyObject * obj0 = 0 ;
24564 PyObject * obj1 = 0 ;
24565 char *kwnames[] = {
24566 (char *) "dest",(char *) "event", NULL
24567 };
24568
24569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24571 if (SWIG_arg_fail(1)) SWIG_fail;
24572 {
24573 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24574 if (SWIG_arg_fail(2)) SWIG_fail;
24575 if (arg2 == NULL) {
24576 SWIG_null_ref("wxEvent");
24577 }
24578 if (SWIG_arg_fail(2)) SWIG_fail;
24579 }
24580 {
24581 PyThreadState* __tstate = wxPyBeginAllowThreads();
24582 wxPostEvent(arg1,*arg2);
24583
24584 wxPyEndAllowThreads(__tstate);
24585 if (PyErr_Occurred()) SWIG_fail;
24586 }
24587 Py_INCREF(Py_None); resultobj = Py_None;
24588 return resultobj;
24589 fail:
24590 return NULL;
24591 }
24592
24593
24594 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24595 PyObject *resultobj;
24596 char *kwnames[] = {
24597 NULL
24598 };
24599
24600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24601 {
24602 PyThreadState* __tstate = wxPyBeginAllowThreads();
24603 wxApp_CleanUp();
24604
24605 wxPyEndAllowThreads(__tstate);
24606 if (PyErr_Occurred()) SWIG_fail;
24607 }
24608 Py_INCREF(Py_None); resultobj = Py_None;
24609 return resultobj;
24610 fail:
24611 return NULL;
24612 }
24613
24614
24615 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24616 PyObject *resultobj;
24617 wxPyApp *result;
24618 char *kwnames[] = {
24619 NULL
24620 };
24621
24622 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24623 {
24624 PyThreadState* __tstate = wxPyBeginAllowThreads();
24625 result = (wxPyApp *)wxPyGetApp();
24626
24627 wxPyEndAllowThreads(__tstate);
24628 if (PyErr_Occurred()) SWIG_fail;
24629 }
24630 {
24631 resultobj = wxPyMake_wxObject(result, 0);
24632 }
24633 return resultobj;
24634 fail:
24635 return NULL;
24636 }
24637
24638
24639 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24640 PyObject *resultobj;
24641 char *arg1 = (char *) 0 ;
24642 PyObject * obj0 = 0 ;
24643 char *kwnames[] = {
24644 (char *) "encoding", NULL
24645 };
24646
24647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24648 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24649 SWIG_arg_fail(1);SWIG_fail;
24650 }
24651 {
24652 PyThreadState* __tstate = wxPyBeginAllowThreads();
24653 wxSetDefaultPyEncoding((char const *)arg1);
24654
24655 wxPyEndAllowThreads(__tstate);
24656 if (PyErr_Occurred()) SWIG_fail;
24657 }
24658 Py_INCREF(Py_None); resultobj = Py_None;
24659 return resultobj;
24660 fail:
24661 return NULL;
24662 }
24663
24664
24665 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24666 PyObject *resultobj;
24667 char *result;
24668 char *kwnames[] = {
24669 NULL
24670 };
24671
24672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24673 {
24674 PyThreadState* __tstate = wxPyBeginAllowThreads();
24675 result = (char *)wxGetDefaultPyEncoding();
24676
24677 wxPyEndAllowThreads(__tstate);
24678 if (PyErr_Occurred()) SWIG_fail;
24679 }
24680 resultobj = SWIG_FromCharPtr(result);
24681 return resultobj;
24682 fail:
24683 return NULL;
24684 }
24685
24686
24687 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24688 PyObject *resultobj;
24689 wxEventLoop *result;
24690 char *kwnames[] = {
24691 NULL
24692 };
24693
24694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24695 {
24696 PyThreadState* __tstate = wxPyBeginAllowThreads();
24697 result = (wxEventLoop *)new wxEventLoop();
24698
24699 wxPyEndAllowThreads(__tstate);
24700 if (PyErr_Occurred()) SWIG_fail;
24701 }
24702 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24703 return resultobj;
24704 fail:
24705 return NULL;
24706 }
24707
24708
24709 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24710 PyObject *resultobj;
24711 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24712 PyObject * obj0 = 0 ;
24713 char *kwnames[] = {
24714 (char *) "self", NULL
24715 };
24716
24717 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24718 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24719 if (SWIG_arg_fail(1)) SWIG_fail;
24720 {
24721 PyThreadState* __tstate = wxPyBeginAllowThreads();
24722 delete arg1;
24723
24724 wxPyEndAllowThreads(__tstate);
24725 if (PyErr_Occurred()) SWIG_fail;
24726 }
24727 Py_INCREF(Py_None); resultobj = Py_None;
24728 return resultobj;
24729 fail:
24730 return NULL;
24731 }
24732
24733
24734 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24735 PyObject *resultobj;
24736 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24737 int result;
24738 PyObject * obj0 = 0 ;
24739 char *kwnames[] = {
24740 (char *) "self", NULL
24741 };
24742
24743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24745 if (SWIG_arg_fail(1)) SWIG_fail;
24746 {
24747 PyThreadState* __tstate = wxPyBeginAllowThreads();
24748 result = (int)(arg1)->Run();
24749
24750 wxPyEndAllowThreads(__tstate);
24751 if (PyErr_Occurred()) SWIG_fail;
24752 }
24753 {
24754 resultobj = SWIG_From_int((int)(result));
24755 }
24756 return resultobj;
24757 fail:
24758 return NULL;
24759 }
24760
24761
24762 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24763 PyObject *resultobj;
24764 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24765 int arg2 = (int) 0 ;
24766 PyObject * obj0 = 0 ;
24767 PyObject * obj1 = 0 ;
24768 char *kwnames[] = {
24769 (char *) "self",(char *) "rc", NULL
24770 };
24771
24772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24774 if (SWIG_arg_fail(1)) SWIG_fail;
24775 if (obj1) {
24776 {
24777 arg2 = (int)(SWIG_As_int(obj1));
24778 if (SWIG_arg_fail(2)) SWIG_fail;
24779 }
24780 }
24781 {
24782 PyThreadState* __tstate = wxPyBeginAllowThreads();
24783 (arg1)->Exit(arg2);
24784
24785 wxPyEndAllowThreads(__tstate);
24786 if (PyErr_Occurred()) SWIG_fail;
24787 }
24788 Py_INCREF(Py_None); resultobj = Py_None;
24789 return resultobj;
24790 fail:
24791 return NULL;
24792 }
24793
24794
24795 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24796 PyObject *resultobj;
24797 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24798 bool result;
24799 PyObject * obj0 = 0 ;
24800 char *kwnames[] = {
24801 (char *) "self", NULL
24802 };
24803
24804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24806 if (SWIG_arg_fail(1)) SWIG_fail;
24807 {
24808 PyThreadState* __tstate = wxPyBeginAllowThreads();
24809 result = (bool)((wxEventLoop const *)arg1)->Pending();
24810
24811 wxPyEndAllowThreads(__tstate);
24812 if (PyErr_Occurred()) SWIG_fail;
24813 }
24814 {
24815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24816 }
24817 return resultobj;
24818 fail:
24819 return NULL;
24820 }
24821
24822
24823 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24824 PyObject *resultobj;
24825 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24826 bool result;
24827 PyObject * obj0 = 0 ;
24828 char *kwnames[] = {
24829 (char *) "self", NULL
24830 };
24831
24832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24834 if (SWIG_arg_fail(1)) SWIG_fail;
24835 {
24836 PyThreadState* __tstate = wxPyBeginAllowThreads();
24837 result = (bool)(arg1)->Dispatch();
24838
24839 wxPyEndAllowThreads(__tstate);
24840 if (PyErr_Occurred()) SWIG_fail;
24841 }
24842 {
24843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24844 }
24845 return resultobj;
24846 fail:
24847 return NULL;
24848 }
24849
24850
24851 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24852 PyObject *resultobj;
24853 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24854 bool result;
24855 PyObject * obj0 = 0 ;
24856 char *kwnames[] = {
24857 (char *) "self", NULL
24858 };
24859
24860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24862 if (SWIG_arg_fail(1)) SWIG_fail;
24863 {
24864 PyThreadState* __tstate = wxPyBeginAllowThreads();
24865 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24866
24867 wxPyEndAllowThreads(__tstate);
24868 if (PyErr_Occurred()) SWIG_fail;
24869 }
24870 {
24871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24872 }
24873 return resultobj;
24874 fail:
24875 return NULL;
24876 }
24877
24878
24879 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24880 PyObject *resultobj;
24881 wxEventLoop *result;
24882 char *kwnames[] = {
24883 NULL
24884 };
24885
24886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24887 {
24888 PyThreadState* __tstate = wxPyBeginAllowThreads();
24889 result = (wxEventLoop *)wxEventLoop::GetActive();
24890
24891 wxPyEndAllowThreads(__tstate);
24892 if (PyErr_Occurred()) SWIG_fail;
24893 }
24894 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24895 return resultobj;
24896 fail:
24897 return NULL;
24898 }
24899
24900
24901 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24902 PyObject *resultobj;
24903 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24904 PyObject * obj0 = 0 ;
24905 char *kwnames[] = {
24906 (char *) "loop", NULL
24907 };
24908
24909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
24910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24911 if (SWIG_arg_fail(1)) SWIG_fail;
24912 {
24913 PyThreadState* __tstate = wxPyBeginAllowThreads();
24914 wxEventLoop::SetActive(arg1);
24915
24916 wxPyEndAllowThreads(__tstate);
24917 if (PyErr_Occurred()) SWIG_fail;
24918 }
24919 Py_INCREF(Py_None); resultobj = Py_None;
24920 return resultobj;
24921 fail:
24922 return NULL;
24923 }
24924
24925
24926 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
24927 PyObject *obj;
24928 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24929 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
24930 Py_INCREF(obj);
24931 return Py_BuildValue((char *)"");
24932 }
24933 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24934 PyObject *resultobj;
24935 int arg1 = (int) 0 ;
24936 int arg2 = (int) 0 ;
24937 int arg3 = (int) 0 ;
24938 wxAcceleratorEntry *result;
24939 PyObject * obj0 = 0 ;
24940 PyObject * obj1 = 0 ;
24941 PyObject * obj2 = 0 ;
24942 char *kwnames[] = {
24943 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
24944 };
24945
24946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
24947 if (obj0) {
24948 {
24949 arg1 = (int)(SWIG_As_int(obj0));
24950 if (SWIG_arg_fail(1)) SWIG_fail;
24951 }
24952 }
24953 if (obj1) {
24954 {
24955 arg2 = (int)(SWIG_As_int(obj1));
24956 if (SWIG_arg_fail(2)) SWIG_fail;
24957 }
24958 }
24959 if (obj2) {
24960 {
24961 arg3 = (int)(SWIG_As_int(obj2));
24962 if (SWIG_arg_fail(3)) SWIG_fail;
24963 }
24964 }
24965 {
24966 PyThreadState* __tstate = wxPyBeginAllowThreads();
24967 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24968
24969 wxPyEndAllowThreads(__tstate);
24970 if (PyErr_Occurred()) SWIG_fail;
24971 }
24972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24973 return resultobj;
24974 fail:
24975 return NULL;
24976 }
24977
24978
24979 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24980 PyObject *resultobj;
24981 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24982 PyObject * obj0 = 0 ;
24983 char *kwnames[] = {
24984 (char *) "self", NULL
24985 };
24986
24987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24989 if (SWIG_arg_fail(1)) SWIG_fail;
24990 {
24991 PyThreadState* __tstate = wxPyBeginAllowThreads();
24992 delete arg1;
24993
24994 wxPyEndAllowThreads(__tstate);
24995 if (PyErr_Occurred()) SWIG_fail;
24996 }
24997 Py_INCREF(Py_None); resultobj = Py_None;
24998 return resultobj;
24999 fail:
25000 return NULL;
25001 }
25002
25003
25004 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
25005 PyObject *resultobj;
25006 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25007 int arg2 ;
25008 int arg3 ;
25009 int arg4 ;
25010 PyObject * obj0 = 0 ;
25011 PyObject * obj1 = 0 ;
25012 PyObject * obj2 = 0 ;
25013 PyObject * obj3 = 0 ;
25014 char *kwnames[] = {
25015 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
25016 };
25017
25018 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25019 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25020 if (SWIG_arg_fail(1)) SWIG_fail;
25021 {
25022 arg2 = (int)(SWIG_As_int(obj1));
25023 if (SWIG_arg_fail(2)) SWIG_fail;
25024 }
25025 {
25026 arg3 = (int)(SWIG_As_int(obj2));
25027 if (SWIG_arg_fail(3)) SWIG_fail;
25028 }
25029 {
25030 arg4 = (int)(SWIG_As_int(obj3));
25031 if (SWIG_arg_fail(4)) SWIG_fail;
25032 }
25033 {
25034 PyThreadState* __tstate = wxPyBeginAllowThreads();
25035 (arg1)->Set(arg2,arg3,arg4);
25036
25037 wxPyEndAllowThreads(__tstate);
25038 if (PyErr_Occurred()) SWIG_fail;
25039 }
25040 Py_INCREF(Py_None); resultobj = Py_None;
25041 return resultobj;
25042 fail:
25043 return NULL;
25044 }
25045
25046
25047 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
25048 PyObject *resultobj;
25049 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25050 int result;
25051 PyObject * obj0 = 0 ;
25052 char *kwnames[] = {
25053 (char *) "self", NULL
25054 };
25055
25056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
25057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25058 if (SWIG_arg_fail(1)) SWIG_fail;
25059 {
25060 PyThreadState* __tstate = wxPyBeginAllowThreads();
25061 result = (int)(arg1)->GetFlags();
25062
25063 wxPyEndAllowThreads(__tstate);
25064 if (PyErr_Occurred()) SWIG_fail;
25065 }
25066 {
25067 resultobj = SWIG_From_int((int)(result));
25068 }
25069 return resultobj;
25070 fail:
25071 return NULL;
25072 }
25073
25074
25075 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
25076 PyObject *resultobj;
25077 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25078 int result;
25079 PyObject * obj0 = 0 ;
25080 char *kwnames[] = {
25081 (char *) "self", NULL
25082 };
25083
25084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
25085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25086 if (SWIG_arg_fail(1)) SWIG_fail;
25087 {
25088 PyThreadState* __tstate = wxPyBeginAllowThreads();
25089 result = (int)(arg1)->GetKeyCode();
25090
25091 wxPyEndAllowThreads(__tstate);
25092 if (PyErr_Occurred()) SWIG_fail;
25093 }
25094 {
25095 resultobj = SWIG_From_int((int)(result));
25096 }
25097 return resultobj;
25098 fail:
25099 return NULL;
25100 }
25101
25102
25103 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
25104 PyObject *resultobj;
25105 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
25106 int result;
25107 PyObject * obj0 = 0 ;
25108 char *kwnames[] = {
25109 (char *) "self", NULL
25110 };
25111
25112 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
25113 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
25114 if (SWIG_arg_fail(1)) SWIG_fail;
25115 {
25116 PyThreadState* __tstate = wxPyBeginAllowThreads();
25117 result = (int)(arg1)->GetCommand();
25118
25119 wxPyEndAllowThreads(__tstate);
25120 if (PyErr_Occurred()) SWIG_fail;
25121 }
25122 {
25123 resultobj = SWIG_From_int((int)(result));
25124 }
25125 return resultobj;
25126 fail:
25127 return NULL;
25128 }
25129
25130
25131 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
25132 PyObject *obj;
25133 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25134 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
25135 Py_INCREF(obj);
25136 return Py_BuildValue((char *)"");
25137 }
25138 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25139 PyObject *resultobj;
25140 int arg1 ;
25141 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
25142 wxAcceleratorTable *result;
25143 PyObject * obj0 = 0 ;
25144 char *kwnames[] = {
25145 (char *) "n", NULL
25146 };
25147
25148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
25149 {
25150 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
25151 if (arg2) arg1 = PyList_Size(obj0);
25152 else arg1 = 0;
25153 }
25154 {
25155 PyThreadState* __tstate = wxPyBeginAllowThreads();
25156 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
25157
25158 wxPyEndAllowThreads(__tstate);
25159 if (PyErr_Occurred()) SWIG_fail;
25160 }
25161 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
25162 {
25163 delete [] arg2;
25164 }
25165 return resultobj;
25166 fail:
25167 {
25168 delete [] arg2;
25169 }
25170 return NULL;
25171 }
25172
25173
25174 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
25175 PyObject *resultobj;
25176 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25177 PyObject * obj0 = 0 ;
25178 char *kwnames[] = {
25179 (char *) "self", NULL
25180 };
25181
25182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
25183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25184 if (SWIG_arg_fail(1)) SWIG_fail;
25185 {
25186 PyThreadState* __tstate = wxPyBeginAllowThreads();
25187 delete arg1;
25188
25189 wxPyEndAllowThreads(__tstate);
25190 if (PyErr_Occurred()) SWIG_fail;
25191 }
25192 Py_INCREF(Py_None); resultobj = Py_None;
25193 return resultobj;
25194 fail:
25195 return NULL;
25196 }
25197
25198
25199 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
25200 PyObject *resultobj;
25201 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
25202 bool result;
25203 PyObject * obj0 = 0 ;
25204 char *kwnames[] = {
25205 (char *) "self", NULL
25206 };
25207
25208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
25209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
25210 if (SWIG_arg_fail(1)) SWIG_fail;
25211 {
25212 PyThreadState* __tstate = wxPyBeginAllowThreads();
25213 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
25214
25215 wxPyEndAllowThreads(__tstate);
25216 if (PyErr_Occurred()) SWIG_fail;
25217 }
25218 {
25219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25220 }
25221 return resultobj;
25222 fail:
25223 return NULL;
25224 }
25225
25226
25227 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
25228 PyObject *obj;
25229 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25230 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
25231 Py_INCREF(obj);
25232 return Py_BuildValue((char *)"");
25233 }
25234 static int _wrap_NullAcceleratorTable_set(PyObject *) {
25235 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
25236 return 1;
25237 }
25238
25239
25240 static PyObject *_wrap_NullAcceleratorTable_get(void) {
25241 PyObject *pyobj;
25242
25243 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
25244 return pyobj;
25245 }
25246
25247
25248 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
25249 PyObject *resultobj;
25250 wxString *arg1 = 0 ;
25251 wxAcceleratorEntry *result;
25252 bool temp1 = false ;
25253 PyObject * obj0 = 0 ;
25254 char *kwnames[] = {
25255 (char *) "label", NULL
25256 };
25257
25258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
25259 {
25260 arg1 = wxString_in_helper(obj0);
25261 if (arg1 == NULL) SWIG_fail;
25262 temp1 = true;
25263 }
25264 {
25265 PyThreadState* __tstate = wxPyBeginAllowThreads();
25266 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
25267
25268 wxPyEndAllowThreads(__tstate);
25269 if (PyErr_Occurred()) SWIG_fail;
25270 }
25271 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
25272 {
25273 if (temp1)
25274 delete arg1;
25275 }
25276 return resultobj;
25277 fail:
25278 {
25279 if (temp1)
25280 delete arg1;
25281 }
25282 return NULL;
25283 }
25284
25285
25286 static int _wrap_PanelNameStr_set(PyObject *) {
25287 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
25288 return 1;
25289 }
25290
25291
25292 static PyObject *_wrap_PanelNameStr_get(void) {
25293 PyObject *pyobj;
25294
25295 {
25296 #if wxUSE_UNICODE
25297 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25298 #else
25299 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
25300 #endif
25301 }
25302 return pyobj;
25303 }
25304
25305
25306 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25307 PyObject *resultobj;
25308 wxVisualAttributes *result;
25309 char *kwnames[] = {
25310 NULL
25311 };
25312
25313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
25314 {
25315 PyThreadState* __tstate = wxPyBeginAllowThreads();
25316 result = (wxVisualAttributes *)new_wxVisualAttributes();
25317
25318 wxPyEndAllowThreads(__tstate);
25319 if (PyErr_Occurred()) SWIG_fail;
25320 }
25321 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
25322 return resultobj;
25323 fail:
25324 return NULL;
25325 }
25326
25327
25328 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
25329 PyObject *resultobj;
25330 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25331 PyObject * obj0 = 0 ;
25332 char *kwnames[] = {
25333 (char *) "self", NULL
25334 };
25335
25336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
25337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25338 if (SWIG_arg_fail(1)) SWIG_fail;
25339 {
25340 PyThreadState* __tstate = wxPyBeginAllowThreads();
25341 delete_wxVisualAttributes(arg1);
25342
25343 wxPyEndAllowThreads(__tstate);
25344 if (PyErr_Occurred()) SWIG_fail;
25345 }
25346 Py_INCREF(Py_None); resultobj = Py_None;
25347 return resultobj;
25348 fail:
25349 return NULL;
25350 }
25351
25352
25353 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
25354 PyObject *resultobj;
25355 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25356 wxFont *arg2 = (wxFont *) 0 ;
25357 PyObject * obj0 = 0 ;
25358 PyObject * obj1 = 0 ;
25359 char *kwnames[] = {
25360 (char *) "self",(char *) "font", NULL
25361 };
25362
25363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
25364 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25365 if (SWIG_arg_fail(1)) SWIG_fail;
25366 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
25367 if (SWIG_arg_fail(2)) SWIG_fail;
25368 if (arg1) (arg1)->font = *arg2;
25369
25370 Py_INCREF(Py_None); resultobj = Py_None;
25371 return resultobj;
25372 fail:
25373 return NULL;
25374 }
25375
25376
25377 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
25378 PyObject *resultobj;
25379 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25380 wxFont *result;
25381 PyObject * obj0 = 0 ;
25382 char *kwnames[] = {
25383 (char *) "self", NULL
25384 };
25385
25386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
25387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25388 if (SWIG_arg_fail(1)) SWIG_fail;
25389 result = (wxFont *)& ((arg1)->font);
25390
25391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
25392 return resultobj;
25393 fail:
25394 return NULL;
25395 }
25396
25397
25398 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25399 PyObject *resultobj;
25400 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25401 wxColour *arg2 = (wxColour *) 0 ;
25402 PyObject * obj0 = 0 ;
25403 PyObject * obj1 = 0 ;
25404 char *kwnames[] = {
25405 (char *) "self",(char *) "colFg", NULL
25406 };
25407
25408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
25409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25410 if (SWIG_arg_fail(1)) SWIG_fail;
25411 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25412 if (SWIG_arg_fail(2)) SWIG_fail;
25413 if (arg1) (arg1)->colFg = *arg2;
25414
25415 Py_INCREF(Py_None); resultobj = Py_None;
25416 return resultobj;
25417 fail:
25418 return NULL;
25419 }
25420
25421
25422 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25423 PyObject *resultobj;
25424 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25425 wxColour *result;
25426 PyObject * obj0 = 0 ;
25427 char *kwnames[] = {
25428 (char *) "self", NULL
25429 };
25430
25431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
25432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25433 if (SWIG_arg_fail(1)) SWIG_fail;
25434 result = (wxColour *)& ((arg1)->colFg);
25435
25436 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25437 return resultobj;
25438 fail:
25439 return NULL;
25440 }
25441
25442
25443 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
25444 PyObject *resultobj;
25445 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25446 wxColour *arg2 = (wxColour *) 0 ;
25447 PyObject * obj0 = 0 ;
25448 PyObject * obj1 = 0 ;
25449 char *kwnames[] = {
25450 (char *) "self",(char *) "colBg", NULL
25451 };
25452
25453 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
25454 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25455 if (SWIG_arg_fail(1)) SWIG_fail;
25456 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
25457 if (SWIG_arg_fail(2)) SWIG_fail;
25458 if (arg1) (arg1)->colBg = *arg2;
25459
25460 Py_INCREF(Py_None); resultobj = Py_None;
25461 return resultobj;
25462 fail:
25463 return NULL;
25464 }
25465
25466
25467 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
25468 PyObject *resultobj;
25469 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
25470 wxColour *result;
25471 PyObject * obj0 = 0 ;
25472 char *kwnames[] = {
25473 (char *) "self", NULL
25474 };
25475
25476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
25477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
25478 if (SWIG_arg_fail(1)) SWIG_fail;
25479 result = (wxColour *)& ((arg1)->colBg);
25480
25481 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
25482 return resultobj;
25483 fail:
25484 return NULL;
25485 }
25486
25487
25488 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
25489 PyObject *obj;
25490 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
25491 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
25492 Py_INCREF(obj);
25493 return Py_BuildValue((char *)"");
25494 }
25495 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
25496 PyObject *resultobj;
25497 wxWindow *arg1 = (wxWindow *) 0 ;
25498 int arg2 = (int) (int)-1 ;
25499 wxPoint const &arg3_defvalue = wxDefaultPosition ;
25500 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
25501 wxSize const &arg4_defvalue = wxDefaultSize ;
25502 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
25503 long arg5 = (long) 0 ;
25504 wxString const &arg6_defvalue = wxPyPanelNameStr ;
25505 wxString *arg6 = (wxString *) &arg6_defvalue ;
25506 wxWindow *result;
25507 wxPoint temp3 ;
25508 wxSize temp4 ;
25509 bool temp6 = false ;
25510 PyObject * obj0 = 0 ;
25511 PyObject * obj1 = 0 ;
25512 PyObject * obj2 = 0 ;
25513 PyObject * obj3 = 0 ;
25514 PyObject * obj4 = 0 ;
25515 PyObject * obj5 = 0 ;
25516 char *kwnames[] = {
25517 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25518 };
25519
25520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25522 if (SWIG_arg_fail(1)) SWIG_fail;
25523 if (obj1) {
25524 {
25525 arg2 = (int const)(SWIG_As_int(obj1));
25526 if (SWIG_arg_fail(2)) SWIG_fail;
25527 }
25528 }
25529 if (obj2) {
25530 {
25531 arg3 = &temp3;
25532 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25533 }
25534 }
25535 if (obj3) {
25536 {
25537 arg4 = &temp4;
25538 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25539 }
25540 }
25541 if (obj4) {
25542 {
25543 arg5 = (long)(SWIG_As_long(obj4));
25544 if (SWIG_arg_fail(5)) SWIG_fail;
25545 }
25546 }
25547 if (obj5) {
25548 {
25549 arg6 = wxString_in_helper(obj5);
25550 if (arg6 == NULL) SWIG_fail;
25551 temp6 = true;
25552 }
25553 }
25554 {
25555 if (!wxPyCheckForApp()) SWIG_fail;
25556 PyThreadState* __tstate = wxPyBeginAllowThreads();
25557 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25558
25559 wxPyEndAllowThreads(__tstate);
25560 if (PyErr_Occurred()) SWIG_fail;
25561 }
25562 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25563 {
25564 if (temp6)
25565 delete arg6;
25566 }
25567 return resultobj;
25568 fail:
25569 {
25570 if (temp6)
25571 delete arg6;
25572 }
25573 return NULL;
25574 }
25575
25576
25577 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25578 PyObject *resultobj;
25579 wxWindow *result;
25580 char *kwnames[] = {
25581 NULL
25582 };
25583
25584 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25585 {
25586 if (!wxPyCheckForApp()) SWIG_fail;
25587 PyThreadState* __tstate = wxPyBeginAllowThreads();
25588 result = (wxWindow *)new wxWindow();
25589
25590 wxPyEndAllowThreads(__tstate);
25591 if (PyErr_Occurred()) SWIG_fail;
25592 }
25593 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25594 return resultobj;
25595 fail:
25596 return NULL;
25597 }
25598
25599
25600 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25601 PyObject *resultobj;
25602 wxWindow *arg1 = (wxWindow *) 0 ;
25603 wxWindow *arg2 = (wxWindow *) 0 ;
25604 int arg3 = (int) (int)-1 ;
25605 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25606 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25607 wxSize const &arg5_defvalue = wxDefaultSize ;
25608 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25609 long arg6 = (long) 0 ;
25610 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25611 wxString *arg7 = (wxString *) &arg7_defvalue ;
25612 bool result;
25613 wxPoint temp4 ;
25614 wxSize temp5 ;
25615 bool temp7 = false ;
25616 PyObject * obj0 = 0 ;
25617 PyObject * obj1 = 0 ;
25618 PyObject * obj2 = 0 ;
25619 PyObject * obj3 = 0 ;
25620 PyObject * obj4 = 0 ;
25621 PyObject * obj5 = 0 ;
25622 PyObject * obj6 = 0 ;
25623 char *kwnames[] = {
25624 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25625 };
25626
25627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25629 if (SWIG_arg_fail(1)) SWIG_fail;
25630 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25631 if (SWIG_arg_fail(2)) SWIG_fail;
25632 if (obj2) {
25633 {
25634 arg3 = (int const)(SWIG_As_int(obj2));
25635 if (SWIG_arg_fail(3)) SWIG_fail;
25636 }
25637 }
25638 if (obj3) {
25639 {
25640 arg4 = &temp4;
25641 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25642 }
25643 }
25644 if (obj4) {
25645 {
25646 arg5 = &temp5;
25647 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25648 }
25649 }
25650 if (obj5) {
25651 {
25652 arg6 = (long)(SWIG_As_long(obj5));
25653 if (SWIG_arg_fail(6)) SWIG_fail;
25654 }
25655 }
25656 if (obj6) {
25657 {
25658 arg7 = wxString_in_helper(obj6);
25659 if (arg7 == NULL) SWIG_fail;
25660 temp7 = true;
25661 }
25662 }
25663 {
25664 PyThreadState* __tstate = wxPyBeginAllowThreads();
25665 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25666
25667 wxPyEndAllowThreads(__tstate);
25668 if (PyErr_Occurred()) SWIG_fail;
25669 }
25670 {
25671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25672 }
25673 {
25674 if (temp7)
25675 delete arg7;
25676 }
25677 return resultobj;
25678 fail:
25679 {
25680 if (temp7)
25681 delete arg7;
25682 }
25683 return NULL;
25684 }
25685
25686
25687 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25688 PyObject *resultobj;
25689 wxWindow *arg1 = (wxWindow *) 0 ;
25690 bool arg2 = (bool) false ;
25691 bool result;
25692 PyObject * obj0 = 0 ;
25693 PyObject * obj1 = 0 ;
25694 char *kwnames[] = {
25695 (char *) "self",(char *) "force", NULL
25696 };
25697
25698 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
25699 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25700 if (SWIG_arg_fail(1)) SWIG_fail;
25701 if (obj1) {
25702 {
25703 arg2 = (bool)(SWIG_As_bool(obj1));
25704 if (SWIG_arg_fail(2)) SWIG_fail;
25705 }
25706 }
25707 {
25708 PyThreadState* __tstate = wxPyBeginAllowThreads();
25709 result = (bool)(arg1)->Close(arg2);
25710
25711 wxPyEndAllowThreads(__tstate);
25712 if (PyErr_Occurred()) SWIG_fail;
25713 }
25714 {
25715 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25716 }
25717 return resultobj;
25718 fail:
25719 return NULL;
25720 }
25721
25722
25723 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25724 PyObject *resultobj;
25725 wxWindow *arg1 = (wxWindow *) 0 ;
25726 bool result;
25727 PyObject * obj0 = 0 ;
25728 char *kwnames[] = {
25729 (char *) "self", NULL
25730 };
25731
25732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25734 if (SWIG_arg_fail(1)) SWIG_fail;
25735 {
25736 PyThreadState* __tstate = wxPyBeginAllowThreads();
25737 result = (bool)(arg1)->Destroy();
25738
25739 wxPyEndAllowThreads(__tstate);
25740 if (PyErr_Occurred()) SWIG_fail;
25741 }
25742 {
25743 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25744 }
25745 return resultobj;
25746 fail:
25747 return NULL;
25748 }
25749
25750
25751 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25752 PyObject *resultobj;
25753 wxWindow *arg1 = (wxWindow *) 0 ;
25754 bool result;
25755 PyObject * obj0 = 0 ;
25756 char *kwnames[] = {
25757 (char *) "self", NULL
25758 };
25759
25760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25762 if (SWIG_arg_fail(1)) SWIG_fail;
25763 {
25764 PyThreadState* __tstate = wxPyBeginAllowThreads();
25765 result = (bool)(arg1)->DestroyChildren();
25766
25767 wxPyEndAllowThreads(__tstate);
25768 if (PyErr_Occurred()) SWIG_fail;
25769 }
25770 {
25771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25772 }
25773 return resultobj;
25774 fail:
25775 return NULL;
25776 }
25777
25778
25779 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25780 PyObject *resultobj;
25781 wxWindow *arg1 = (wxWindow *) 0 ;
25782 bool result;
25783 PyObject * obj0 = 0 ;
25784 char *kwnames[] = {
25785 (char *) "self", NULL
25786 };
25787
25788 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25789 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25790 if (SWIG_arg_fail(1)) SWIG_fail;
25791 {
25792 PyThreadState* __tstate = wxPyBeginAllowThreads();
25793 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25794
25795 wxPyEndAllowThreads(__tstate);
25796 if (PyErr_Occurred()) SWIG_fail;
25797 }
25798 {
25799 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25800 }
25801 return resultobj;
25802 fail:
25803 return NULL;
25804 }
25805
25806
25807 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25808 PyObject *resultobj;
25809 wxWindow *arg1 = (wxWindow *) 0 ;
25810 wxString *arg2 = 0 ;
25811 bool temp2 = false ;
25812 PyObject * obj0 = 0 ;
25813 PyObject * obj1 = 0 ;
25814 char *kwnames[] = {
25815 (char *) "self",(char *) "label", NULL
25816 };
25817
25818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25820 if (SWIG_arg_fail(1)) SWIG_fail;
25821 {
25822 arg2 = wxString_in_helper(obj1);
25823 if (arg2 == NULL) SWIG_fail;
25824 temp2 = true;
25825 }
25826 {
25827 PyThreadState* __tstate = wxPyBeginAllowThreads();
25828 (arg1)->SetLabel((wxString const &)*arg2);
25829
25830 wxPyEndAllowThreads(__tstate);
25831 if (PyErr_Occurred()) SWIG_fail;
25832 }
25833 Py_INCREF(Py_None); resultobj = Py_None;
25834 {
25835 if (temp2)
25836 delete arg2;
25837 }
25838 return resultobj;
25839 fail:
25840 {
25841 if (temp2)
25842 delete arg2;
25843 }
25844 return NULL;
25845 }
25846
25847
25848 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25849 PyObject *resultobj;
25850 wxWindow *arg1 = (wxWindow *) 0 ;
25851 wxString result;
25852 PyObject * obj0 = 0 ;
25853 char *kwnames[] = {
25854 (char *) "self", NULL
25855 };
25856
25857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25859 if (SWIG_arg_fail(1)) SWIG_fail;
25860 {
25861 PyThreadState* __tstate = wxPyBeginAllowThreads();
25862 result = ((wxWindow const *)arg1)->GetLabel();
25863
25864 wxPyEndAllowThreads(__tstate);
25865 if (PyErr_Occurred()) SWIG_fail;
25866 }
25867 {
25868 #if wxUSE_UNICODE
25869 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25870 #else
25871 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25872 #endif
25873 }
25874 return resultobj;
25875 fail:
25876 return NULL;
25877 }
25878
25879
25880 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25881 PyObject *resultobj;
25882 wxWindow *arg1 = (wxWindow *) 0 ;
25883 wxString *arg2 = 0 ;
25884 bool temp2 = false ;
25885 PyObject * obj0 = 0 ;
25886 PyObject * obj1 = 0 ;
25887 char *kwnames[] = {
25888 (char *) "self",(char *) "name", NULL
25889 };
25890
25891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25893 if (SWIG_arg_fail(1)) SWIG_fail;
25894 {
25895 arg2 = wxString_in_helper(obj1);
25896 if (arg2 == NULL) SWIG_fail;
25897 temp2 = true;
25898 }
25899 {
25900 PyThreadState* __tstate = wxPyBeginAllowThreads();
25901 (arg1)->SetName((wxString const &)*arg2);
25902
25903 wxPyEndAllowThreads(__tstate);
25904 if (PyErr_Occurred()) SWIG_fail;
25905 }
25906 Py_INCREF(Py_None); resultobj = Py_None;
25907 {
25908 if (temp2)
25909 delete arg2;
25910 }
25911 return resultobj;
25912 fail:
25913 {
25914 if (temp2)
25915 delete arg2;
25916 }
25917 return NULL;
25918 }
25919
25920
25921 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25922 PyObject *resultobj;
25923 wxWindow *arg1 = (wxWindow *) 0 ;
25924 wxString result;
25925 PyObject * obj0 = 0 ;
25926 char *kwnames[] = {
25927 (char *) "self", NULL
25928 };
25929
25930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25932 if (SWIG_arg_fail(1)) SWIG_fail;
25933 {
25934 PyThreadState* __tstate = wxPyBeginAllowThreads();
25935 result = ((wxWindow const *)arg1)->GetName();
25936
25937 wxPyEndAllowThreads(__tstate);
25938 if (PyErr_Occurred()) SWIG_fail;
25939 }
25940 {
25941 #if wxUSE_UNICODE
25942 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25943 #else
25944 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25945 #endif
25946 }
25947 return resultobj;
25948 fail:
25949 return NULL;
25950 }
25951
25952
25953 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25954 PyObject *resultobj;
25955 wxWindow *arg1 = (wxWindow *) 0 ;
25956 wxWindowVariant arg2 ;
25957 PyObject * obj0 = 0 ;
25958 PyObject * obj1 = 0 ;
25959 char *kwnames[] = {
25960 (char *) "self",(char *) "variant", NULL
25961 };
25962
25963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25965 if (SWIG_arg_fail(1)) SWIG_fail;
25966 {
25967 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25968 if (SWIG_arg_fail(2)) SWIG_fail;
25969 }
25970 {
25971 PyThreadState* __tstate = wxPyBeginAllowThreads();
25972 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25973
25974 wxPyEndAllowThreads(__tstate);
25975 if (PyErr_Occurred()) SWIG_fail;
25976 }
25977 Py_INCREF(Py_None); resultobj = Py_None;
25978 return resultobj;
25979 fail:
25980 return NULL;
25981 }
25982
25983
25984 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25985 PyObject *resultobj;
25986 wxWindow *arg1 = (wxWindow *) 0 ;
25987 wxWindowVariant result;
25988 PyObject * obj0 = 0 ;
25989 char *kwnames[] = {
25990 (char *) "self", NULL
25991 };
25992
25993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25995 if (SWIG_arg_fail(1)) SWIG_fail;
25996 {
25997 PyThreadState* __tstate = wxPyBeginAllowThreads();
25998 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25999
26000 wxPyEndAllowThreads(__tstate);
26001 if (PyErr_Occurred()) SWIG_fail;
26002 }
26003 resultobj = SWIG_From_int((result));
26004 return resultobj;
26005 fail:
26006 return NULL;
26007 }
26008
26009
26010 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
26011 PyObject *resultobj;
26012 wxWindow *arg1 = (wxWindow *) 0 ;
26013 int arg2 ;
26014 PyObject * obj0 = 0 ;
26015 PyObject * obj1 = 0 ;
26016 char *kwnames[] = {
26017 (char *) "self",(char *) "winid", NULL
26018 };
26019
26020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
26021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26022 if (SWIG_arg_fail(1)) SWIG_fail;
26023 {
26024 arg2 = (int)(SWIG_As_int(obj1));
26025 if (SWIG_arg_fail(2)) SWIG_fail;
26026 }
26027 {
26028 PyThreadState* __tstate = wxPyBeginAllowThreads();
26029 (arg1)->SetId(arg2);
26030
26031 wxPyEndAllowThreads(__tstate);
26032 if (PyErr_Occurred()) SWIG_fail;
26033 }
26034 Py_INCREF(Py_None); resultobj = Py_None;
26035 return resultobj;
26036 fail:
26037 return NULL;
26038 }
26039
26040
26041 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
26042 PyObject *resultobj;
26043 wxWindow *arg1 = (wxWindow *) 0 ;
26044 int result;
26045 PyObject * obj0 = 0 ;
26046 char *kwnames[] = {
26047 (char *) "self", NULL
26048 };
26049
26050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
26051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26052 if (SWIG_arg_fail(1)) SWIG_fail;
26053 {
26054 PyThreadState* __tstate = wxPyBeginAllowThreads();
26055 result = (int)((wxWindow const *)arg1)->GetId();
26056
26057 wxPyEndAllowThreads(__tstate);
26058 if (PyErr_Occurred()) SWIG_fail;
26059 }
26060 {
26061 resultobj = SWIG_From_int((int)(result));
26062 }
26063 return resultobj;
26064 fail:
26065 return NULL;
26066 }
26067
26068
26069 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26070 PyObject *resultobj;
26071 int result;
26072 char *kwnames[] = {
26073 NULL
26074 };
26075
26076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
26077 {
26078 PyThreadState* __tstate = wxPyBeginAllowThreads();
26079 result = (int)wxWindow::NewControlId();
26080
26081 wxPyEndAllowThreads(__tstate);
26082 if (PyErr_Occurred()) SWIG_fail;
26083 }
26084 {
26085 resultobj = SWIG_From_int((int)(result));
26086 }
26087 return resultobj;
26088 fail:
26089 return NULL;
26090 }
26091
26092
26093 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26094 PyObject *resultobj;
26095 int arg1 ;
26096 int result;
26097 PyObject * obj0 = 0 ;
26098 char *kwnames[] = {
26099 (char *) "winid", NULL
26100 };
26101
26102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
26103 {
26104 arg1 = (int)(SWIG_As_int(obj0));
26105 if (SWIG_arg_fail(1)) SWIG_fail;
26106 }
26107 {
26108 PyThreadState* __tstate = wxPyBeginAllowThreads();
26109 result = (int)wxWindow::NextControlId(arg1);
26110
26111 wxPyEndAllowThreads(__tstate);
26112 if (PyErr_Occurred()) SWIG_fail;
26113 }
26114 {
26115 resultobj = SWIG_From_int((int)(result));
26116 }
26117 return resultobj;
26118 fail:
26119 return NULL;
26120 }
26121
26122
26123 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
26124 PyObject *resultobj;
26125 int arg1 ;
26126 int result;
26127 PyObject * obj0 = 0 ;
26128 char *kwnames[] = {
26129 (char *) "winid", NULL
26130 };
26131
26132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
26133 {
26134 arg1 = (int)(SWIG_As_int(obj0));
26135 if (SWIG_arg_fail(1)) SWIG_fail;
26136 }
26137 {
26138 PyThreadState* __tstate = wxPyBeginAllowThreads();
26139 result = (int)wxWindow::PrevControlId(arg1);
26140
26141 wxPyEndAllowThreads(__tstate);
26142 if (PyErr_Occurred()) SWIG_fail;
26143 }
26144 {
26145 resultobj = SWIG_From_int((int)(result));
26146 }
26147 return resultobj;
26148 fail:
26149 return NULL;
26150 }
26151
26152
26153 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26154 PyObject *resultobj;
26155 wxWindow *arg1 = (wxWindow *) 0 ;
26156 wxSize *arg2 = 0 ;
26157 wxSize temp2 ;
26158 PyObject * obj0 = 0 ;
26159 PyObject * obj1 = 0 ;
26160 char *kwnames[] = {
26161 (char *) "self",(char *) "size", NULL
26162 };
26163
26164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
26165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26166 if (SWIG_arg_fail(1)) SWIG_fail;
26167 {
26168 arg2 = &temp2;
26169 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26170 }
26171 {
26172 PyThreadState* __tstate = wxPyBeginAllowThreads();
26173 (arg1)->SetSize((wxSize const &)*arg2);
26174
26175 wxPyEndAllowThreads(__tstate);
26176 if (PyErr_Occurred()) SWIG_fail;
26177 }
26178 Py_INCREF(Py_None); resultobj = Py_None;
26179 return resultobj;
26180 fail:
26181 return NULL;
26182 }
26183
26184
26185 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
26186 PyObject *resultobj;
26187 wxWindow *arg1 = (wxWindow *) 0 ;
26188 int arg2 ;
26189 int arg3 ;
26190 int arg4 ;
26191 int arg5 ;
26192 int arg6 = (int) wxSIZE_AUTO ;
26193 PyObject * obj0 = 0 ;
26194 PyObject * obj1 = 0 ;
26195 PyObject * obj2 = 0 ;
26196 PyObject * obj3 = 0 ;
26197 PyObject * obj4 = 0 ;
26198 PyObject * obj5 = 0 ;
26199 char *kwnames[] = {
26200 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
26201 };
26202
26203 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
26204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26205 if (SWIG_arg_fail(1)) SWIG_fail;
26206 {
26207 arg2 = (int)(SWIG_As_int(obj1));
26208 if (SWIG_arg_fail(2)) SWIG_fail;
26209 }
26210 {
26211 arg3 = (int)(SWIG_As_int(obj2));
26212 if (SWIG_arg_fail(3)) SWIG_fail;
26213 }
26214 {
26215 arg4 = (int)(SWIG_As_int(obj3));
26216 if (SWIG_arg_fail(4)) SWIG_fail;
26217 }
26218 {
26219 arg5 = (int)(SWIG_As_int(obj4));
26220 if (SWIG_arg_fail(5)) SWIG_fail;
26221 }
26222 if (obj5) {
26223 {
26224 arg6 = (int)(SWIG_As_int(obj5));
26225 if (SWIG_arg_fail(6)) SWIG_fail;
26226 }
26227 }
26228 {
26229 PyThreadState* __tstate = wxPyBeginAllowThreads();
26230 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
26231
26232 wxPyEndAllowThreads(__tstate);
26233 if (PyErr_Occurred()) SWIG_fail;
26234 }
26235 Py_INCREF(Py_None); resultobj = Py_None;
26236 return resultobj;
26237 fail:
26238 return NULL;
26239 }
26240
26241
26242 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26243 PyObject *resultobj;
26244 wxWindow *arg1 = (wxWindow *) 0 ;
26245 wxRect *arg2 = 0 ;
26246 int arg3 = (int) wxSIZE_AUTO ;
26247 wxRect temp2 ;
26248 PyObject * obj0 = 0 ;
26249 PyObject * obj1 = 0 ;
26250 PyObject * obj2 = 0 ;
26251 char *kwnames[] = {
26252 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
26253 };
26254
26255 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
26256 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26257 if (SWIG_arg_fail(1)) SWIG_fail;
26258 {
26259 arg2 = &temp2;
26260 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26261 }
26262 if (obj2) {
26263 {
26264 arg3 = (int)(SWIG_As_int(obj2));
26265 if (SWIG_arg_fail(3)) SWIG_fail;
26266 }
26267 }
26268 {
26269 PyThreadState* __tstate = wxPyBeginAllowThreads();
26270 (arg1)->SetSize((wxRect const &)*arg2,arg3);
26271
26272 wxPyEndAllowThreads(__tstate);
26273 if (PyErr_Occurred()) SWIG_fail;
26274 }
26275 Py_INCREF(Py_None); resultobj = Py_None;
26276 return resultobj;
26277 fail:
26278 return NULL;
26279 }
26280
26281
26282 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26283 PyObject *resultobj;
26284 wxWindow *arg1 = (wxWindow *) 0 ;
26285 int arg2 ;
26286 int arg3 ;
26287 PyObject * obj0 = 0 ;
26288 PyObject * obj1 = 0 ;
26289 PyObject * obj2 = 0 ;
26290 char *kwnames[] = {
26291 (char *) "self",(char *) "width",(char *) "height", NULL
26292 };
26293
26294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26296 if (SWIG_arg_fail(1)) SWIG_fail;
26297 {
26298 arg2 = (int)(SWIG_As_int(obj1));
26299 if (SWIG_arg_fail(2)) SWIG_fail;
26300 }
26301 {
26302 arg3 = (int)(SWIG_As_int(obj2));
26303 if (SWIG_arg_fail(3)) SWIG_fail;
26304 }
26305 {
26306 PyThreadState* __tstate = wxPyBeginAllowThreads();
26307 (arg1)->SetSize(arg2,arg3);
26308
26309 wxPyEndAllowThreads(__tstate);
26310 if (PyErr_Occurred()) SWIG_fail;
26311 }
26312 Py_INCREF(Py_None); resultobj = Py_None;
26313 return resultobj;
26314 fail:
26315 return NULL;
26316 }
26317
26318
26319 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
26320 PyObject *resultobj;
26321 wxWindow *arg1 = (wxWindow *) 0 ;
26322 wxPoint *arg2 = 0 ;
26323 int arg3 = (int) wxSIZE_USE_EXISTING ;
26324 wxPoint temp2 ;
26325 PyObject * obj0 = 0 ;
26326 PyObject * obj1 = 0 ;
26327 PyObject * obj2 = 0 ;
26328 char *kwnames[] = {
26329 (char *) "self",(char *) "pt",(char *) "flags", NULL
26330 };
26331
26332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
26333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26334 if (SWIG_arg_fail(1)) SWIG_fail;
26335 {
26336 arg2 = &temp2;
26337 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26338 }
26339 if (obj2) {
26340 {
26341 arg3 = (int)(SWIG_As_int(obj2));
26342 if (SWIG_arg_fail(3)) SWIG_fail;
26343 }
26344 }
26345 {
26346 PyThreadState* __tstate = wxPyBeginAllowThreads();
26347 (arg1)->Move((wxPoint const &)*arg2,arg3);
26348
26349 wxPyEndAllowThreads(__tstate);
26350 if (PyErr_Occurred()) SWIG_fail;
26351 }
26352 Py_INCREF(Py_None); resultobj = Py_None;
26353 return resultobj;
26354 fail:
26355 return NULL;
26356 }
26357
26358
26359 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
26360 PyObject *resultobj;
26361 wxWindow *arg1 = (wxWindow *) 0 ;
26362 int arg2 ;
26363 int arg3 ;
26364 int arg4 = (int) wxSIZE_USE_EXISTING ;
26365 PyObject * obj0 = 0 ;
26366 PyObject * obj1 = 0 ;
26367 PyObject * obj2 = 0 ;
26368 PyObject * obj3 = 0 ;
26369 char *kwnames[] = {
26370 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
26371 };
26372
26373 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26374 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26375 if (SWIG_arg_fail(1)) SWIG_fail;
26376 {
26377 arg2 = (int)(SWIG_As_int(obj1));
26378 if (SWIG_arg_fail(2)) SWIG_fail;
26379 }
26380 {
26381 arg3 = (int)(SWIG_As_int(obj2));
26382 if (SWIG_arg_fail(3)) SWIG_fail;
26383 }
26384 if (obj3) {
26385 {
26386 arg4 = (int)(SWIG_As_int(obj3));
26387 if (SWIG_arg_fail(4)) SWIG_fail;
26388 }
26389 }
26390 {
26391 PyThreadState* __tstate = wxPyBeginAllowThreads();
26392 (arg1)->Move(arg2,arg3,arg4);
26393
26394 wxPyEndAllowThreads(__tstate);
26395 if (PyErr_Occurred()) SWIG_fail;
26396 }
26397 Py_INCREF(Py_None); resultobj = Py_None;
26398 return resultobj;
26399 fail:
26400 return NULL;
26401 }
26402
26403
26404 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26405 PyObject *resultobj;
26406 wxWindow *arg1 = (wxWindow *) 0 ;
26407 wxSize const &arg2_defvalue = wxDefaultSize ;
26408 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
26409 wxSize temp2 ;
26410 PyObject * obj0 = 0 ;
26411 PyObject * obj1 = 0 ;
26412 char *kwnames[] = {
26413 (char *) "self",(char *) "size", NULL
26414 };
26415
26416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
26417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26418 if (SWIG_arg_fail(1)) SWIG_fail;
26419 if (obj1) {
26420 {
26421 arg2 = &temp2;
26422 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26423 }
26424 }
26425 {
26426 PyThreadState* __tstate = wxPyBeginAllowThreads();
26427 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
26428
26429 wxPyEndAllowThreads(__tstate);
26430 if (PyErr_Occurred()) SWIG_fail;
26431 }
26432 Py_INCREF(Py_None); resultobj = Py_None;
26433 return resultobj;
26434 fail:
26435 return NULL;
26436 }
26437
26438
26439 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
26440 PyObject *resultobj;
26441 wxWindow *arg1 = (wxWindow *) 0 ;
26442 PyObject * obj0 = 0 ;
26443 char *kwnames[] = {
26444 (char *) "self", NULL
26445 };
26446
26447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
26448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26449 if (SWIG_arg_fail(1)) SWIG_fail;
26450 {
26451 PyThreadState* __tstate = wxPyBeginAllowThreads();
26452 (arg1)->Raise();
26453
26454 wxPyEndAllowThreads(__tstate);
26455 if (PyErr_Occurred()) SWIG_fail;
26456 }
26457 Py_INCREF(Py_None); resultobj = Py_None;
26458 return resultobj;
26459 fail:
26460 return NULL;
26461 }
26462
26463
26464 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26465 PyObject *resultobj;
26466 wxWindow *arg1 = (wxWindow *) 0 ;
26467 PyObject * obj0 = 0 ;
26468 char *kwnames[] = {
26469 (char *) "self", NULL
26470 };
26471
26472 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26474 if (SWIG_arg_fail(1)) SWIG_fail;
26475 {
26476 PyThreadState* __tstate = wxPyBeginAllowThreads();
26477 (arg1)->Lower();
26478
26479 wxPyEndAllowThreads(__tstate);
26480 if (PyErr_Occurred()) SWIG_fail;
26481 }
26482 Py_INCREF(Py_None); resultobj = Py_None;
26483 return resultobj;
26484 fail:
26485 return NULL;
26486 }
26487
26488
26489 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26490 PyObject *resultobj;
26491 wxWindow *arg1 = (wxWindow *) 0 ;
26492 wxSize *arg2 = 0 ;
26493 wxSize temp2 ;
26494 PyObject * obj0 = 0 ;
26495 PyObject * obj1 = 0 ;
26496 char *kwnames[] = {
26497 (char *) "self",(char *) "size", NULL
26498 };
26499
26500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) goto fail;
26501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26502 if (SWIG_arg_fail(1)) SWIG_fail;
26503 {
26504 arg2 = &temp2;
26505 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26506 }
26507 {
26508 PyThreadState* __tstate = wxPyBeginAllowThreads();
26509 (arg1)->SetClientSize((wxSize const &)*arg2);
26510
26511 wxPyEndAllowThreads(__tstate);
26512 if (PyErr_Occurred()) SWIG_fail;
26513 }
26514 Py_INCREF(Py_None); resultobj = Py_None;
26515 return resultobj;
26516 fail:
26517 return NULL;
26518 }
26519
26520
26521 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26522 PyObject *resultobj;
26523 wxWindow *arg1 = (wxWindow *) 0 ;
26524 int arg2 ;
26525 int arg3 ;
26526 PyObject * obj0 = 0 ;
26527 PyObject * obj1 = 0 ;
26528 PyObject * obj2 = 0 ;
26529 char *kwnames[] = {
26530 (char *) "self",(char *) "width",(char *) "height", NULL
26531 };
26532
26533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26535 if (SWIG_arg_fail(1)) SWIG_fail;
26536 {
26537 arg2 = (int)(SWIG_As_int(obj1));
26538 if (SWIG_arg_fail(2)) SWIG_fail;
26539 }
26540 {
26541 arg3 = (int)(SWIG_As_int(obj2));
26542 if (SWIG_arg_fail(3)) SWIG_fail;
26543 }
26544 {
26545 PyThreadState* __tstate = wxPyBeginAllowThreads();
26546 (arg1)->SetClientSize(arg2,arg3);
26547
26548 wxPyEndAllowThreads(__tstate);
26549 if (PyErr_Occurred()) SWIG_fail;
26550 }
26551 Py_INCREF(Py_None); resultobj = Py_None;
26552 return resultobj;
26553 fail:
26554 return NULL;
26555 }
26556
26557
26558 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26559 PyObject *resultobj;
26560 wxWindow *arg1 = (wxWindow *) 0 ;
26561 wxRect *arg2 = 0 ;
26562 wxRect temp2 ;
26563 PyObject * obj0 = 0 ;
26564 PyObject * obj1 = 0 ;
26565 char *kwnames[] = {
26566 (char *) "self",(char *) "rect", NULL
26567 };
26568
26569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26571 if (SWIG_arg_fail(1)) SWIG_fail;
26572 {
26573 arg2 = &temp2;
26574 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26575 }
26576 {
26577 PyThreadState* __tstate = wxPyBeginAllowThreads();
26578 (arg1)->SetClientSize((wxRect const &)*arg2);
26579
26580 wxPyEndAllowThreads(__tstate);
26581 if (PyErr_Occurred()) SWIG_fail;
26582 }
26583 Py_INCREF(Py_None); resultobj = Py_None;
26584 return resultobj;
26585 fail:
26586 return NULL;
26587 }
26588
26589
26590 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26591 PyObject *resultobj;
26592 wxWindow *arg1 = (wxWindow *) 0 ;
26593 wxPoint result;
26594 PyObject * obj0 = 0 ;
26595 char *kwnames[] = {
26596 (char *) "self", NULL
26597 };
26598
26599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26601 if (SWIG_arg_fail(1)) SWIG_fail;
26602 {
26603 PyThreadState* __tstate = wxPyBeginAllowThreads();
26604 result = (arg1)->GetPosition();
26605
26606 wxPyEndAllowThreads(__tstate);
26607 if (PyErr_Occurred()) SWIG_fail;
26608 }
26609 {
26610 wxPoint * resultptr;
26611 resultptr = new wxPoint((wxPoint &)(result));
26612 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26613 }
26614 return resultobj;
26615 fail:
26616 return NULL;
26617 }
26618
26619
26620 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26621 PyObject *resultobj;
26622 wxWindow *arg1 = (wxWindow *) 0 ;
26623 int *arg2 = (int *) 0 ;
26624 int *arg3 = (int *) 0 ;
26625 int temp2 ;
26626 int res2 = 0 ;
26627 int temp3 ;
26628 int res3 = 0 ;
26629 PyObject * obj0 = 0 ;
26630 char *kwnames[] = {
26631 (char *) "self", NULL
26632 };
26633
26634 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26635 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26638 if (SWIG_arg_fail(1)) SWIG_fail;
26639 {
26640 PyThreadState* __tstate = wxPyBeginAllowThreads();
26641 (arg1)->GetPosition(arg2,arg3);
26642
26643 wxPyEndAllowThreads(__tstate);
26644 if (PyErr_Occurred()) SWIG_fail;
26645 }
26646 Py_INCREF(Py_None); resultobj = Py_None;
26647 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26648 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26649 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26650 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26651 return resultobj;
26652 fail:
26653 return NULL;
26654 }
26655
26656
26657 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26658 PyObject *resultobj;
26659 wxWindow *arg1 = (wxWindow *) 0 ;
26660 wxSize result;
26661 PyObject * obj0 = 0 ;
26662 char *kwnames[] = {
26663 (char *) "self", NULL
26664 };
26665
26666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26668 if (SWIG_arg_fail(1)) SWIG_fail;
26669 {
26670 PyThreadState* __tstate = wxPyBeginAllowThreads();
26671 result = ((wxWindow const *)arg1)->GetSize();
26672
26673 wxPyEndAllowThreads(__tstate);
26674 if (PyErr_Occurred()) SWIG_fail;
26675 }
26676 {
26677 wxSize * resultptr;
26678 resultptr = new wxSize((wxSize &)(result));
26679 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26680 }
26681 return resultobj;
26682 fail:
26683 return NULL;
26684 }
26685
26686
26687 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26688 PyObject *resultobj;
26689 wxWindow *arg1 = (wxWindow *) 0 ;
26690 int *arg2 = (int *) 0 ;
26691 int *arg3 = (int *) 0 ;
26692 int temp2 ;
26693 int res2 = 0 ;
26694 int temp3 ;
26695 int res3 = 0 ;
26696 PyObject * obj0 = 0 ;
26697 char *kwnames[] = {
26698 (char *) "self", NULL
26699 };
26700
26701 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26702 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26705 if (SWIG_arg_fail(1)) SWIG_fail;
26706 {
26707 PyThreadState* __tstate = wxPyBeginAllowThreads();
26708 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26709
26710 wxPyEndAllowThreads(__tstate);
26711 if (PyErr_Occurred()) SWIG_fail;
26712 }
26713 Py_INCREF(Py_None); resultobj = Py_None;
26714 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26715 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26716 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26717 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26718 return resultobj;
26719 fail:
26720 return NULL;
26721 }
26722
26723
26724 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26725 PyObject *resultobj;
26726 wxWindow *arg1 = (wxWindow *) 0 ;
26727 wxRect result;
26728 PyObject * obj0 = 0 ;
26729 char *kwnames[] = {
26730 (char *) "self", NULL
26731 };
26732
26733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26735 if (SWIG_arg_fail(1)) SWIG_fail;
26736 {
26737 PyThreadState* __tstate = wxPyBeginAllowThreads();
26738 result = ((wxWindow const *)arg1)->GetRect();
26739
26740 wxPyEndAllowThreads(__tstate);
26741 if (PyErr_Occurred()) SWIG_fail;
26742 }
26743 {
26744 wxRect * resultptr;
26745 resultptr = new wxRect((wxRect &)(result));
26746 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26747 }
26748 return resultobj;
26749 fail:
26750 return NULL;
26751 }
26752
26753
26754 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26755 PyObject *resultobj;
26756 wxWindow *arg1 = (wxWindow *) 0 ;
26757 wxSize result;
26758 PyObject * obj0 = 0 ;
26759 char *kwnames[] = {
26760 (char *) "self", NULL
26761 };
26762
26763 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26764 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26765 if (SWIG_arg_fail(1)) SWIG_fail;
26766 {
26767 PyThreadState* __tstate = wxPyBeginAllowThreads();
26768 result = ((wxWindow const *)arg1)->GetClientSize();
26769
26770 wxPyEndAllowThreads(__tstate);
26771 if (PyErr_Occurred()) SWIG_fail;
26772 }
26773 {
26774 wxSize * resultptr;
26775 resultptr = new wxSize((wxSize &)(result));
26776 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26777 }
26778 return resultobj;
26779 fail:
26780 return NULL;
26781 }
26782
26783
26784 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26785 PyObject *resultobj;
26786 wxWindow *arg1 = (wxWindow *) 0 ;
26787 int *arg2 = (int *) 0 ;
26788 int *arg3 = (int *) 0 ;
26789 int temp2 ;
26790 int res2 = 0 ;
26791 int temp3 ;
26792 int res3 = 0 ;
26793 PyObject * obj0 = 0 ;
26794 char *kwnames[] = {
26795 (char *) "self", NULL
26796 };
26797
26798 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26799 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26802 if (SWIG_arg_fail(1)) SWIG_fail;
26803 {
26804 PyThreadState* __tstate = wxPyBeginAllowThreads();
26805 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26806
26807 wxPyEndAllowThreads(__tstate);
26808 if (PyErr_Occurred()) SWIG_fail;
26809 }
26810 Py_INCREF(Py_None); resultobj = Py_None;
26811 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26812 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26813 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26814 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26815 return resultobj;
26816 fail:
26817 return NULL;
26818 }
26819
26820
26821 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26822 PyObject *resultobj;
26823 wxWindow *arg1 = (wxWindow *) 0 ;
26824 wxPoint result;
26825 PyObject * obj0 = 0 ;
26826 char *kwnames[] = {
26827 (char *) "self", NULL
26828 };
26829
26830 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26831 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26832 if (SWIG_arg_fail(1)) SWIG_fail;
26833 {
26834 PyThreadState* __tstate = wxPyBeginAllowThreads();
26835 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26836
26837 wxPyEndAllowThreads(__tstate);
26838 if (PyErr_Occurred()) SWIG_fail;
26839 }
26840 {
26841 wxPoint * resultptr;
26842 resultptr = new wxPoint((wxPoint &)(result));
26843 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26844 }
26845 return resultobj;
26846 fail:
26847 return NULL;
26848 }
26849
26850
26851 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26852 PyObject *resultobj;
26853 wxWindow *arg1 = (wxWindow *) 0 ;
26854 wxRect result;
26855 PyObject * obj0 = 0 ;
26856 char *kwnames[] = {
26857 (char *) "self", NULL
26858 };
26859
26860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26862 if (SWIG_arg_fail(1)) SWIG_fail;
26863 {
26864 PyThreadState* __tstate = wxPyBeginAllowThreads();
26865 result = ((wxWindow const *)arg1)->GetClientRect();
26866
26867 wxPyEndAllowThreads(__tstate);
26868 if (PyErr_Occurred()) SWIG_fail;
26869 }
26870 {
26871 wxRect * resultptr;
26872 resultptr = new wxRect((wxRect &)(result));
26873 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26874 }
26875 return resultobj;
26876 fail:
26877 return NULL;
26878 }
26879
26880
26881 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26882 PyObject *resultobj;
26883 wxWindow *arg1 = (wxWindow *) 0 ;
26884 wxSize result;
26885 PyObject * obj0 = 0 ;
26886 char *kwnames[] = {
26887 (char *) "self", NULL
26888 };
26889
26890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26892 if (SWIG_arg_fail(1)) SWIG_fail;
26893 {
26894 PyThreadState* __tstate = wxPyBeginAllowThreads();
26895 result = ((wxWindow const *)arg1)->GetBestSize();
26896
26897 wxPyEndAllowThreads(__tstate);
26898 if (PyErr_Occurred()) SWIG_fail;
26899 }
26900 {
26901 wxSize * resultptr;
26902 resultptr = new wxSize((wxSize &)(result));
26903 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26904 }
26905 return resultobj;
26906 fail:
26907 return NULL;
26908 }
26909
26910
26911 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26912 PyObject *resultobj;
26913 wxWindow *arg1 = (wxWindow *) 0 ;
26914 int *arg2 = (int *) 0 ;
26915 int *arg3 = (int *) 0 ;
26916 int temp2 ;
26917 int res2 = 0 ;
26918 int temp3 ;
26919 int res3 = 0 ;
26920 PyObject * obj0 = 0 ;
26921 char *kwnames[] = {
26922 (char *) "self", NULL
26923 };
26924
26925 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26926 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26929 if (SWIG_arg_fail(1)) SWIG_fail;
26930 {
26931 PyThreadState* __tstate = wxPyBeginAllowThreads();
26932 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26933
26934 wxPyEndAllowThreads(__tstate);
26935 if (PyErr_Occurred()) SWIG_fail;
26936 }
26937 Py_INCREF(Py_None); resultobj = Py_None;
26938 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26939 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26940 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26941 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26942 return resultobj;
26943 fail:
26944 return NULL;
26945 }
26946
26947
26948 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26949 PyObject *resultobj;
26950 wxWindow *arg1 = (wxWindow *) 0 ;
26951 PyObject * obj0 = 0 ;
26952 char *kwnames[] = {
26953 (char *) "self", NULL
26954 };
26955
26956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26958 if (SWIG_arg_fail(1)) SWIG_fail;
26959 {
26960 PyThreadState* __tstate = wxPyBeginAllowThreads();
26961 (arg1)->InvalidateBestSize();
26962
26963 wxPyEndAllowThreads(__tstate);
26964 if (PyErr_Occurred()) SWIG_fail;
26965 }
26966 Py_INCREF(Py_None); resultobj = Py_None;
26967 return resultobj;
26968 fail:
26969 return NULL;
26970 }
26971
26972
26973 static PyObject *_wrap_Window_CacheBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26974 PyObject *resultobj;
26975 wxWindow *arg1 = (wxWindow *) 0 ;
26976 wxSize *arg2 = 0 ;
26977 wxSize temp2 ;
26978 PyObject * obj0 = 0 ;
26979 PyObject * obj1 = 0 ;
26980 char *kwnames[] = {
26981 (char *) "self",(char *) "size", NULL
26982 };
26983
26984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) goto fail;
26985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26986 if (SWIG_arg_fail(1)) SWIG_fail;
26987 {
26988 arg2 = &temp2;
26989 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26990 }
26991 {
26992 PyThreadState* __tstate = wxPyBeginAllowThreads();
26993 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
26994
26995 wxPyEndAllowThreads(__tstate);
26996 if (PyErr_Occurred()) SWIG_fail;
26997 }
26998 Py_INCREF(Py_None); resultobj = Py_None;
26999 return resultobj;
27000 fail:
27001 return NULL;
27002 }
27003
27004
27005 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
27006 PyObject *resultobj;
27007 wxWindow *arg1 = (wxWindow *) 0 ;
27008 wxSize result;
27009 PyObject * obj0 = 0 ;
27010 char *kwnames[] = {
27011 (char *) "self", NULL
27012 };
27013
27014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
27015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27016 if (SWIG_arg_fail(1)) SWIG_fail;
27017 {
27018 PyThreadState* __tstate = wxPyBeginAllowThreads();
27019 result = ((wxWindow const *)arg1)->GetBestFittingSize();
27020
27021 wxPyEndAllowThreads(__tstate);
27022 if (PyErr_Occurred()) SWIG_fail;
27023 }
27024 {
27025 wxSize * resultptr;
27026 resultptr = new wxSize((wxSize &)(result));
27027 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27028 }
27029 return resultobj;
27030 fail:
27031 return NULL;
27032 }
27033
27034
27035 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
27036 PyObject *resultobj;
27037 wxWindow *arg1 = (wxWindow *) 0 ;
27038 wxSize result;
27039 PyObject * obj0 = 0 ;
27040 char *kwnames[] = {
27041 (char *) "self", NULL
27042 };
27043
27044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
27045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27046 if (SWIG_arg_fail(1)) SWIG_fail;
27047 {
27048 PyThreadState* __tstate = wxPyBeginAllowThreads();
27049 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
27050
27051 wxPyEndAllowThreads(__tstate);
27052 if (PyErr_Occurred()) SWIG_fail;
27053 }
27054 {
27055 wxSize * resultptr;
27056 resultptr = new wxSize((wxSize &)(result));
27057 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27058 }
27059 return resultobj;
27060 fail:
27061 return NULL;
27062 }
27063
27064
27065 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
27066 PyObject *resultobj;
27067 wxWindow *arg1 = (wxWindow *) 0 ;
27068 int arg2 = (int) wxBOTH ;
27069 PyObject * obj0 = 0 ;
27070 PyObject * obj1 = 0 ;
27071 char *kwnames[] = {
27072 (char *) "self",(char *) "direction", NULL
27073 };
27074
27075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
27076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27077 if (SWIG_arg_fail(1)) SWIG_fail;
27078 if (obj1) {
27079 {
27080 arg2 = (int)(SWIG_As_int(obj1));
27081 if (SWIG_arg_fail(2)) SWIG_fail;
27082 }
27083 }
27084 {
27085 PyThreadState* __tstate = wxPyBeginAllowThreads();
27086 (arg1)->Center(arg2);
27087
27088 wxPyEndAllowThreads(__tstate);
27089 if (PyErr_Occurred()) SWIG_fail;
27090 }
27091 Py_INCREF(Py_None); resultobj = Py_None;
27092 return resultobj;
27093 fail:
27094 return NULL;
27095 }
27096
27097
27098 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
27099 PyObject *resultobj;
27100 wxWindow *arg1 = (wxWindow *) 0 ;
27101 int arg2 = (int) wxBOTH ;
27102 PyObject * obj0 = 0 ;
27103 PyObject * obj1 = 0 ;
27104 char *kwnames[] = {
27105 (char *) "self",(char *) "dir", NULL
27106 };
27107
27108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
27109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27110 if (SWIG_arg_fail(1)) SWIG_fail;
27111 if (obj1) {
27112 {
27113 arg2 = (int)(SWIG_As_int(obj1));
27114 if (SWIG_arg_fail(2)) SWIG_fail;
27115 }
27116 }
27117 {
27118 PyThreadState* __tstate = wxPyBeginAllowThreads();
27119 (arg1)->CenterOnScreen(arg2);
27120
27121 wxPyEndAllowThreads(__tstate);
27122 if (PyErr_Occurred()) SWIG_fail;
27123 }
27124 Py_INCREF(Py_None); resultobj = Py_None;
27125 return resultobj;
27126 fail:
27127 return NULL;
27128 }
27129
27130
27131 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
27132 PyObject *resultobj;
27133 wxWindow *arg1 = (wxWindow *) 0 ;
27134 int arg2 = (int) wxBOTH ;
27135 PyObject * obj0 = 0 ;
27136 PyObject * obj1 = 0 ;
27137 char *kwnames[] = {
27138 (char *) "self",(char *) "dir", NULL
27139 };
27140
27141 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
27142 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27143 if (SWIG_arg_fail(1)) SWIG_fail;
27144 if (obj1) {
27145 {
27146 arg2 = (int)(SWIG_As_int(obj1));
27147 if (SWIG_arg_fail(2)) SWIG_fail;
27148 }
27149 }
27150 {
27151 PyThreadState* __tstate = wxPyBeginAllowThreads();
27152 (arg1)->CenterOnParent(arg2);
27153
27154 wxPyEndAllowThreads(__tstate);
27155 if (PyErr_Occurred()) SWIG_fail;
27156 }
27157 Py_INCREF(Py_None); resultobj = Py_None;
27158 return resultobj;
27159 fail:
27160 return NULL;
27161 }
27162
27163
27164 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
27165 PyObject *resultobj;
27166 wxWindow *arg1 = (wxWindow *) 0 ;
27167 PyObject * obj0 = 0 ;
27168 char *kwnames[] = {
27169 (char *) "self", NULL
27170 };
27171
27172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
27173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27174 if (SWIG_arg_fail(1)) SWIG_fail;
27175 {
27176 PyThreadState* __tstate = wxPyBeginAllowThreads();
27177 (arg1)->Fit();
27178
27179 wxPyEndAllowThreads(__tstate);
27180 if (PyErr_Occurred()) SWIG_fail;
27181 }
27182 Py_INCREF(Py_None); resultobj = Py_None;
27183 return resultobj;
27184 fail:
27185 return NULL;
27186 }
27187
27188
27189 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
27190 PyObject *resultobj;
27191 wxWindow *arg1 = (wxWindow *) 0 ;
27192 PyObject * obj0 = 0 ;
27193 char *kwnames[] = {
27194 (char *) "self", NULL
27195 };
27196
27197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
27198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27199 if (SWIG_arg_fail(1)) SWIG_fail;
27200 {
27201 PyThreadState* __tstate = wxPyBeginAllowThreads();
27202 (arg1)->FitInside();
27203
27204 wxPyEndAllowThreads(__tstate);
27205 if (PyErr_Occurred()) SWIG_fail;
27206 }
27207 Py_INCREF(Py_None); resultobj = Py_None;
27208 return resultobj;
27209 fail:
27210 return NULL;
27211 }
27212
27213
27214 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27215 PyObject *resultobj;
27216 wxWindow *arg1 = (wxWindow *) 0 ;
27217 int arg2 ;
27218 int arg3 ;
27219 int arg4 = (int) -1 ;
27220 int arg5 = (int) -1 ;
27221 int arg6 = (int) -1 ;
27222 int arg7 = (int) -1 ;
27223 PyObject * obj0 = 0 ;
27224 PyObject * obj1 = 0 ;
27225 PyObject * obj2 = 0 ;
27226 PyObject * obj3 = 0 ;
27227 PyObject * obj4 = 0 ;
27228 PyObject * obj5 = 0 ;
27229 PyObject * obj6 = 0 ;
27230 char *kwnames[] = {
27231 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
27232 };
27233
27234 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
27235 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27236 if (SWIG_arg_fail(1)) SWIG_fail;
27237 {
27238 arg2 = (int)(SWIG_As_int(obj1));
27239 if (SWIG_arg_fail(2)) SWIG_fail;
27240 }
27241 {
27242 arg3 = (int)(SWIG_As_int(obj2));
27243 if (SWIG_arg_fail(3)) SWIG_fail;
27244 }
27245 if (obj3) {
27246 {
27247 arg4 = (int)(SWIG_As_int(obj3));
27248 if (SWIG_arg_fail(4)) SWIG_fail;
27249 }
27250 }
27251 if (obj4) {
27252 {
27253 arg5 = (int)(SWIG_As_int(obj4));
27254 if (SWIG_arg_fail(5)) SWIG_fail;
27255 }
27256 }
27257 if (obj5) {
27258 {
27259 arg6 = (int)(SWIG_As_int(obj5));
27260 if (SWIG_arg_fail(6)) SWIG_fail;
27261 }
27262 }
27263 if (obj6) {
27264 {
27265 arg7 = (int)(SWIG_As_int(obj6));
27266 if (SWIG_arg_fail(7)) SWIG_fail;
27267 }
27268 }
27269 {
27270 PyThreadState* __tstate = wxPyBeginAllowThreads();
27271 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
27272
27273 wxPyEndAllowThreads(__tstate);
27274 if (PyErr_Occurred()) SWIG_fail;
27275 }
27276 Py_INCREF(Py_None); resultobj = Py_None;
27277 return resultobj;
27278 fail:
27279 return NULL;
27280 }
27281
27282
27283 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27284 PyObject *resultobj;
27285 wxWindow *arg1 = (wxWindow *) 0 ;
27286 wxSize *arg2 = 0 ;
27287 wxSize const &arg3_defvalue = wxDefaultSize ;
27288 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27289 wxSize const &arg4_defvalue = wxDefaultSize ;
27290 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
27291 wxSize temp2 ;
27292 wxSize temp3 ;
27293 wxSize temp4 ;
27294 PyObject * obj0 = 0 ;
27295 PyObject * obj1 = 0 ;
27296 PyObject * obj2 = 0 ;
27297 PyObject * obj3 = 0 ;
27298 char *kwnames[] = {
27299 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
27300 };
27301
27302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
27303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27304 if (SWIG_arg_fail(1)) SWIG_fail;
27305 {
27306 arg2 = &temp2;
27307 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27308 }
27309 if (obj2) {
27310 {
27311 arg3 = &temp3;
27312 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27313 }
27314 }
27315 if (obj3) {
27316 {
27317 arg4 = &temp4;
27318 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
27319 }
27320 }
27321 {
27322 PyThreadState* __tstate = wxPyBeginAllowThreads();
27323 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
27324
27325 wxPyEndAllowThreads(__tstate);
27326 if (PyErr_Occurred()) SWIG_fail;
27327 }
27328 Py_INCREF(Py_None); resultobj = Py_None;
27329 return resultobj;
27330 fail:
27331 return NULL;
27332 }
27333
27334
27335 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
27336 PyObject *resultobj;
27337 wxWindow *arg1 = (wxWindow *) 0 ;
27338 int arg2 ;
27339 int arg3 ;
27340 int arg4 = (int) -1 ;
27341 int arg5 = (int) -1 ;
27342 PyObject * obj0 = 0 ;
27343 PyObject * obj1 = 0 ;
27344 PyObject * obj2 = 0 ;
27345 PyObject * obj3 = 0 ;
27346 PyObject * obj4 = 0 ;
27347 char *kwnames[] = {
27348 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
27349 };
27350
27351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
27352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27353 if (SWIG_arg_fail(1)) SWIG_fail;
27354 {
27355 arg2 = (int)(SWIG_As_int(obj1));
27356 if (SWIG_arg_fail(2)) SWIG_fail;
27357 }
27358 {
27359 arg3 = (int)(SWIG_As_int(obj2));
27360 if (SWIG_arg_fail(3)) SWIG_fail;
27361 }
27362 if (obj3) {
27363 {
27364 arg4 = (int)(SWIG_As_int(obj3));
27365 if (SWIG_arg_fail(4)) SWIG_fail;
27366 }
27367 }
27368 if (obj4) {
27369 {
27370 arg5 = (int)(SWIG_As_int(obj4));
27371 if (SWIG_arg_fail(5)) SWIG_fail;
27372 }
27373 }
27374 {
27375 PyThreadState* __tstate = wxPyBeginAllowThreads();
27376 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
27377
27378 wxPyEndAllowThreads(__tstate);
27379 if (PyErr_Occurred()) SWIG_fail;
27380 }
27381 Py_INCREF(Py_None); resultobj = Py_None;
27382 return resultobj;
27383 fail:
27384 return NULL;
27385 }
27386
27387
27388 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
27389 PyObject *resultobj;
27390 wxWindow *arg1 = (wxWindow *) 0 ;
27391 wxSize *arg2 = 0 ;
27392 wxSize const &arg3_defvalue = wxDefaultSize ;
27393 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
27394 wxSize temp2 ;
27395 wxSize temp3 ;
27396 PyObject * obj0 = 0 ;
27397 PyObject * obj1 = 0 ;
27398 PyObject * obj2 = 0 ;
27399 char *kwnames[] = {
27400 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
27401 };
27402
27403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
27404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27405 if (SWIG_arg_fail(1)) SWIG_fail;
27406 {
27407 arg2 = &temp2;
27408 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27409 }
27410 if (obj2) {
27411 {
27412 arg3 = &temp3;
27413 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
27414 }
27415 }
27416 {
27417 PyThreadState* __tstate = wxPyBeginAllowThreads();
27418 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
27419
27420 wxPyEndAllowThreads(__tstate);
27421 if (PyErr_Occurred()) SWIG_fail;
27422 }
27423 Py_INCREF(Py_None); resultobj = Py_None;
27424 return resultobj;
27425 fail:
27426 return NULL;
27427 }
27428
27429
27430 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27431 PyObject *resultobj;
27432 wxWindow *arg1 = (wxWindow *) 0 ;
27433 wxSize result;
27434 PyObject * obj0 = 0 ;
27435 char *kwnames[] = {
27436 (char *) "self", NULL
27437 };
27438
27439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
27440 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27441 if (SWIG_arg_fail(1)) SWIG_fail;
27442 {
27443 PyThreadState* __tstate = wxPyBeginAllowThreads();
27444 result = ((wxWindow const *)arg1)->GetMaxSize();
27445
27446 wxPyEndAllowThreads(__tstate);
27447 if (PyErr_Occurred()) SWIG_fail;
27448 }
27449 {
27450 wxSize * resultptr;
27451 resultptr = new wxSize((wxSize &)(result));
27452 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27453 }
27454 return resultobj;
27455 fail:
27456 return NULL;
27457 }
27458
27459
27460 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27461 PyObject *resultobj;
27462 wxWindow *arg1 = (wxWindow *) 0 ;
27463 wxSize result;
27464 PyObject * obj0 = 0 ;
27465 char *kwnames[] = {
27466 (char *) "self", NULL
27467 };
27468
27469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
27470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27471 if (SWIG_arg_fail(1)) SWIG_fail;
27472 {
27473 PyThreadState* __tstate = wxPyBeginAllowThreads();
27474 result = ((wxWindow const *)arg1)->GetMinSize();
27475
27476 wxPyEndAllowThreads(__tstate);
27477 if (PyErr_Occurred()) SWIG_fail;
27478 }
27479 {
27480 wxSize * resultptr;
27481 resultptr = new wxSize((wxSize &)(result));
27482 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27483 }
27484 return resultobj;
27485 fail:
27486 return NULL;
27487 }
27488
27489
27490 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27491 PyObject *resultobj;
27492 wxWindow *arg1 = (wxWindow *) 0 ;
27493 wxSize *arg2 = 0 ;
27494 wxSize temp2 ;
27495 PyObject * obj0 = 0 ;
27496 PyObject * obj1 = 0 ;
27497 char *kwnames[] = {
27498 (char *) "self",(char *) "minSize", NULL
27499 };
27500
27501 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27502 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27503 if (SWIG_arg_fail(1)) SWIG_fail;
27504 {
27505 arg2 = &temp2;
27506 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27507 }
27508 {
27509 PyThreadState* __tstate = wxPyBeginAllowThreads();
27510 (arg1)->SetMinSize((wxSize const &)*arg2);
27511
27512 wxPyEndAllowThreads(__tstate);
27513 if (PyErr_Occurred()) SWIG_fail;
27514 }
27515 Py_INCREF(Py_None); resultobj = Py_None;
27516 return resultobj;
27517 fail:
27518 return NULL;
27519 }
27520
27521
27522 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27523 PyObject *resultobj;
27524 wxWindow *arg1 = (wxWindow *) 0 ;
27525 wxSize *arg2 = 0 ;
27526 wxSize temp2 ;
27527 PyObject * obj0 = 0 ;
27528 PyObject * obj1 = 0 ;
27529 char *kwnames[] = {
27530 (char *) "self",(char *) "maxSize", NULL
27531 };
27532
27533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27535 if (SWIG_arg_fail(1)) SWIG_fail;
27536 {
27537 arg2 = &temp2;
27538 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27539 }
27540 {
27541 PyThreadState* __tstate = wxPyBeginAllowThreads();
27542 (arg1)->SetMaxSize((wxSize const &)*arg2);
27543
27544 wxPyEndAllowThreads(__tstate);
27545 if (PyErr_Occurred()) SWIG_fail;
27546 }
27547 Py_INCREF(Py_None); resultobj = Py_None;
27548 return resultobj;
27549 fail:
27550 return NULL;
27551 }
27552
27553
27554 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27555 PyObject *resultobj;
27556 wxWindow *arg1 = (wxWindow *) 0 ;
27557 int result;
27558 PyObject * obj0 = 0 ;
27559 char *kwnames[] = {
27560 (char *) "self", NULL
27561 };
27562
27563 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27564 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27565 if (SWIG_arg_fail(1)) SWIG_fail;
27566 {
27567 PyThreadState* __tstate = wxPyBeginAllowThreads();
27568 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27569
27570 wxPyEndAllowThreads(__tstate);
27571 if (PyErr_Occurred()) SWIG_fail;
27572 }
27573 {
27574 resultobj = SWIG_From_int((int)(result));
27575 }
27576 return resultobj;
27577 fail:
27578 return NULL;
27579 }
27580
27581
27582 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27583 PyObject *resultobj;
27584 wxWindow *arg1 = (wxWindow *) 0 ;
27585 int result;
27586 PyObject * obj0 = 0 ;
27587 char *kwnames[] = {
27588 (char *) "self", NULL
27589 };
27590
27591 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27592 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27593 if (SWIG_arg_fail(1)) SWIG_fail;
27594 {
27595 PyThreadState* __tstate = wxPyBeginAllowThreads();
27596 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27597
27598 wxPyEndAllowThreads(__tstate);
27599 if (PyErr_Occurred()) SWIG_fail;
27600 }
27601 {
27602 resultobj = SWIG_From_int((int)(result));
27603 }
27604 return resultobj;
27605 fail:
27606 return NULL;
27607 }
27608
27609
27610 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27611 PyObject *resultobj;
27612 wxWindow *arg1 = (wxWindow *) 0 ;
27613 int result;
27614 PyObject * obj0 = 0 ;
27615 char *kwnames[] = {
27616 (char *) "self", NULL
27617 };
27618
27619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27621 if (SWIG_arg_fail(1)) SWIG_fail;
27622 {
27623 PyThreadState* __tstate = wxPyBeginAllowThreads();
27624 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27625
27626 wxPyEndAllowThreads(__tstate);
27627 if (PyErr_Occurred()) SWIG_fail;
27628 }
27629 {
27630 resultobj = SWIG_From_int((int)(result));
27631 }
27632 return resultobj;
27633 fail:
27634 return NULL;
27635 }
27636
27637
27638 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27639 PyObject *resultobj;
27640 wxWindow *arg1 = (wxWindow *) 0 ;
27641 int result;
27642 PyObject * obj0 = 0 ;
27643 char *kwnames[] = {
27644 (char *) "self", NULL
27645 };
27646
27647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) 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 {
27651 PyThreadState* __tstate = wxPyBeginAllowThreads();
27652 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27653
27654 wxPyEndAllowThreads(__tstate);
27655 if (PyErr_Occurred()) SWIG_fail;
27656 }
27657 {
27658 resultobj = SWIG_From_int((int)(result));
27659 }
27660 return resultobj;
27661 fail:
27662 return NULL;
27663 }
27664
27665
27666 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27667 PyObject *resultobj;
27668 wxWindow *arg1 = (wxWindow *) 0 ;
27669 wxSize *arg2 = 0 ;
27670 wxSize temp2 ;
27671 PyObject * obj0 = 0 ;
27672 PyObject * obj1 = 0 ;
27673 char *kwnames[] = {
27674 (char *) "self",(char *) "size", NULL
27675 };
27676
27677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27679 if (SWIG_arg_fail(1)) SWIG_fail;
27680 {
27681 arg2 = &temp2;
27682 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27683 }
27684 {
27685 PyThreadState* __tstate = wxPyBeginAllowThreads();
27686 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27687
27688 wxPyEndAllowThreads(__tstate);
27689 if (PyErr_Occurred()) SWIG_fail;
27690 }
27691 Py_INCREF(Py_None); resultobj = Py_None;
27692 return resultobj;
27693 fail:
27694 return NULL;
27695 }
27696
27697
27698 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27699 PyObject *resultobj;
27700 wxWindow *arg1 = (wxWindow *) 0 ;
27701 int arg2 ;
27702 int arg3 ;
27703 PyObject * obj0 = 0 ;
27704 PyObject * obj1 = 0 ;
27705 PyObject * obj2 = 0 ;
27706 char *kwnames[] = {
27707 (char *) "self",(char *) "w",(char *) "h", NULL
27708 };
27709
27710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27712 if (SWIG_arg_fail(1)) SWIG_fail;
27713 {
27714 arg2 = (int)(SWIG_As_int(obj1));
27715 if (SWIG_arg_fail(2)) SWIG_fail;
27716 }
27717 {
27718 arg3 = (int)(SWIG_As_int(obj2));
27719 if (SWIG_arg_fail(3)) SWIG_fail;
27720 }
27721 {
27722 PyThreadState* __tstate = wxPyBeginAllowThreads();
27723 (arg1)->SetVirtualSize(arg2,arg3);
27724
27725 wxPyEndAllowThreads(__tstate);
27726 if (PyErr_Occurred()) SWIG_fail;
27727 }
27728 Py_INCREF(Py_None); resultobj = Py_None;
27729 return resultobj;
27730 fail:
27731 return NULL;
27732 }
27733
27734
27735 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27736 PyObject *resultobj;
27737 wxWindow *arg1 = (wxWindow *) 0 ;
27738 wxSize result;
27739 PyObject * obj0 = 0 ;
27740 char *kwnames[] = {
27741 (char *) "self", NULL
27742 };
27743
27744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27746 if (SWIG_arg_fail(1)) SWIG_fail;
27747 {
27748 PyThreadState* __tstate = wxPyBeginAllowThreads();
27749 result = ((wxWindow const *)arg1)->GetVirtualSize();
27750
27751 wxPyEndAllowThreads(__tstate);
27752 if (PyErr_Occurred()) SWIG_fail;
27753 }
27754 {
27755 wxSize * resultptr;
27756 resultptr = new wxSize((wxSize &)(result));
27757 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27758 }
27759 return resultobj;
27760 fail:
27761 return NULL;
27762 }
27763
27764
27765 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27766 PyObject *resultobj;
27767 wxWindow *arg1 = (wxWindow *) 0 ;
27768 int *arg2 = (int *) 0 ;
27769 int *arg3 = (int *) 0 ;
27770 int temp2 ;
27771 int res2 = 0 ;
27772 int temp3 ;
27773 int res3 = 0 ;
27774 PyObject * obj0 = 0 ;
27775 char *kwnames[] = {
27776 (char *) "self", NULL
27777 };
27778
27779 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27780 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27783 if (SWIG_arg_fail(1)) SWIG_fail;
27784 {
27785 PyThreadState* __tstate = wxPyBeginAllowThreads();
27786 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27787
27788 wxPyEndAllowThreads(__tstate);
27789 if (PyErr_Occurred()) SWIG_fail;
27790 }
27791 Py_INCREF(Py_None); resultobj = Py_None;
27792 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27793 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27794 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27795 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27796 return resultobj;
27797 fail:
27798 return NULL;
27799 }
27800
27801
27802 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27803 PyObject *resultobj;
27804 wxWindow *arg1 = (wxWindow *) 0 ;
27805 wxSize result;
27806 PyObject * obj0 = 0 ;
27807 char *kwnames[] = {
27808 (char *) "self", NULL
27809 };
27810
27811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27813 if (SWIG_arg_fail(1)) SWIG_fail;
27814 {
27815 PyThreadState* __tstate = wxPyBeginAllowThreads();
27816 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27817
27818 wxPyEndAllowThreads(__tstate);
27819 if (PyErr_Occurred()) SWIG_fail;
27820 }
27821 {
27822 wxSize * resultptr;
27823 resultptr = new wxSize((wxSize &)(result));
27824 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27825 }
27826 return resultobj;
27827 fail:
27828 return NULL;
27829 }
27830
27831
27832 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27833 PyObject *resultobj;
27834 wxWindow *arg1 = (wxWindow *) 0 ;
27835 bool arg2 = (bool) true ;
27836 bool result;
27837 PyObject * obj0 = 0 ;
27838 PyObject * obj1 = 0 ;
27839 char *kwnames[] = {
27840 (char *) "self",(char *) "show", NULL
27841 };
27842
27843 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27844 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27845 if (SWIG_arg_fail(1)) SWIG_fail;
27846 if (obj1) {
27847 {
27848 arg2 = (bool)(SWIG_As_bool(obj1));
27849 if (SWIG_arg_fail(2)) SWIG_fail;
27850 }
27851 }
27852 {
27853 PyThreadState* __tstate = wxPyBeginAllowThreads();
27854 result = (bool)(arg1)->Show(arg2);
27855
27856 wxPyEndAllowThreads(__tstate);
27857 if (PyErr_Occurred()) SWIG_fail;
27858 }
27859 {
27860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27861 }
27862 return resultobj;
27863 fail:
27864 return NULL;
27865 }
27866
27867
27868 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27869 PyObject *resultobj;
27870 wxWindow *arg1 = (wxWindow *) 0 ;
27871 bool result;
27872 PyObject * obj0 = 0 ;
27873 char *kwnames[] = {
27874 (char *) "self", NULL
27875 };
27876
27877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27879 if (SWIG_arg_fail(1)) SWIG_fail;
27880 {
27881 PyThreadState* __tstate = wxPyBeginAllowThreads();
27882 result = (bool)(arg1)->Hide();
27883
27884 wxPyEndAllowThreads(__tstate);
27885 if (PyErr_Occurred()) SWIG_fail;
27886 }
27887 {
27888 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27889 }
27890 return resultobj;
27891 fail:
27892 return NULL;
27893 }
27894
27895
27896 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27897 PyObject *resultobj;
27898 wxWindow *arg1 = (wxWindow *) 0 ;
27899 bool arg2 = (bool) true ;
27900 bool result;
27901 PyObject * obj0 = 0 ;
27902 PyObject * obj1 = 0 ;
27903 char *kwnames[] = {
27904 (char *) "self",(char *) "enable", NULL
27905 };
27906
27907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
27908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27909 if (SWIG_arg_fail(1)) SWIG_fail;
27910 if (obj1) {
27911 {
27912 arg2 = (bool)(SWIG_As_bool(obj1));
27913 if (SWIG_arg_fail(2)) SWIG_fail;
27914 }
27915 }
27916 {
27917 PyThreadState* __tstate = wxPyBeginAllowThreads();
27918 result = (bool)(arg1)->Enable(arg2);
27919
27920 wxPyEndAllowThreads(__tstate);
27921 if (PyErr_Occurred()) SWIG_fail;
27922 }
27923 {
27924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27925 }
27926 return resultobj;
27927 fail:
27928 return NULL;
27929 }
27930
27931
27932 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27933 PyObject *resultobj;
27934 wxWindow *arg1 = (wxWindow *) 0 ;
27935 bool result;
27936 PyObject * obj0 = 0 ;
27937 char *kwnames[] = {
27938 (char *) "self", NULL
27939 };
27940
27941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27943 if (SWIG_arg_fail(1)) SWIG_fail;
27944 {
27945 PyThreadState* __tstate = wxPyBeginAllowThreads();
27946 result = (bool)(arg1)->Disable();
27947
27948 wxPyEndAllowThreads(__tstate);
27949 if (PyErr_Occurred()) SWIG_fail;
27950 }
27951 {
27952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27953 }
27954 return resultobj;
27955 fail:
27956 return NULL;
27957 }
27958
27959
27960 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27961 PyObject *resultobj;
27962 wxWindow *arg1 = (wxWindow *) 0 ;
27963 bool result;
27964 PyObject * obj0 = 0 ;
27965 char *kwnames[] = {
27966 (char *) "self", NULL
27967 };
27968
27969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27971 if (SWIG_arg_fail(1)) SWIG_fail;
27972 {
27973 PyThreadState* __tstate = wxPyBeginAllowThreads();
27974 result = (bool)((wxWindow const *)arg1)->IsShown();
27975
27976 wxPyEndAllowThreads(__tstate);
27977 if (PyErr_Occurred()) SWIG_fail;
27978 }
27979 {
27980 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27981 }
27982 return resultobj;
27983 fail:
27984 return NULL;
27985 }
27986
27987
27988 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27989 PyObject *resultobj;
27990 wxWindow *arg1 = (wxWindow *) 0 ;
27991 bool result;
27992 PyObject * obj0 = 0 ;
27993 char *kwnames[] = {
27994 (char *) "self", NULL
27995 };
27996
27997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27999 if (SWIG_arg_fail(1)) SWIG_fail;
28000 {
28001 PyThreadState* __tstate = wxPyBeginAllowThreads();
28002 result = (bool)((wxWindow const *)arg1)->IsEnabled();
28003
28004 wxPyEndAllowThreads(__tstate);
28005 if (PyErr_Occurred()) SWIG_fail;
28006 }
28007 {
28008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28009 }
28010 return resultobj;
28011 fail:
28012 return NULL;
28013 }
28014
28015
28016 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28017 PyObject *resultobj;
28018 wxWindow *arg1 = (wxWindow *) 0 ;
28019 long arg2 ;
28020 PyObject * obj0 = 0 ;
28021 PyObject * obj1 = 0 ;
28022 char *kwnames[] = {
28023 (char *) "self",(char *) "style", NULL
28024 };
28025
28026 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
28027 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28028 if (SWIG_arg_fail(1)) SWIG_fail;
28029 {
28030 arg2 = (long)(SWIG_As_long(obj1));
28031 if (SWIG_arg_fail(2)) SWIG_fail;
28032 }
28033 {
28034 PyThreadState* __tstate = wxPyBeginAllowThreads();
28035 (arg1)->SetWindowStyleFlag(arg2);
28036
28037 wxPyEndAllowThreads(__tstate);
28038 if (PyErr_Occurred()) SWIG_fail;
28039 }
28040 Py_INCREF(Py_None); resultobj = Py_None;
28041 return resultobj;
28042 fail:
28043 return NULL;
28044 }
28045
28046
28047 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28048 PyObject *resultobj;
28049 wxWindow *arg1 = (wxWindow *) 0 ;
28050 long result;
28051 PyObject * obj0 = 0 ;
28052 char *kwnames[] = {
28053 (char *) "self", NULL
28054 };
28055
28056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
28057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28058 if (SWIG_arg_fail(1)) SWIG_fail;
28059 {
28060 PyThreadState* __tstate = wxPyBeginAllowThreads();
28061 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
28062
28063 wxPyEndAllowThreads(__tstate);
28064 if (PyErr_Occurred()) SWIG_fail;
28065 }
28066 {
28067 resultobj = SWIG_From_long((long)(result));
28068 }
28069 return resultobj;
28070 fail:
28071 return NULL;
28072 }
28073
28074
28075 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
28076 PyObject *resultobj;
28077 wxWindow *arg1 = (wxWindow *) 0 ;
28078 int arg2 ;
28079 bool result;
28080 PyObject * obj0 = 0 ;
28081 PyObject * obj1 = 0 ;
28082 char *kwnames[] = {
28083 (char *) "self",(char *) "flag", NULL
28084 };
28085
28086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) 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 arg2 = (int)(SWIG_As_int(obj1));
28091 if (SWIG_arg_fail(2)) SWIG_fail;
28092 }
28093 {
28094 PyThreadState* __tstate = wxPyBeginAllowThreads();
28095 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
28096
28097 wxPyEndAllowThreads(__tstate);
28098 if (PyErr_Occurred()) SWIG_fail;
28099 }
28100 {
28101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28102 }
28103 return resultobj;
28104 fail:
28105 return NULL;
28106 }
28107
28108
28109 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
28110 PyObject *resultobj;
28111 wxWindow *arg1 = (wxWindow *) 0 ;
28112 bool result;
28113 PyObject * obj0 = 0 ;
28114 char *kwnames[] = {
28115 (char *) "self", NULL
28116 };
28117
28118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
28119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28120 if (SWIG_arg_fail(1)) SWIG_fail;
28121 {
28122 PyThreadState* __tstate = wxPyBeginAllowThreads();
28123 result = (bool)((wxWindow const *)arg1)->IsRetained();
28124
28125 wxPyEndAllowThreads(__tstate);
28126 if (PyErr_Occurred()) SWIG_fail;
28127 }
28128 {
28129 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28130 }
28131 return resultobj;
28132 fail:
28133 return NULL;
28134 }
28135
28136
28137 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28138 PyObject *resultobj;
28139 wxWindow *arg1 = (wxWindow *) 0 ;
28140 long arg2 ;
28141 PyObject * obj0 = 0 ;
28142 PyObject * obj1 = 0 ;
28143 char *kwnames[] = {
28144 (char *) "self",(char *) "exStyle", NULL
28145 };
28146
28147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
28148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28149 if (SWIG_arg_fail(1)) SWIG_fail;
28150 {
28151 arg2 = (long)(SWIG_As_long(obj1));
28152 if (SWIG_arg_fail(2)) SWIG_fail;
28153 }
28154 {
28155 PyThreadState* __tstate = wxPyBeginAllowThreads();
28156 (arg1)->SetExtraStyle(arg2);
28157
28158 wxPyEndAllowThreads(__tstate);
28159 if (PyErr_Occurred()) SWIG_fail;
28160 }
28161 Py_INCREF(Py_None); resultobj = Py_None;
28162 return resultobj;
28163 fail:
28164 return NULL;
28165 }
28166
28167
28168 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
28169 PyObject *resultobj;
28170 wxWindow *arg1 = (wxWindow *) 0 ;
28171 long result;
28172 PyObject * obj0 = 0 ;
28173 char *kwnames[] = {
28174 (char *) "self", NULL
28175 };
28176
28177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
28178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28179 if (SWIG_arg_fail(1)) SWIG_fail;
28180 {
28181 PyThreadState* __tstate = wxPyBeginAllowThreads();
28182 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
28183
28184 wxPyEndAllowThreads(__tstate);
28185 if (PyErr_Occurred()) SWIG_fail;
28186 }
28187 {
28188 resultobj = SWIG_From_long((long)(result));
28189 }
28190 return resultobj;
28191 fail:
28192 return NULL;
28193 }
28194
28195
28196 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
28197 PyObject *resultobj;
28198 wxWindow *arg1 = (wxWindow *) 0 ;
28199 bool arg2 = (bool) true ;
28200 PyObject * obj0 = 0 ;
28201 PyObject * obj1 = 0 ;
28202 char *kwnames[] = {
28203 (char *) "self",(char *) "modal", NULL
28204 };
28205
28206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) 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 if (obj1) {
28210 {
28211 arg2 = (bool)(SWIG_As_bool(obj1));
28212 if (SWIG_arg_fail(2)) SWIG_fail;
28213 }
28214 }
28215 {
28216 PyThreadState* __tstate = wxPyBeginAllowThreads();
28217 (arg1)->MakeModal(arg2);
28218
28219 wxPyEndAllowThreads(__tstate);
28220 if (PyErr_Occurred()) SWIG_fail;
28221 }
28222 Py_INCREF(Py_None); resultobj = Py_None;
28223 return resultobj;
28224 fail:
28225 return NULL;
28226 }
28227
28228
28229 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28230 PyObject *resultobj;
28231 wxWindow *arg1 = (wxWindow *) 0 ;
28232 bool arg2 ;
28233 PyObject * obj0 = 0 ;
28234 PyObject * obj1 = 0 ;
28235 char *kwnames[] = {
28236 (char *) "self",(char *) "enableTheme", NULL
28237 };
28238
28239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
28240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28241 if (SWIG_arg_fail(1)) SWIG_fail;
28242 {
28243 arg2 = (bool)(SWIG_As_bool(obj1));
28244 if (SWIG_arg_fail(2)) SWIG_fail;
28245 }
28246 {
28247 PyThreadState* __tstate = wxPyBeginAllowThreads();
28248 (arg1)->SetThemeEnabled(arg2);
28249
28250 wxPyEndAllowThreads(__tstate);
28251 if (PyErr_Occurred()) SWIG_fail;
28252 }
28253 Py_INCREF(Py_None); resultobj = Py_None;
28254 return resultobj;
28255 fail:
28256 return NULL;
28257 }
28258
28259
28260 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
28261 PyObject *resultobj;
28262 wxWindow *arg1 = (wxWindow *) 0 ;
28263 bool result;
28264 PyObject * obj0 = 0 ;
28265 char *kwnames[] = {
28266 (char *) "self", NULL
28267 };
28268
28269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
28270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28271 if (SWIG_arg_fail(1)) SWIG_fail;
28272 {
28273 PyThreadState* __tstate = wxPyBeginAllowThreads();
28274 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
28275
28276 wxPyEndAllowThreads(__tstate);
28277 if (PyErr_Occurred()) SWIG_fail;
28278 }
28279 {
28280 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28281 }
28282 return resultobj;
28283 fail:
28284 return NULL;
28285 }
28286
28287
28288 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28289 PyObject *resultobj;
28290 wxWindow *arg1 = (wxWindow *) 0 ;
28291 PyObject * obj0 = 0 ;
28292 char *kwnames[] = {
28293 (char *) "self", NULL
28294 };
28295
28296 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
28297 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28298 if (SWIG_arg_fail(1)) SWIG_fail;
28299 {
28300 PyThreadState* __tstate = wxPyBeginAllowThreads();
28301 (arg1)->SetFocus();
28302
28303 wxPyEndAllowThreads(__tstate);
28304 if (PyErr_Occurred()) SWIG_fail;
28305 }
28306 Py_INCREF(Py_None); resultobj = Py_None;
28307 return resultobj;
28308 fail:
28309 return NULL;
28310 }
28311
28312
28313 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
28314 PyObject *resultobj;
28315 wxWindow *arg1 = (wxWindow *) 0 ;
28316 PyObject * obj0 = 0 ;
28317 char *kwnames[] = {
28318 (char *) "self", NULL
28319 };
28320
28321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
28322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28323 if (SWIG_arg_fail(1)) SWIG_fail;
28324 {
28325 PyThreadState* __tstate = wxPyBeginAllowThreads();
28326 (arg1)->SetFocusFromKbd();
28327
28328 wxPyEndAllowThreads(__tstate);
28329 if (PyErr_Occurred()) SWIG_fail;
28330 }
28331 Py_INCREF(Py_None); resultobj = Py_None;
28332 return resultobj;
28333 fail:
28334 return NULL;
28335 }
28336
28337
28338 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28339 PyObject *resultobj;
28340 wxWindow *result;
28341 char *kwnames[] = {
28342 NULL
28343 };
28344
28345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
28346 {
28347 if (!wxPyCheckForApp()) SWIG_fail;
28348 PyThreadState* __tstate = wxPyBeginAllowThreads();
28349 result = (wxWindow *)wxWindow::FindFocus();
28350
28351 wxPyEndAllowThreads(__tstate);
28352 if (PyErr_Occurred()) SWIG_fail;
28353 }
28354 {
28355 resultobj = wxPyMake_wxObject(result, 0);
28356 }
28357 return resultobj;
28358 fail:
28359 return NULL;
28360 }
28361
28362
28363 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
28364 PyObject *resultobj;
28365 wxWindow *arg1 = (wxWindow *) 0 ;
28366 bool result;
28367 PyObject * obj0 = 0 ;
28368 char *kwnames[] = {
28369 (char *) "self", NULL
28370 };
28371
28372 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
28373 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28374 if (SWIG_arg_fail(1)) SWIG_fail;
28375 {
28376 PyThreadState* __tstate = wxPyBeginAllowThreads();
28377 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
28378
28379 wxPyEndAllowThreads(__tstate);
28380 if (PyErr_Occurred()) SWIG_fail;
28381 }
28382 {
28383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28384 }
28385 return resultobj;
28386 fail:
28387 return NULL;
28388 }
28389
28390
28391 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
28392 PyObject *resultobj;
28393 wxWindow *arg1 = (wxWindow *) 0 ;
28394 bool result;
28395 PyObject * obj0 = 0 ;
28396 char *kwnames[] = {
28397 (char *) "self", NULL
28398 };
28399
28400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
28401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28402 if (SWIG_arg_fail(1)) SWIG_fail;
28403 {
28404 PyThreadState* __tstate = wxPyBeginAllowThreads();
28405 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
28406
28407 wxPyEndAllowThreads(__tstate);
28408 if (PyErr_Occurred()) SWIG_fail;
28409 }
28410 {
28411 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28412 }
28413 return resultobj;
28414 fail:
28415 return NULL;
28416 }
28417
28418
28419 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28420 PyObject *resultobj;
28421 wxWindow *arg1 = (wxWindow *) 0 ;
28422 wxWindow *result;
28423 PyObject * obj0 = 0 ;
28424 char *kwnames[] = {
28425 (char *) "self", NULL
28426 };
28427
28428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
28429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28430 if (SWIG_arg_fail(1)) SWIG_fail;
28431 {
28432 PyThreadState* __tstate = wxPyBeginAllowThreads();
28433 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
28434
28435 wxPyEndAllowThreads(__tstate);
28436 if (PyErr_Occurred()) SWIG_fail;
28437 }
28438 {
28439 resultobj = wxPyMake_wxObject(result, 0);
28440 }
28441 return resultobj;
28442 fail:
28443 return NULL;
28444 }
28445
28446
28447 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28448 PyObject *resultobj;
28449 wxWindow *arg1 = (wxWindow *) 0 ;
28450 wxWindow *arg2 = (wxWindow *) 0 ;
28451 wxWindow *result;
28452 PyObject * obj0 = 0 ;
28453 PyObject * obj1 = 0 ;
28454 char *kwnames[] = {
28455 (char *) "self",(char *) "child", NULL
28456 };
28457
28458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28460 if (SWIG_arg_fail(1)) SWIG_fail;
28461 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28462 if (SWIG_arg_fail(2)) SWIG_fail;
28463 {
28464 PyThreadState* __tstate = wxPyBeginAllowThreads();
28465 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
28466
28467 wxPyEndAllowThreads(__tstate);
28468 if (PyErr_Occurred()) SWIG_fail;
28469 }
28470 {
28471 resultobj = wxPyMake_wxObject(result, 0);
28472 }
28473 return resultobj;
28474 fail:
28475 return NULL;
28476 }
28477
28478
28479 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
28480 PyObject *resultobj;
28481 wxWindow *arg1 = (wxWindow *) 0 ;
28482 wxWindow *arg2 = (wxWindow *) 0 ;
28483 PyObject * obj0 = 0 ;
28484 PyObject * obj1 = 0 ;
28485 char *kwnames[] = {
28486 (char *) "self",(char *) "win", NULL
28487 };
28488
28489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28491 if (SWIG_arg_fail(1)) SWIG_fail;
28492 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28493 if (SWIG_arg_fail(2)) SWIG_fail;
28494 {
28495 PyThreadState* __tstate = wxPyBeginAllowThreads();
28496 (arg1)->SetTmpDefaultItem(arg2);
28497
28498 wxPyEndAllowThreads(__tstate);
28499 if (PyErr_Occurred()) SWIG_fail;
28500 }
28501 Py_INCREF(Py_None); resultobj = Py_None;
28502 return resultobj;
28503 fail:
28504 return NULL;
28505 }
28506
28507
28508 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28509 PyObject *resultobj;
28510 wxWindow *arg1 = (wxWindow *) 0 ;
28511 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28512 bool result;
28513 PyObject * obj0 = 0 ;
28514 PyObject * obj1 = 0 ;
28515 char *kwnames[] = {
28516 (char *) "self",(char *) "flags", NULL
28517 };
28518
28519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28521 if (SWIG_arg_fail(1)) SWIG_fail;
28522 if (obj1) {
28523 {
28524 arg2 = (int)(SWIG_As_int(obj1));
28525 if (SWIG_arg_fail(2)) SWIG_fail;
28526 }
28527 }
28528 {
28529 PyThreadState* __tstate = wxPyBeginAllowThreads();
28530 result = (bool)(arg1)->Navigate(arg2);
28531
28532 wxPyEndAllowThreads(__tstate);
28533 if (PyErr_Occurred()) SWIG_fail;
28534 }
28535 {
28536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28537 }
28538 return resultobj;
28539 fail:
28540 return NULL;
28541 }
28542
28543
28544 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28545 PyObject *resultobj;
28546 wxWindow *arg1 = (wxWindow *) 0 ;
28547 wxWindow *arg2 = (wxWindow *) 0 ;
28548 PyObject * obj0 = 0 ;
28549 PyObject * obj1 = 0 ;
28550 char *kwnames[] = {
28551 (char *) "self",(char *) "win", NULL
28552 };
28553
28554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28556 if (SWIG_arg_fail(1)) SWIG_fail;
28557 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28558 if (SWIG_arg_fail(2)) SWIG_fail;
28559 {
28560 PyThreadState* __tstate = wxPyBeginAllowThreads();
28561 (arg1)->MoveAfterInTabOrder(arg2);
28562
28563 wxPyEndAllowThreads(__tstate);
28564 if (PyErr_Occurred()) SWIG_fail;
28565 }
28566 Py_INCREF(Py_None); resultobj = Py_None;
28567 return resultobj;
28568 fail:
28569 return NULL;
28570 }
28571
28572
28573 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28574 PyObject *resultobj;
28575 wxWindow *arg1 = (wxWindow *) 0 ;
28576 wxWindow *arg2 = (wxWindow *) 0 ;
28577 PyObject * obj0 = 0 ;
28578 PyObject * obj1 = 0 ;
28579 char *kwnames[] = {
28580 (char *) "self",(char *) "win", NULL
28581 };
28582
28583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28585 if (SWIG_arg_fail(1)) SWIG_fail;
28586 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28587 if (SWIG_arg_fail(2)) SWIG_fail;
28588 {
28589 PyThreadState* __tstate = wxPyBeginAllowThreads();
28590 (arg1)->MoveBeforeInTabOrder(arg2);
28591
28592 wxPyEndAllowThreads(__tstate);
28593 if (PyErr_Occurred()) SWIG_fail;
28594 }
28595 Py_INCREF(Py_None); resultobj = Py_None;
28596 return resultobj;
28597 fail:
28598 return NULL;
28599 }
28600
28601
28602 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28603 PyObject *resultobj;
28604 wxWindow *arg1 = (wxWindow *) 0 ;
28605 PyObject *result;
28606 PyObject * obj0 = 0 ;
28607 char *kwnames[] = {
28608 (char *) "self", NULL
28609 };
28610
28611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28613 if (SWIG_arg_fail(1)) SWIG_fail;
28614 {
28615 PyThreadState* __tstate = wxPyBeginAllowThreads();
28616 result = (PyObject *)wxWindow_GetChildren(arg1);
28617
28618 wxPyEndAllowThreads(__tstate);
28619 if (PyErr_Occurred()) SWIG_fail;
28620 }
28621 resultobj = result;
28622 return resultobj;
28623 fail:
28624 return NULL;
28625 }
28626
28627
28628 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28629 PyObject *resultobj;
28630 wxWindow *arg1 = (wxWindow *) 0 ;
28631 wxWindow *result;
28632 PyObject * obj0 = 0 ;
28633 char *kwnames[] = {
28634 (char *) "self", NULL
28635 };
28636
28637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28639 if (SWIG_arg_fail(1)) SWIG_fail;
28640 {
28641 PyThreadState* __tstate = wxPyBeginAllowThreads();
28642 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28643
28644 wxPyEndAllowThreads(__tstate);
28645 if (PyErr_Occurred()) SWIG_fail;
28646 }
28647 {
28648 resultobj = wxPyMake_wxObject(result, 0);
28649 }
28650 return resultobj;
28651 fail:
28652 return NULL;
28653 }
28654
28655
28656 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28657 PyObject *resultobj;
28658 wxWindow *arg1 = (wxWindow *) 0 ;
28659 wxWindow *result;
28660 PyObject * obj0 = 0 ;
28661 char *kwnames[] = {
28662 (char *) "self", NULL
28663 };
28664
28665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28667 if (SWIG_arg_fail(1)) SWIG_fail;
28668 {
28669 PyThreadState* __tstate = wxPyBeginAllowThreads();
28670 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28671
28672 wxPyEndAllowThreads(__tstate);
28673 if (PyErr_Occurred()) SWIG_fail;
28674 }
28675 {
28676 resultobj = wxPyMake_wxObject(result, 0);
28677 }
28678 return resultobj;
28679 fail:
28680 return NULL;
28681 }
28682
28683
28684 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28685 PyObject *resultobj;
28686 wxWindow *arg1 = (wxWindow *) 0 ;
28687 bool result;
28688 PyObject * obj0 = 0 ;
28689 char *kwnames[] = {
28690 (char *) "self", NULL
28691 };
28692
28693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28695 if (SWIG_arg_fail(1)) SWIG_fail;
28696 {
28697 PyThreadState* __tstate = wxPyBeginAllowThreads();
28698 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28699
28700 wxPyEndAllowThreads(__tstate);
28701 if (PyErr_Occurred()) SWIG_fail;
28702 }
28703 {
28704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28705 }
28706 return resultobj;
28707 fail:
28708 return NULL;
28709 }
28710
28711
28712 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28713 PyObject *resultobj;
28714 wxWindow *arg1 = (wxWindow *) 0 ;
28715 wxWindow *arg2 = (wxWindow *) 0 ;
28716 bool result;
28717 PyObject * obj0 = 0 ;
28718 PyObject * obj1 = 0 ;
28719 char *kwnames[] = {
28720 (char *) "self",(char *) "newParent", NULL
28721 };
28722
28723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28725 if (SWIG_arg_fail(1)) SWIG_fail;
28726 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28727 if (SWIG_arg_fail(2)) SWIG_fail;
28728 {
28729 PyThreadState* __tstate = wxPyBeginAllowThreads();
28730 result = (bool)(arg1)->Reparent(arg2);
28731
28732 wxPyEndAllowThreads(__tstate);
28733 if (PyErr_Occurred()) SWIG_fail;
28734 }
28735 {
28736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28737 }
28738 return resultobj;
28739 fail:
28740 return NULL;
28741 }
28742
28743
28744 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28745 PyObject *resultobj;
28746 wxWindow *arg1 = (wxWindow *) 0 ;
28747 wxWindow *arg2 = (wxWindow *) 0 ;
28748 PyObject * obj0 = 0 ;
28749 PyObject * obj1 = 0 ;
28750 char *kwnames[] = {
28751 (char *) "self",(char *) "child", NULL
28752 };
28753
28754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28756 if (SWIG_arg_fail(1)) SWIG_fail;
28757 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28758 if (SWIG_arg_fail(2)) SWIG_fail;
28759 {
28760 PyThreadState* __tstate = wxPyBeginAllowThreads();
28761 (arg1)->AddChild(arg2);
28762
28763 wxPyEndAllowThreads(__tstate);
28764 if (PyErr_Occurred()) SWIG_fail;
28765 }
28766 Py_INCREF(Py_None); resultobj = Py_None;
28767 return resultobj;
28768 fail:
28769 return NULL;
28770 }
28771
28772
28773 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28774 PyObject *resultobj;
28775 wxWindow *arg1 = (wxWindow *) 0 ;
28776 wxWindow *arg2 = (wxWindow *) 0 ;
28777 PyObject * obj0 = 0 ;
28778 PyObject * obj1 = 0 ;
28779 char *kwnames[] = {
28780 (char *) "self",(char *) "child", NULL
28781 };
28782
28783 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28784 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28785 if (SWIG_arg_fail(1)) SWIG_fail;
28786 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28787 if (SWIG_arg_fail(2)) SWIG_fail;
28788 {
28789 PyThreadState* __tstate = wxPyBeginAllowThreads();
28790 (arg1)->RemoveChild(arg2);
28791
28792 wxPyEndAllowThreads(__tstate);
28793 if (PyErr_Occurred()) SWIG_fail;
28794 }
28795 Py_INCREF(Py_None); resultobj = Py_None;
28796 return resultobj;
28797 fail:
28798 return NULL;
28799 }
28800
28801
28802 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28803 PyObject *resultobj;
28804 wxWindow *arg1 = (wxWindow *) 0 ;
28805 long arg2 ;
28806 wxWindow *result;
28807 PyObject * obj0 = 0 ;
28808 PyObject * obj1 = 0 ;
28809 char *kwnames[] = {
28810 (char *) "self",(char *) "winid", NULL
28811 };
28812
28813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28815 if (SWIG_arg_fail(1)) SWIG_fail;
28816 {
28817 arg2 = (long)(SWIG_As_long(obj1));
28818 if (SWIG_arg_fail(2)) SWIG_fail;
28819 }
28820 {
28821 PyThreadState* __tstate = wxPyBeginAllowThreads();
28822 result = (wxWindow *)(arg1)->FindWindow(arg2);
28823
28824 wxPyEndAllowThreads(__tstate);
28825 if (PyErr_Occurred()) SWIG_fail;
28826 }
28827 {
28828 resultobj = wxPyMake_wxObject(result, 0);
28829 }
28830 return resultobj;
28831 fail:
28832 return NULL;
28833 }
28834
28835
28836 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28837 PyObject *resultobj;
28838 wxWindow *arg1 = (wxWindow *) 0 ;
28839 wxString *arg2 = 0 ;
28840 wxWindow *result;
28841 bool temp2 = false ;
28842 PyObject * obj0 = 0 ;
28843 PyObject * obj1 = 0 ;
28844 char *kwnames[] = {
28845 (char *) "self",(char *) "name", NULL
28846 };
28847
28848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28850 if (SWIG_arg_fail(1)) SWIG_fail;
28851 {
28852 arg2 = wxString_in_helper(obj1);
28853 if (arg2 == NULL) SWIG_fail;
28854 temp2 = true;
28855 }
28856 {
28857 PyThreadState* __tstate = wxPyBeginAllowThreads();
28858 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28859
28860 wxPyEndAllowThreads(__tstate);
28861 if (PyErr_Occurred()) SWIG_fail;
28862 }
28863 {
28864 resultobj = wxPyMake_wxObject(result, 0);
28865 }
28866 {
28867 if (temp2)
28868 delete arg2;
28869 }
28870 return resultobj;
28871 fail:
28872 {
28873 if (temp2)
28874 delete arg2;
28875 }
28876 return NULL;
28877 }
28878
28879
28880 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28881 PyObject *resultobj;
28882 wxWindow *arg1 = (wxWindow *) 0 ;
28883 wxEvtHandler *result;
28884 PyObject * obj0 = 0 ;
28885 char *kwnames[] = {
28886 (char *) "self", NULL
28887 };
28888
28889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28891 if (SWIG_arg_fail(1)) SWIG_fail;
28892 {
28893 PyThreadState* __tstate = wxPyBeginAllowThreads();
28894 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28895
28896 wxPyEndAllowThreads(__tstate);
28897 if (PyErr_Occurred()) SWIG_fail;
28898 }
28899 {
28900 resultobj = wxPyMake_wxObject(result, 0);
28901 }
28902 return resultobj;
28903 fail:
28904 return NULL;
28905 }
28906
28907
28908 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28909 PyObject *resultobj;
28910 wxWindow *arg1 = (wxWindow *) 0 ;
28911 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28912 PyObject * obj0 = 0 ;
28913 PyObject * obj1 = 0 ;
28914 char *kwnames[] = {
28915 (char *) "self",(char *) "handler", NULL
28916 };
28917
28918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28920 if (SWIG_arg_fail(1)) SWIG_fail;
28921 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28922 if (SWIG_arg_fail(2)) SWIG_fail;
28923 {
28924 PyThreadState* __tstate = wxPyBeginAllowThreads();
28925 (arg1)->SetEventHandler(arg2);
28926
28927 wxPyEndAllowThreads(__tstate);
28928 if (PyErr_Occurred()) SWIG_fail;
28929 }
28930 Py_INCREF(Py_None); resultobj = Py_None;
28931 return resultobj;
28932 fail:
28933 return NULL;
28934 }
28935
28936
28937 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28938 PyObject *resultobj;
28939 wxWindow *arg1 = (wxWindow *) 0 ;
28940 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28941 PyObject * obj0 = 0 ;
28942 PyObject * obj1 = 0 ;
28943 char *kwnames[] = {
28944 (char *) "self",(char *) "handler", NULL
28945 };
28946
28947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28949 if (SWIG_arg_fail(1)) SWIG_fail;
28950 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28951 if (SWIG_arg_fail(2)) SWIG_fail;
28952 {
28953 PyThreadState* __tstate = wxPyBeginAllowThreads();
28954 (arg1)->PushEventHandler(arg2);
28955
28956 wxPyEndAllowThreads(__tstate);
28957 if (PyErr_Occurred()) SWIG_fail;
28958 }
28959 Py_INCREF(Py_None); resultobj = Py_None;
28960 return resultobj;
28961 fail:
28962 return NULL;
28963 }
28964
28965
28966 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28967 PyObject *resultobj;
28968 wxWindow *arg1 = (wxWindow *) 0 ;
28969 bool arg2 = (bool) false ;
28970 wxEvtHandler *result;
28971 PyObject * obj0 = 0 ;
28972 PyObject * obj1 = 0 ;
28973 char *kwnames[] = {
28974 (char *) "self",(char *) "deleteHandler", NULL
28975 };
28976
28977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28979 if (SWIG_arg_fail(1)) SWIG_fail;
28980 if (obj1) {
28981 {
28982 arg2 = (bool)(SWIG_As_bool(obj1));
28983 if (SWIG_arg_fail(2)) SWIG_fail;
28984 }
28985 }
28986 {
28987 PyThreadState* __tstate = wxPyBeginAllowThreads();
28988 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28989
28990 wxPyEndAllowThreads(__tstate);
28991 if (PyErr_Occurred()) SWIG_fail;
28992 }
28993 {
28994 resultobj = wxPyMake_wxObject(result, 0);
28995 }
28996 return resultobj;
28997 fail:
28998 return NULL;
28999 }
29000
29001
29002 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
29003 PyObject *resultobj;
29004 wxWindow *arg1 = (wxWindow *) 0 ;
29005 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
29006 bool result;
29007 PyObject * obj0 = 0 ;
29008 PyObject * obj1 = 0 ;
29009 char *kwnames[] = {
29010 (char *) "self",(char *) "handler", NULL
29011 };
29012
29013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
29014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29015 if (SWIG_arg_fail(1)) SWIG_fail;
29016 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
29017 if (SWIG_arg_fail(2)) SWIG_fail;
29018 {
29019 PyThreadState* __tstate = wxPyBeginAllowThreads();
29020 result = (bool)(arg1)->RemoveEventHandler(arg2);
29021
29022 wxPyEndAllowThreads(__tstate);
29023 if (PyErr_Occurred()) SWIG_fail;
29024 }
29025 {
29026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29027 }
29028 return resultobj;
29029 fail:
29030 return NULL;
29031 }
29032
29033
29034 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29035 PyObject *resultobj;
29036 wxWindow *arg1 = (wxWindow *) 0 ;
29037 wxValidator *arg2 = 0 ;
29038 PyObject * obj0 = 0 ;
29039 PyObject * obj1 = 0 ;
29040 char *kwnames[] = {
29041 (char *) "self",(char *) "validator", NULL
29042 };
29043
29044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
29045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29046 if (SWIG_arg_fail(1)) SWIG_fail;
29047 {
29048 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
29049 if (SWIG_arg_fail(2)) SWIG_fail;
29050 if (arg2 == NULL) {
29051 SWIG_null_ref("wxValidator");
29052 }
29053 if (SWIG_arg_fail(2)) SWIG_fail;
29054 }
29055 {
29056 PyThreadState* __tstate = wxPyBeginAllowThreads();
29057 (arg1)->SetValidator((wxValidator const &)*arg2);
29058
29059 wxPyEndAllowThreads(__tstate);
29060 if (PyErr_Occurred()) SWIG_fail;
29061 }
29062 Py_INCREF(Py_None); resultobj = Py_None;
29063 return resultobj;
29064 fail:
29065 return NULL;
29066 }
29067
29068
29069 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
29070 PyObject *resultobj;
29071 wxWindow *arg1 = (wxWindow *) 0 ;
29072 wxValidator *result;
29073 PyObject * obj0 = 0 ;
29074 char *kwnames[] = {
29075 (char *) "self", NULL
29076 };
29077
29078 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
29079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29080 if (SWIG_arg_fail(1)) SWIG_fail;
29081 {
29082 PyThreadState* __tstate = wxPyBeginAllowThreads();
29083 result = (wxValidator *)(arg1)->GetValidator();
29084
29085 wxPyEndAllowThreads(__tstate);
29086 if (PyErr_Occurred()) SWIG_fail;
29087 }
29088 {
29089 resultobj = wxPyMake_wxObject(result, 0);
29090 }
29091 return resultobj;
29092 fail:
29093 return NULL;
29094 }
29095
29096
29097 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
29098 PyObject *resultobj;
29099 wxWindow *arg1 = (wxWindow *) 0 ;
29100 bool result;
29101 PyObject * obj0 = 0 ;
29102 char *kwnames[] = {
29103 (char *) "self", NULL
29104 };
29105
29106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
29107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29108 if (SWIG_arg_fail(1)) SWIG_fail;
29109 {
29110 PyThreadState* __tstate = wxPyBeginAllowThreads();
29111 result = (bool)(arg1)->Validate();
29112
29113 wxPyEndAllowThreads(__tstate);
29114 if (PyErr_Occurred()) SWIG_fail;
29115 }
29116 {
29117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29118 }
29119 return resultobj;
29120 fail:
29121 return NULL;
29122 }
29123
29124
29125 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29126 PyObject *resultobj;
29127 wxWindow *arg1 = (wxWindow *) 0 ;
29128 bool result;
29129 PyObject * obj0 = 0 ;
29130 char *kwnames[] = {
29131 (char *) "self", NULL
29132 };
29133
29134 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
29135 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29136 if (SWIG_arg_fail(1)) SWIG_fail;
29137 {
29138 PyThreadState* __tstate = wxPyBeginAllowThreads();
29139 result = (bool)(arg1)->TransferDataToWindow();
29140
29141 wxPyEndAllowThreads(__tstate);
29142 if (PyErr_Occurred()) SWIG_fail;
29143 }
29144 {
29145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29146 }
29147 return resultobj;
29148 fail:
29149 return NULL;
29150 }
29151
29152
29153 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
29154 PyObject *resultobj;
29155 wxWindow *arg1 = (wxWindow *) 0 ;
29156 bool result;
29157 PyObject * obj0 = 0 ;
29158 char *kwnames[] = {
29159 (char *) "self", NULL
29160 };
29161
29162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
29163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29164 if (SWIG_arg_fail(1)) SWIG_fail;
29165 {
29166 PyThreadState* __tstate = wxPyBeginAllowThreads();
29167 result = (bool)(arg1)->TransferDataFromWindow();
29168
29169 wxPyEndAllowThreads(__tstate);
29170 if (PyErr_Occurred()) SWIG_fail;
29171 }
29172 {
29173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29174 }
29175 return resultobj;
29176 fail:
29177 return NULL;
29178 }
29179
29180
29181 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29182 PyObject *resultobj;
29183 wxWindow *arg1 = (wxWindow *) 0 ;
29184 PyObject * obj0 = 0 ;
29185 char *kwnames[] = {
29186 (char *) "self", NULL
29187 };
29188
29189 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
29190 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29191 if (SWIG_arg_fail(1)) SWIG_fail;
29192 {
29193 PyThreadState* __tstate = wxPyBeginAllowThreads();
29194 (arg1)->InitDialog();
29195
29196 wxPyEndAllowThreads(__tstate);
29197 if (PyErr_Occurred()) SWIG_fail;
29198 }
29199 Py_INCREF(Py_None); resultobj = Py_None;
29200 return resultobj;
29201 fail:
29202 return NULL;
29203 }
29204
29205
29206 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29207 PyObject *resultobj;
29208 wxWindow *arg1 = (wxWindow *) 0 ;
29209 wxAcceleratorTable *arg2 = 0 ;
29210 PyObject * obj0 = 0 ;
29211 PyObject * obj1 = 0 ;
29212 char *kwnames[] = {
29213 (char *) "self",(char *) "accel", NULL
29214 };
29215
29216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
29217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29218 if (SWIG_arg_fail(1)) SWIG_fail;
29219 {
29220 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
29221 if (SWIG_arg_fail(2)) SWIG_fail;
29222 if (arg2 == NULL) {
29223 SWIG_null_ref("wxAcceleratorTable");
29224 }
29225 if (SWIG_arg_fail(2)) SWIG_fail;
29226 }
29227 {
29228 PyThreadState* __tstate = wxPyBeginAllowThreads();
29229 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
29230
29231 wxPyEndAllowThreads(__tstate);
29232 if (PyErr_Occurred()) SWIG_fail;
29233 }
29234 Py_INCREF(Py_None); resultobj = Py_None;
29235 return resultobj;
29236 fail:
29237 return NULL;
29238 }
29239
29240
29241 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
29242 PyObject *resultobj;
29243 wxWindow *arg1 = (wxWindow *) 0 ;
29244 wxAcceleratorTable *result;
29245 PyObject * obj0 = 0 ;
29246 char *kwnames[] = {
29247 (char *) "self", NULL
29248 };
29249
29250 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
29251 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29252 if (SWIG_arg_fail(1)) SWIG_fail;
29253 {
29254 PyThreadState* __tstate = wxPyBeginAllowThreads();
29255 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
29256
29257 wxPyEndAllowThreads(__tstate);
29258 if (PyErr_Occurred()) SWIG_fail;
29259 }
29260 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
29261 return resultobj;
29262 fail:
29263 return NULL;
29264 }
29265
29266
29267 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29268 PyObject *resultobj;
29269 wxWindow *arg1 = (wxWindow *) 0 ;
29270 int arg2 ;
29271 int arg3 ;
29272 int arg4 ;
29273 bool result;
29274 PyObject * obj0 = 0 ;
29275 PyObject * obj1 = 0 ;
29276 PyObject * obj2 = 0 ;
29277 PyObject * obj3 = 0 ;
29278 char *kwnames[] = {
29279 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
29280 };
29281
29282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
29283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29284 if (SWIG_arg_fail(1)) SWIG_fail;
29285 {
29286 arg2 = (int)(SWIG_As_int(obj1));
29287 if (SWIG_arg_fail(2)) SWIG_fail;
29288 }
29289 {
29290 arg3 = (int)(SWIG_As_int(obj2));
29291 if (SWIG_arg_fail(3)) SWIG_fail;
29292 }
29293 {
29294 arg4 = (int)(SWIG_As_int(obj3));
29295 if (SWIG_arg_fail(4)) SWIG_fail;
29296 }
29297 {
29298 PyThreadState* __tstate = wxPyBeginAllowThreads();
29299 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
29300
29301 wxPyEndAllowThreads(__tstate);
29302 if (PyErr_Occurred()) SWIG_fail;
29303 }
29304 {
29305 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29306 }
29307 return resultobj;
29308 fail:
29309 return NULL;
29310 }
29311
29312
29313 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
29314 PyObject *resultobj;
29315 wxWindow *arg1 = (wxWindow *) 0 ;
29316 int arg2 ;
29317 bool result;
29318 PyObject * obj0 = 0 ;
29319 PyObject * obj1 = 0 ;
29320 char *kwnames[] = {
29321 (char *) "self",(char *) "hotkeyId", NULL
29322 };
29323
29324 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
29325 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29326 if (SWIG_arg_fail(1)) SWIG_fail;
29327 {
29328 arg2 = (int)(SWIG_As_int(obj1));
29329 if (SWIG_arg_fail(2)) SWIG_fail;
29330 }
29331 {
29332 PyThreadState* __tstate = wxPyBeginAllowThreads();
29333 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
29334
29335 wxPyEndAllowThreads(__tstate);
29336 if (PyErr_Occurred()) SWIG_fail;
29337 }
29338 {
29339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29340 }
29341 return resultobj;
29342 fail:
29343 return NULL;
29344 }
29345
29346
29347 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29348 PyObject *resultobj;
29349 wxWindow *arg1 = (wxWindow *) 0 ;
29350 wxPoint *arg2 = 0 ;
29351 wxPoint result;
29352 wxPoint temp2 ;
29353 PyObject * obj0 = 0 ;
29354 PyObject * obj1 = 0 ;
29355 char *kwnames[] = {
29356 (char *) "self",(char *) "pt", NULL
29357 };
29358
29359 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
29360 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29361 if (SWIG_arg_fail(1)) SWIG_fail;
29362 {
29363 arg2 = &temp2;
29364 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29365 }
29366 {
29367 PyThreadState* __tstate = wxPyBeginAllowThreads();
29368 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29369
29370 wxPyEndAllowThreads(__tstate);
29371 if (PyErr_Occurred()) SWIG_fail;
29372 }
29373 {
29374 wxPoint * resultptr;
29375 resultptr = new wxPoint((wxPoint &)(result));
29376 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29377 }
29378 return resultobj;
29379 fail:
29380 return NULL;
29381 }
29382
29383
29384 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
29385 PyObject *resultobj;
29386 wxWindow *arg1 = (wxWindow *) 0 ;
29387 wxSize *arg2 = 0 ;
29388 wxSize result;
29389 wxSize temp2 ;
29390 PyObject * obj0 = 0 ;
29391 PyObject * obj1 = 0 ;
29392 char *kwnames[] = {
29393 (char *) "self",(char *) "sz", NULL
29394 };
29395
29396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
29397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29398 if (SWIG_arg_fail(1)) SWIG_fail;
29399 {
29400 arg2 = &temp2;
29401 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29402 }
29403 {
29404 PyThreadState* __tstate = wxPyBeginAllowThreads();
29405 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29406
29407 wxPyEndAllowThreads(__tstate);
29408 if (PyErr_Occurred()) SWIG_fail;
29409 }
29410 {
29411 wxSize * resultptr;
29412 resultptr = new wxSize((wxSize &)(result));
29413 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29414 }
29415 return resultobj;
29416 fail:
29417 return NULL;
29418 }
29419
29420
29421 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
29422 PyObject *resultobj;
29423 wxWindow *arg1 = (wxWindow *) 0 ;
29424 wxPoint *arg2 = 0 ;
29425 wxPoint result;
29426 wxPoint temp2 ;
29427 PyObject * obj0 = 0 ;
29428 PyObject * obj1 = 0 ;
29429 char *kwnames[] = {
29430 (char *) "self",(char *) "pt", NULL
29431 };
29432
29433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
29434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29435 if (SWIG_arg_fail(1)) SWIG_fail;
29436 {
29437 arg2 = &temp2;
29438 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29439 }
29440 {
29441 PyThreadState* __tstate = wxPyBeginAllowThreads();
29442 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
29443
29444 wxPyEndAllowThreads(__tstate);
29445 if (PyErr_Occurred()) SWIG_fail;
29446 }
29447 {
29448 wxPoint * resultptr;
29449 resultptr = new wxPoint((wxPoint &)(result));
29450 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29451 }
29452 return resultobj;
29453 fail:
29454 return NULL;
29455 }
29456
29457
29458 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
29459 PyObject *resultobj;
29460 wxWindow *arg1 = (wxWindow *) 0 ;
29461 wxSize *arg2 = 0 ;
29462 wxSize result;
29463 wxSize temp2 ;
29464 PyObject * obj0 = 0 ;
29465 PyObject * obj1 = 0 ;
29466 char *kwnames[] = {
29467 (char *) "self",(char *) "sz", NULL
29468 };
29469
29470 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
29471 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29472 if (SWIG_arg_fail(1)) SWIG_fail;
29473 {
29474 arg2 = &temp2;
29475 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29476 }
29477 {
29478 PyThreadState* __tstate = wxPyBeginAllowThreads();
29479 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
29480
29481 wxPyEndAllowThreads(__tstate);
29482 if (PyErr_Occurred()) SWIG_fail;
29483 }
29484 {
29485 wxSize * resultptr;
29486 resultptr = new wxSize((wxSize &)(result));
29487 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29488 }
29489 return resultobj;
29490 fail:
29491 return NULL;
29492 }
29493
29494
29495 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29496 PyObject *resultobj;
29497 wxWindow *arg1 = (wxWindow *) 0 ;
29498 wxPoint *arg2 = 0 ;
29499 wxPoint result;
29500 wxPoint temp2 ;
29501 PyObject * obj0 = 0 ;
29502 PyObject * obj1 = 0 ;
29503 char *kwnames[] = {
29504 (char *) "self",(char *) "pt", NULL
29505 };
29506
29507 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29508 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29509 if (SWIG_arg_fail(1)) SWIG_fail;
29510 {
29511 arg2 = &temp2;
29512 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29513 }
29514 {
29515 PyThreadState* __tstate = wxPyBeginAllowThreads();
29516 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29517
29518 wxPyEndAllowThreads(__tstate);
29519 if (PyErr_Occurred()) SWIG_fail;
29520 }
29521 {
29522 wxPoint * resultptr;
29523 resultptr = new wxPoint((wxPoint &)(result));
29524 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29525 }
29526 return resultobj;
29527 fail:
29528 return NULL;
29529 }
29530
29531
29532 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29533 PyObject *resultobj;
29534 wxWindow *arg1 = (wxWindow *) 0 ;
29535 wxSize *arg2 = 0 ;
29536 wxSize result;
29537 wxSize temp2 ;
29538 PyObject * obj0 = 0 ;
29539 PyObject * obj1 = 0 ;
29540 char *kwnames[] = {
29541 (char *) "self",(char *) "sz", NULL
29542 };
29543
29544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29546 if (SWIG_arg_fail(1)) SWIG_fail;
29547 {
29548 arg2 = &temp2;
29549 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29550 }
29551 {
29552 PyThreadState* __tstate = wxPyBeginAllowThreads();
29553 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29554
29555 wxPyEndAllowThreads(__tstate);
29556 if (PyErr_Occurred()) SWIG_fail;
29557 }
29558 {
29559 wxSize * resultptr;
29560 resultptr = new wxSize((wxSize &)(result));
29561 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29562 }
29563 return resultobj;
29564 fail:
29565 return NULL;
29566 }
29567
29568
29569 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29570 PyObject *resultobj;
29571 wxWindow *arg1 = (wxWindow *) 0 ;
29572 int arg2 ;
29573 int arg3 ;
29574 PyObject * obj0 = 0 ;
29575 PyObject * obj1 = 0 ;
29576 PyObject * obj2 = 0 ;
29577 char *kwnames[] = {
29578 (char *) "self",(char *) "x",(char *) "y", NULL
29579 };
29580
29581 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29582 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29583 if (SWIG_arg_fail(1)) SWIG_fail;
29584 {
29585 arg2 = (int)(SWIG_As_int(obj1));
29586 if (SWIG_arg_fail(2)) SWIG_fail;
29587 }
29588 {
29589 arg3 = (int)(SWIG_As_int(obj2));
29590 if (SWIG_arg_fail(3)) SWIG_fail;
29591 }
29592 {
29593 PyThreadState* __tstate = wxPyBeginAllowThreads();
29594 (arg1)->WarpPointer(arg2,arg3);
29595
29596 wxPyEndAllowThreads(__tstate);
29597 if (PyErr_Occurred()) SWIG_fail;
29598 }
29599 Py_INCREF(Py_None); resultobj = Py_None;
29600 return resultobj;
29601 fail:
29602 return NULL;
29603 }
29604
29605
29606 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29607 PyObject *resultobj;
29608 wxWindow *arg1 = (wxWindow *) 0 ;
29609 PyObject * obj0 = 0 ;
29610 char *kwnames[] = {
29611 (char *) "self", NULL
29612 };
29613
29614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",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 (arg1)->CaptureMouse();
29620
29621 wxPyEndAllowThreads(__tstate);
29622 if (PyErr_Occurred()) SWIG_fail;
29623 }
29624 Py_INCREF(Py_None); resultobj = Py_None;
29625 return resultobj;
29626 fail:
29627 return NULL;
29628 }
29629
29630
29631 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29632 PyObject *resultobj;
29633 wxWindow *arg1 = (wxWindow *) 0 ;
29634 PyObject * obj0 = 0 ;
29635 char *kwnames[] = {
29636 (char *) "self", NULL
29637 };
29638
29639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29641 if (SWIG_arg_fail(1)) SWIG_fail;
29642 {
29643 PyThreadState* __tstate = wxPyBeginAllowThreads();
29644 (arg1)->ReleaseMouse();
29645
29646 wxPyEndAllowThreads(__tstate);
29647 if (PyErr_Occurred()) SWIG_fail;
29648 }
29649 Py_INCREF(Py_None); resultobj = Py_None;
29650 return resultobj;
29651 fail:
29652 return NULL;
29653 }
29654
29655
29656 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29657 PyObject *resultobj;
29658 wxWindow *result;
29659 char *kwnames[] = {
29660 NULL
29661 };
29662
29663 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29664 {
29665 if (!wxPyCheckForApp()) SWIG_fail;
29666 PyThreadState* __tstate = wxPyBeginAllowThreads();
29667 result = (wxWindow *)wxWindow::GetCapture();
29668
29669 wxPyEndAllowThreads(__tstate);
29670 if (PyErr_Occurred()) SWIG_fail;
29671 }
29672 {
29673 resultobj = wxPyMake_wxObject(result, 0);
29674 }
29675 return resultobj;
29676 fail:
29677 return NULL;
29678 }
29679
29680
29681 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29682 PyObject *resultobj;
29683 wxWindow *arg1 = (wxWindow *) 0 ;
29684 bool result;
29685 PyObject * obj0 = 0 ;
29686 char *kwnames[] = {
29687 (char *) "self", NULL
29688 };
29689
29690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29692 if (SWIG_arg_fail(1)) SWIG_fail;
29693 {
29694 PyThreadState* __tstate = wxPyBeginAllowThreads();
29695 result = (bool)((wxWindow const *)arg1)->HasCapture();
29696
29697 wxPyEndAllowThreads(__tstate);
29698 if (PyErr_Occurred()) SWIG_fail;
29699 }
29700 {
29701 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29702 }
29703 return resultobj;
29704 fail:
29705 return NULL;
29706 }
29707
29708
29709 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29710 PyObject *resultobj;
29711 wxWindow *arg1 = (wxWindow *) 0 ;
29712 bool arg2 = (bool) true ;
29713 wxRect *arg3 = (wxRect *) NULL ;
29714 PyObject * obj0 = 0 ;
29715 PyObject * obj1 = 0 ;
29716 PyObject * obj2 = 0 ;
29717 char *kwnames[] = {
29718 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29719 };
29720
29721 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29723 if (SWIG_arg_fail(1)) SWIG_fail;
29724 if (obj1) {
29725 {
29726 arg2 = (bool)(SWIG_As_bool(obj1));
29727 if (SWIG_arg_fail(2)) SWIG_fail;
29728 }
29729 }
29730 if (obj2) {
29731 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29732 if (SWIG_arg_fail(3)) SWIG_fail;
29733 }
29734 {
29735 PyThreadState* __tstate = wxPyBeginAllowThreads();
29736 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29737
29738 wxPyEndAllowThreads(__tstate);
29739 if (PyErr_Occurred()) SWIG_fail;
29740 }
29741 Py_INCREF(Py_None); resultobj = Py_None;
29742 return resultobj;
29743 fail:
29744 return NULL;
29745 }
29746
29747
29748 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29749 PyObject *resultobj;
29750 wxWindow *arg1 = (wxWindow *) 0 ;
29751 wxRect *arg2 = 0 ;
29752 bool arg3 = (bool) true ;
29753 wxRect temp2 ;
29754 PyObject * obj0 = 0 ;
29755 PyObject * obj1 = 0 ;
29756 PyObject * obj2 = 0 ;
29757 char *kwnames[] = {
29758 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29759 };
29760
29761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29763 if (SWIG_arg_fail(1)) SWIG_fail;
29764 {
29765 arg2 = &temp2;
29766 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29767 }
29768 if (obj2) {
29769 {
29770 arg3 = (bool)(SWIG_As_bool(obj2));
29771 if (SWIG_arg_fail(3)) SWIG_fail;
29772 }
29773 }
29774 {
29775 PyThreadState* __tstate = wxPyBeginAllowThreads();
29776 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29777
29778 wxPyEndAllowThreads(__tstate);
29779 if (PyErr_Occurred()) SWIG_fail;
29780 }
29781 Py_INCREF(Py_None); resultobj = Py_None;
29782 return resultobj;
29783 fail:
29784 return NULL;
29785 }
29786
29787
29788 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29789 PyObject *resultobj;
29790 wxWindow *arg1 = (wxWindow *) 0 ;
29791 PyObject * obj0 = 0 ;
29792 char *kwnames[] = {
29793 (char *) "self", NULL
29794 };
29795
29796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29798 if (SWIG_arg_fail(1)) SWIG_fail;
29799 {
29800 PyThreadState* __tstate = wxPyBeginAllowThreads();
29801 (arg1)->Update();
29802
29803 wxPyEndAllowThreads(__tstate);
29804 if (PyErr_Occurred()) SWIG_fail;
29805 }
29806 Py_INCREF(Py_None); resultobj = Py_None;
29807 return resultobj;
29808 fail:
29809 return NULL;
29810 }
29811
29812
29813 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29814 PyObject *resultobj;
29815 wxWindow *arg1 = (wxWindow *) 0 ;
29816 PyObject * obj0 = 0 ;
29817 char *kwnames[] = {
29818 (char *) "self", NULL
29819 };
29820
29821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29823 if (SWIG_arg_fail(1)) SWIG_fail;
29824 {
29825 PyThreadState* __tstate = wxPyBeginAllowThreads();
29826 (arg1)->ClearBackground();
29827
29828 wxPyEndAllowThreads(__tstate);
29829 if (PyErr_Occurred()) SWIG_fail;
29830 }
29831 Py_INCREF(Py_None); resultobj = Py_None;
29832 return resultobj;
29833 fail:
29834 return NULL;
29835 }
29836
29837
29838 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29839 PyObject *resultobj;
29840 wxWindow *arg1 = (wxWindow *) 0 ;
29841 PyObject * obj0 = 0 ;
29842 char *kwnames[] = {
29843 (char *) "self", NULL
29844 };
29845
29846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29848 if (SWIG_arg_fail(1)) SWIG_fail;
29849 {
29850 PyThreadState* __tstate = wxPyBeginAllowThreads();
29851 (arg1)->Freeze();
29852
29853 wxPyEndAllowThreads(__tstate);
29854 if (PyErr_Occurred()) SWIG_fail;
29855 }
29856 Py_INCREF(Py_None); resultobj = Py_None;
29857 return resultobj;
29858 fail:
29859 return NULL;
29860 }
29861
29862
29863 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29864 PyObject *resultobj;
29865 wxWindow *arg1 = (wxWindow *) 0 ;
29866 PyObject * obj0 = 0 ;
29867 char *kwnames[] = {
29868 (char *) "self", NULL
29869 };
29870
29871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29873 if (SWIG_arg_fail(1)) SWIG_fail;
29874 {
29875 PyThreadState* __tstate = wxPyBeginAllowThreads();
29876 (arg1)->Thaw();
29877
29878 wxPyEndAllowThreads(__tstate);
29879 if (PyErr_Occurred()) SWIG_fail;
29880 }
29881 Py_INCREF(Py_None); resultobj = Py_None;
29882 return resultobj;
29883 fail:
29884 return NULL;
29885 }
29886
29887
29888 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29889 PyObject *resultobj;
29890 wxWindow *arg1 = (wxWindow *) 0 ;
29891 wxDC *arg2 = 0 ;
29892 PyObject * obj0 = 0 ;
29893 PyObject * obj1 = 0 ;
29894 char *kwnames[] = {
29895 (char *) "self",(char *) "dc", NULL
29896 };
29897
29898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29900 if (SWIG_arg_fail(1)) SWIG_fail;
29901 {
29902 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29903 if (SWIG_arg_fail(2)) SWIG_fail;
29904 if (arg2 == NULL) {
29905 SWIG_null_ref("wxDC");
29906 }
29907 if (SWIG_arg_fail(2)) SWIG_fail;
29908 }
29909 {
29910 PyThreadState* __tstate = wxPyBeginAllowThreads();
29911 (arg1)->PrepareDC(*arg2);
29912
29913 wxPyEndAllowThreads(__tstate);
29914 if (PyErr_Occurred()) SWIG_fail;
29915 }
29916 Py_INCREF(Py_None); resultobj = Py_None;
29917 return resultobj;
29918 fail:
29919 return NULL;
29920 }
29921
29922
29923 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29924 PyObject *resultobj;
29925 wxWindow *arg1 = (wxWindow *) 0 ;
29926 wxRegion *result;
29927 PyObject * obj0 = 0 ;
29928 char *kwnames[] = {
29929 (char *) "self", NULL
29930 };
29931
29932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29934 if (SWIG_arg_fail(1)) SWIG_fail;
29935 {
29936 PyThreadState* __tstate = wxPyBeginAllowThreads();
29937 {
29938 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29939 result = (wxRegion *) &_result_ref;
29940 }
29941
29942 wxPyEndAllowThreads(__tstate);
29943 if (PyErr_Occurred()) SWIG_fail;
29944 }
29945 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29946 return resultobj;
29947 fail:
29948 return NULL;
29949 }
29950
29951
29952 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29953 PyObject *resultobj;
29954 wxWindow *arg1 = (wxWindow *) 0 ;
29955 wxRect result;
29956 PyObject * obj0 = 0 ;
29957 char *kwnames[] = {
29958 (char *) "self", NULL
29959 };
29960
29961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29963 if (SWIG_arg_fail(1)) SWIG_fail;
29964 {
29965 PyThreadState* __tstate = wxPyBeginAllowThreads();
29966 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29967
29968 wxPyEndAllowThreads(__tstate);
29969 if (PyErr_Occurred()) SWIG_fail;
29970 }
29971 {
29972 wxRect * resultptr;
29973 resultptr = new wxRect((wxRect &)(result));
29974 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29975 }
29976 return resultobj;
29977 fail:
29978 return NULL;
29979 }
29980
29981
29982 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29983 PyObject *resultobj;
29984 wxWindow *arg1 = (wxWindow *) 0 ;
29985 int arg2 ;
29986 int arg3 ;
29987 int arg4 = (int) 1 ;
29988 int arg5 = (int) 1 ;
29989 bool result;
29990 PyObject * obj0 = 0 ;
29991 PyObject * obj1 = 0 ;
29992 PyObject * obj2 = 0 ;
29993 PyObject * obj3 = 0 ;
29994 PyObject * obj4 = 0 ;
29995 char *kwnames[] = {
29996 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29997 };
29998
29999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
30000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30001 if (SWIG_arg_fail(1)) SWIG_fail;
30002 {
30003 arg2 = (int)(SWIG_As_int(obj1));
30004 if (SWIG_arg_fail(2)) SWIG_fail;
30005 }
30006 {
30007 arg3 = (int)(SWIG_As_int(obj2));
30008 if (SWIG_arg_fail(3)) SWIG_fail;
30009 }
30010 if (obj3) {
30011 {
30012 arg4 = (int)(SWIG_As_int(obj3));
30013 if (SWIG_arg_fail(4)) SWIG_fail;
30014 }
30015 }
30016 if (obj4) {
30017 {
30018 arg5 = (int)(SWIG_As_int(obj4));
30019 if (SWIG_arg_fail(5)) SWIG_fail;
30020 }
30021 }
30022 {
30023 PyThreadState* __tstate = wxPyBeginAllowThreads();
30024 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
30025
30026 wxPyEndAllowThreads(__tstate);
30027 if (PyErr_Occurred()) SWIG_fail;
30028 }
30029 {
30030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30031 }
30032 return resultobj;
30033 fail:
30034 return NULL;
30035 }
30036
30037
30038 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
30039 PyObject *resultobj;
30040 wxWindow *arg1 = (wxWindow *) 0 ;
30041 wxPoint *arg2 = 0 ;
30042 bool result;
30043 wxPoint temp2 ;
30044 PyObject * obj0 = 0 ;
30045 PyObject * obj1 = 0 ;
30046 char *kwnames[] = {
30047 (char *) "self",(char *) "pt", NULL
30048 };
30049
30050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
30051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30052 if (SWIG_arg_fail(1)) SWIG_fail;
30053 {
30054 arg2 = &temp2;
30055 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30056 }
30057 {
30058 PyThreadState* __tstate = wxPyBeginAllowThreads();
30059 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
30060
30061 wxPyEndAllowThreads(__tstate);
30062 if (PyErr_Occurred()) SWIG_fail;
30063 }
30064 {
30065 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30066 }
30067 return resultobj;
30068 fail:
30069 return NULL;
30070 }
30071
30072
30073 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
30074 PyObject *resultobj;
30075 wxWindow *arg1 = (wxWindow *) 0 ;
30076 wxRect *arg2 = 0 ;
30077 bool result;
30078 wxRect temp2 ;
30079 PyObject * obj0 = 0 ;
30080 PyObject * obj1 = 0 ;
30081 char *kwnames[] = {
30082 (char *) "self",(char *) "rect", NULL
30083 };
30084
30085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
30086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30087 if (SWIG_arg_fail(1)) SWIG_fail;
30088 {
30089 arg2 = &temp2;
30090 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30091 }
30092 {
30093 PyThreadState* __tstate = wxPyBeginAllowThreads();
30094 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
30095
30096 wxPyEndAllowThreads(__tstate);
30097 if (PyErr_Occurred()) SWIG_fail;
30098 }
30099 {
30100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30101 }
30102 return resultobj;
30103 fail:
30104 return NULL;
30105 }
30106
30107
30108 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30109 PyObject *resultobj;
30110 wxWindow *arg1 = (wxWindow *) 0 ;
30111 wxVisualAttributes result;
30112 PyObject * obj0 = 0 ;
30113 char *kwnames[] = {
30114 (char *) "self", NULL
30115 };
30116
30117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
30118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30119 if (SWIG_arg_fail(1)) SWIG_fail;
30120 {
30121 PyThreadState* __tstate = wxPyBeginAllowThreads();
30122 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
30123
30124 wxPyEndAllowThreads(__tstate);
30125 if (PyErr_Occurred()) SWIG_fail;
30126 }
30127 {
30128 wxVisualAttributes * resultptr;
30129 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
30130 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30131 }
30132 return resultobj;
30133 fail:
30134 return NULL;
30135 }
30136
30137
30138 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
30139 PyObject *resultobj;
30140 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
30141 wxVisualAttributes result;
30142 PyObject * obj0 = 0 ;
30143 char *kwnames[] = {
30144 (char *) "variant", NULL
30145 };
30146
30147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
30148 if (obj0) {
30149 {
30150 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
30151 if (SWIG_arg_fail(1)) SWIG_fail;
30152 }
30153 }
30154 {
30155 if (!wxPyCheckForApp()) SWIG_fail;
30156 PyThreadState* __tstate = wxPyBeginAllowThreads();
30157 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
30158
30159 wxPyEndAllowThreads(__tstate);
30160 if (PyErr_Occurred()) SWIG_fail;
30161 }
30162 {
30163 wxVisualAttributes * resultptr;
30164 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
30165 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
30166 }
30167 return resultobj;
30168 fail:
30169 return NULL;
30170 }
30171
30172
30173 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30174 PyObject *resultobj;
30175 wxWindow *arg1 = (wxWindow *) 0 ;
30176 wxColour *arg2 = 0 ;
30177 bool result;
30178 wxColour temp2 ;
30179 PyObject * obj0 = 0 ;
30180 PyObject * obj1 = 0 ;
30181 char *kwnames[] = {
30182 (char *) "self",(char *) "colour", NULL
30183 };
30184
30185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30187 if (SWIG_arg_fail(1)) SWIG_fail;
30188 {
30189 arg2 = &temp2;
30190 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30191 }
30192 {
30193 PyThreadState* __tstate = wxPyBeginAllowThreads();
30194 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
30195
30196 wxPyEndAllowThreads(__tstate);
30197 if (PyErr_Occurred()) SWIG_fail;
30198 }
30199 {
30200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30201 }
30202 return resultobj;
30203 fail:
30204 return NULL;
30205 }
30206
30207
30208 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30209 PyObject *resultobj;
30210 wxWindow *arg1 = (wxWindow *) 0 ;
30211 wxColour *arg2 = 0 ;
30212 wxColour temp2 ;
30213 PyObject * obj0 = 0 ;
30214 PyObject * obj1 = 0 ;
30215 char *kwnames[] = {
30216 (char *) "self",(char *) "colour", NULL
30217 };
30218
30219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
30220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30221 if (SWIG_arg_fail(1)) SWIG_fail;
30222 {
30223 arg2 = &temp2;
30224 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30225 }
30226 {
30227 PyThreadState* __tstate = wxPyBeginAllowThreads();
30228 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
30229
30230 wxPyEndAllowThreads(__tstate);
30231 if (PyErr_Occurred()) SWIG_fail;
30232 }
30233 Py_INCREF(Py_None); resultobj = Py_None;
30234 return resultobj;
30235 fail:
30236 return NULL;
30237 }
30238
30239
30240 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30241 PyObject *resultobj;
30242 wxWindow *arg1 = (wxWindow *) 0 ;
30243 wxColour *arg2 = 0 ;
30244 bool result;
30245 wxColour temp2 ;
30246 PyObject * obj0 = 0 ;
30247 PyObject * obj1 = 0 ;
30248 char *kwnames[] = {
30249 (char *) "self",(char *) "colour", NULL
30250 };
30251
30252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30254 if (SWIG_arg_fail(1)) SWIG_fail;
30255 {
30256 arg2 = &temp2;
30257 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30258 }
30259 {
30260 PyThreadState* __tstate = wxPyBeginAllowThreads();
30261 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
30262
30263 wxPyEndAllowThreads(__tstate);
30264 if (PyErr_Occurred()) SWIG_fail;
30265 }
30266 {
30267 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30268 }
30269 return resultobj;
30270 fail:
30271 return NULL;
30272 }
30273
30274
30275 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30276 PyObject *resultobj;
30277 wxWindow *arg1 = (wxWindow *) 0 ;
30278 wxColour *arg2 = 0 ;
30279 wxColour temp2 ;
30280 PyObject * obj0 = 0 ;
30281 PyObject * obj1 = 0 ;
30282 char *kwnames[] = {
30283 (char *) "self",(char *) "colour", NULL
30284 };
30285
30286 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
30287 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30288 if (SWIG_arg_fail(1)) SWIG_fail;
30289 {
30290 arg2 = &temp2;
30291 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
30292 }
30293 {
30294 PyThreadState* __tstate = wxPyBeginAllowThreads();
30295 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
30296
30297 wxPyEndAllowThreads(__tstate);
30298 if (PyErr_Occurred()) SWIG_fail;
30299 }
30300 Py_INCREF(Py_None); resultobj = Py_None;
30301 return resultobj;
30302 fail:
30303 return NULL;
30304 }
30305
30306
30307 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30308 PyObject *resultobj;
30309 wxWindow *arg1 = (wxWindow *) 0 ;
30310 wxColour result;
30311 PyObject * obj0 = 0 ;
30312 char *kwnames[] = {
30313 (char *) "self", NULL
30314 };
30315
30316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
30317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30318 if (SWIG_arg_fail(1)) SWIG_fail;
30319 {
30320 PyThreadState* __tstate = wxPyBeginAllowThreads();
30321 result = ((wxWindow const *)arg1)->GetBackgroundColour();
30322
30323 wxPyEndAllowThreads(__tstate);
30324 if (PyErr_Occurred()) SWIG_fail;
30325 }
30326 {
30327 wxColour * resultptr;
30328 resultptr = new wxColour((wxColour &)(result));
30329 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30330 }
30331 return resultobj;
30332 fail:
30333 return NULL;
30334 }
30335
30336
30337 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30338 PyObject *resultobj;
30339 wxWindow *arg1 = (wxWindow *) 0 ;
30340 wxColour result;
30341 PyObject * obj0 = 0 ;
30342 char *kwnames[] = {
30343 (char *) "self", NULL
30344 };
30345
30346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
30347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30348 if (SWIG_arg_fail(1)) SWIG_fail;
30349 {
30350 PyThreadState* __tstate = wxPyBeginAllowThreads();
30351 result = ((wxWindow const *)arg1)->GetForegroundColour();
30352
30353 wxPyEndAllowThreads(__tstate);
30354 if (PyErr_Occurred()) SWIG_fail;
30355 }
30356 {
30357 wxColour * resultptr;
30358 resultptr = new wxColour((wxColour &)(result));
30359 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
30360 }
30361 return resultobj;
30362 fail:
30363 return NULL;
30364 }
30365
30366
30367 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
30368 PyObject *resultobj;
30369 wxWindow *arg1 = (wxWindow *) 0 ;
30370 bool result;
30371 PyObject * obj0 = 0 ;
30372 char *kwnames[] = {
30373 (char *) "self", NULL
30374 };
30375
30376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
30377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30378 if (SWIG_arg_fail(1)) SWIG_fail;
30379 {
30380 PyThreadState* __tstate = wxPyBeginAllowThreads();
30381 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
30382
30383 wxPyEndAllowThreads(__tstate);
30384 if (PyErr_Occurred()) SWIG_fail;
30385 }
30386 {
30387 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30388 }
30389 return resultobj;
30390 fail:
30391 return NULL;
30392 }
30393
30394
30395 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
30396 PyObject *resultobj;
30397 wxWindow *arg1 = (wxWindow *) 0 ;
30398 bool result;
30399 PyObject * obj0 = 0 ;
30400 char *kwnames[] = {
30401 (char *) "self", NULL
30402 };
30403
30404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
30405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30406 if (SWIG_arg_fail(1)) SWIG_fail;
30407 {
30408 PyThreadState* __tstate = wxPyBeginAllowThreads();
30409 result = (bool)((wxWindow const *)arg1)->UseBgCol();
30410
30411 wxPyEndAllowThreads(__tstate);
30412 if (PyErr_Occurred()) SWIG_fail;
30413 }
30414 {
30415 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30416 }
30417 return resultobj;
30418 fail:
30419 return NULL;
30420 }
30421
30422
30423 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30424 PyObject *resultobj;
30425 wxWindow *arg1 = (wxWindow *) 0 ;
30426 wxBackgroundStyle arg2 ;
30427 bool result;
30428 PyObject * obj0 = 0 ;
30429 PyObject * obj1 = 0 ;
30430 char *kwnames[] = {
30431 (char *) "self",(char *) "style", NULL
30432 };
30433
30434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
30435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30436 if (SWIG_arg_fail(1)) SWIG_fail;
30437 {
30438 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
30439 if (SWIG_arg_fail(2)) SWIG_fail;
30440 }
30441 {
30442 PyThreadState* __tstate = wxPyBeginAllowThreads();
30443 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
30444
30445 wxPyEndAllowThreads(__tstate);
30446 if (PyErr_Occurred()) SWIG_fail;
30447 }
30448 {
30449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30450 }
30451 return resultobj;
30452 fail:
30453 return NULL;
30454 }
30455
30456
30457 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
30458 PyObject *resultobj;
30459 wxWindow *arg1 = (wxWindow *) 0 ;
30460 wxBackgroundStyle result;
30461 PyObject * obj0 = 0 ;
30462 char *kwnames[] = {
30463 (char *) "self", NULL
30464 };
30465
30466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
30467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30468 if (SWIG_arg_fail(1)) SWIG_fail;
30469 {
30470 PyThreadState* __tstate = wxPyBeginAllowThreads();
30471 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
30472
30473 wxPyEndAllowThreads(__tstate);
30474 if (PyErr_Occurred()) SWIG_fail;
30475 }
30476 resultobj = SWIG_From_int((result));
30477 return resultobj;
30478 fail:
30479 return NULL;
30480 }
30481
30482
30483 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30484 PyObject *resultobj;
30485 wxWindow *arg1 = (wxWindow *) 0 ;
30486 bool result;
30487 PyObject * obj0 = 0 ;
30488 char *kwnames[] = {
30489 (char *) "self", NULL
30490 };
30491
30492 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30493 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30494 if (SWIG_arg_fail(1)) SWIG_fail;
30495 {
30496 PyThreadState* __tstate = wxPyBeginAllowThreads();
30497 result = (bool)(arg1)->HasTransparentBackground();
30498
30499 wxPyEndAllowThreads(__tstate);
30500 if (PyErr_Occurred()) SWIG_fail;
30501 }
30502 {
30503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30504 }
30505 return resultobj;
30506 fail:
30507 return NULL;
30508 }
30509
30510
30511 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30512 PyObject *resultobj;
30513 wxWindow *arg1 = (wxWindow *) 0 ;
30514 wxCursor *arg2 = 0 ;
30515 bool result;
30516 PyObject * obj0 = 0 ;
30517 PyObject * obj1 = 0 ;
30518 char *kwnames[] = {
30519 (char *) "self",(char *) "cursor", NULL
30520 };
30521
30522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30524 if (SWIG_arg_fail(1)) SWIG_fail;
30525 {
30526 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30527 if (SWIG_arg_fail(2)) SWIG_fail;
30528 if (arg2 == NULL) {
30529 SWIG_null_ref("wxCursor");
30530 }
30531 if (SWIG_arg_fail(2)) SWIG_fail;
30532 }
30533 {
30534 PyThreadState* __tstate = wxPyBeginAllowThreads();
30535 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30536
30537 wxPyEndAllowThreads(__tstate);
30538 if (PyErr_Occurred()) SWIG_fail;
30539 }
30540 {
30541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30542 }
30543 return resultobj;
30544 fail:
30545 return NULL;
30546 }
30547
30548
30549 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30550 PyObject *resultobj;
30551 wxWindow *arg1 = (wxWindow *) 0 ;
30552 wxCursor result;
30553 PyObject * obj0 = 0 ;
30554 char *kwnames[] = {
30555 (char *) "self", NULL
30556 };
30557
30558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
30563 result = (arg1)->GetCursor();
30564
30565 wxPyEndAllowThreads(__tstate);
30566 if (PyErr_Occurred()) SWIG_fail;
30567 }
30568 {
30569 wxCursor * resultptr;
30570 resultptr = new wxCursor((wxCursor &)(result));
30571 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30572 }
30573 return resultobj;
30574 fail:
30575 return NULL;
30576 }
30577
30578
30579 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30580 PyObject *resultobj;
30581 wxWindow *arg1 = (wxWindow *) 0 ;
30582 wxFont *arg2 = 0 ;
30583 bool result;
30584 PyObject * obj0 = 0 ;
30585 PyObject * obj1 = 0 ;
30586 char *kwnames[] = {
30587 (char *) "self",(char *) "font", NULL
30588 };
30589
30590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30592 if (SWIG_arg_fail(1)) SWIG_fail;
30593 {
30594 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30595 if (SWIG_arg_fail(2)) SWIG_fail;
30596 if (arg2 == NULL) {
30597 SWIG_null_ref("wxFont");
30598 }
30599 if (SWIG_arg_fail(2)) SWIG_fail;
30600 }
30601 {
30602 PyThreadState* __tstate = wxPyBeginAllowThreads();
30603 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30604
30605 wxPyEndAllowThreads(__tstate);
30606 if (PyErr_Occurred()) SWIG_fail;
30607 }
30608 {
30609 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30610 }
30611 return resultobj;
30612 fail:
30613 return NULL;
30614 }
30615
30616
30617 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30618 PyObject *resultobj;
30619 wxWindow *arg1 = (wxWindow *) 0 ;
30620 wxFont *arg2 = 0 ;
30621 PyObject * obj0 = 0 ;
30622 PyObject * obj1 = 0 ;
30623 char *kwnames[] = {
30624 (char *) "self",(char *) "font", NULL
30625 };
30626
30627 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30628 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30629 if (SWIG_arg_fail(1)) SWIG_fail;
30630 {
30631 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30632 if (SWIG_arg_fail(2)) SWIG_fail;
30633 if (arg2 == NULL) {
30634 SWIG_null_ref("wxFont");
30635 }
30636 if (SWIG_arg_fail(2)) SWIG_fail;
30637 }
30638 {
30639 PyThreadState* __tstate = wxPyBeginAllowThreads();
30640 (arg1)->SetOwnFont((wxFont const &)*arg2);
30641
30642 wxPyEndAllowThreads(__tstate);
30643 if (PyErr_Occurred()) SWIG_fail;
30644 }
30645 Py_INCREF(Py_None); resultobj = Py_None;
30646 return resultobj;
30647 fail:
30648 return NULL;
30649 }
30650
30651
30652 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30653 PyObject *resultobj;
30654 wxWindow *arg1 = (wxWindow *) 0 ;
30655 wxFont result;
30656 PyObject * obj0 = 0 ;
30657 char *kwnames[] = {
30658 (char *) "self", NULL
30659 };
30660
30661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30663 if (SWIG_arg_fail(1)) SWIG_fail;
30664 {
30665 PyThreadState* __tstate = wxPyBeginAllowThreads();
30666 result = (arg1)->GetFont();
30667
30668 wxPyEndAllowThreads(__tstate);
30669 if (PyErr_Occurred()) SWIG_fail;
30670 }
30671 {
30672 wxFont * resultptr;
30673 resultptr = new wxFont((wxFont &)(result));
30674 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30675 }
30676 return resultobj;
30677 fail:
30678 return NULL;
30679 }
30680
30681
30682 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30683 PyObject *resultobj;
30684 wxWindow *arg1 = (wxWindow *) 0 ;
30685 wxCaret *arg2 = (wxCaret *) 0 ;
30686 PyObject * obj0 = 0 ;
30687 PyObject * obj1 = 0 ;
30688 char *kwnames[] = {
30689 (char *) "self",(char *) "caret", NULL
30690 };
30691
30692 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30693 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30694 if (SWIG_arg_fail(1)) SWIG_fail;
30695 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30696 if (SWIG_arg_fail(2)) SWIG_fail;
30697 {
30698 PyThreadState* __tstate = wxPyBeginAllowThreads();
30699 (arg1)->SetCaret(arg2);
30700
30701 wxPyEndAllowThreads(__tstate);
30702 if (PyErr_Occurred()) SWIG_fail;
30703 }
30704 Py_INCREF(Py_None); resultobj = Py_None;
30705 return resultobj;
30706 fail:
30707 return NULL;
30708 }
30709
30710
30711 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30712 PyObject *resultobj;
30713 wxWindow *arg1 = (wxWindow *) 0 ;
30714 wxCaret *result;
30715 PyObject * obj0 = 0 ;
30716 char *kwnames[] = {
30717 (char *) "self", NULL
30718 };
30719
30720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30722 if (SWIG_arg_fail(1)) SWIG_fail;
30723 {
30724 PyThreadState* __tstate = wxPyBeginAllowThreads();
30725 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30726
30727 wxPyEndAllowThreads(__tstate);
30728 if (PyErr_Occurred()) SWIG_fail;
30729 }
30730 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30731 return resultobj;
30732 fail:
30733 return NULL;
30734 }
30735
30736
30737 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30738 PyObject *resultobj;
30739 wxWindow *arg1 = (wxWindow *) 0 ;
30740 int result;
30741 PyObject * obj0 = 0 ;
30742 char *kwnames[] = {
30743 (char *) "self", NULL
30744 };
30745
30746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30748 if (SWIG_arg_fail(1)) SWIG_fail;
30749 {
30750 PyThreadState* __tstate = wxPyBeginAllowThreads();
30751 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30752
30753 wxPyEndAllowThreads(__tstate);
30754 if (PyErr_Occurred()) SWIG_fail;
30755 }
30756 {
30757 resultobj = SWIG_From_int((int)(result));
30758 }
30759 return resultobj;
30760 fail:
30761 return NULL;
30762 }
30763
30764
30765 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30766 PyObject *resultobj;
30767 wxWindow *arg1 = (wxWindow *) 0 ;
30768 int result;
30769 PyObject * obj0 = 0 ;
30770 char *kwnames[] = {
30771 (char *) "self", NULL
30772 };
30773
30774 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30775 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30776 if (SWIG_arg_fail(1)) SWIG_fail;
30777 {
30778 PyThreadState* __tstate = wxPyBeginAllowThreads();
30779 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30780
30781 wxPyEndAllowThreads(__tstate);
30782 if (PyErr_Occurred()) SWIG_fail;
30783 }
30784 {
30785 resultobj = SWIG_From_int((int)(result));
30786 }
30787 return resultobj;
30788 fail:
30789 return NULL;
30790 }
30791
30792
30793 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30794 PyObject *resultobj;
30795 wxWindow *arg1 = (wxWindow *) 0 ;
30796 wxString *arg2 = 0 ;
30797 int *arg3 = (int *) 0 ;
30798 int *arg4 = (int *) 0 ;
30799 bool temp2 = false ;
30800 int temp3 ;
30801 int res3 = 0 ;
30802 int temp4 ;
30803 int res4 = 0 ;
30804 PyObject * obj0 = 0 ;
30805 PyObject * obj1 = 0 ;
30806 char *kwnames[] = {
30807 (char *) "self",(char *) "string", NULL
30808 };
30809
30810 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30811 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30814 if (SWIG_arg_fail(1)) SWIG_fail;
30815 {
30816 arg2 = wxString_in_helper(obj1);
30817 if (arg2 == NULL) SWIG_fail;
30818 temp2 = true;
30819 }
30820 {
30821 PyThreadState* __tstate = wxPyBeginAllowThreads();
30822 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30823
30824 wxPyEndAllowThreads(__tstate);
30825 if (PyErr_Occurred()) SWIG_fail;
30826 }
30827 Py_INCREF(Py_None); resultobj = Py_None;
30828 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30829 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30830 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30831 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30832 {
30833 if (temp2)
30834 delete arg2;
30835 }
30836 return resultobj;
30837 fail:
30838 {
30839 if (temp2)
30840 delete arg2;
30841 }
30842 return NULL;
30843 }
30844
30845
30846 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30847 PyObject *resultobj;
30848 wxWindow *arg1 = (wxWindow *) 0 ;
30849 wxString *arg2 = 0 ;
30850 int *arg3 = (int *) 0 ;
30851 int *arg4 = (int *) 0 ;
30852 int *arg5 = (int *) 0 ;
30853 int *arg6 = (int *) 0 ;
30854 wxFont *arg7 = (wxFont *) NULL ;
30855 bool temp2 = false ;
30856 int temp3 ;
30857 int res3 = 0 ;
30858 int temp4 ;
30859 int res4 = 0 ;
30860 int temp5 ;
30861 int res5 = 0 ;
30862 int temp6 ;
30863 int res6 = 0 ;
30864 PyObject * obj0 = 0 ;
30865 PyObject * obj1 = 0 ;
30866 PyObject * obj2 = 0 ;
30867 char *kwnames[] = {
30868 (char *) "self",(char *) "string",(char *) "font", NULL
30869 };
30870
30871 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30872 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30873 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30874 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30877 if (SWIG_arg_fail(1)) SWIG_fail;
30878 {
30879 arg2 = wxString_in_helper(obj1);
30880 if (arg2 == NULL) SWIG_fail;
30881 temp2 = true;
30882 }
30883 if (obj2) {
30884 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30885 if (SWIG_arg_fail(7)) SWIG_fail;
30886 }
30887 {
30888 PyThreadState* __tstate = wxPyBeginAllowThreads();
30889 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30890
30891 wxPyEndAllowThreads(__tstate);
30892 if (PyErr_Occurred()) SWIG_fail;
30893 }
30894 Py_INCREF(Py_None); resultobj = Py_None;
30895 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30896 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30897 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30898 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30899 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30900 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30901 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30902 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30903 {
30904 if (temp2)
30905 delete arg2;
30906 }
30907 return resultobj;
30908 fail:
30909 {
30910 if (temp2)
30911 delete arg2;
30912 }
30913 return NULL;
30914 }
30915
30916
30917 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30918 PyObject *resultobj;
30919 wxWindow *arg1 = (wxWindow *) 0 ;
30920 int *arg2 = (int *) 0 ;
30921 int *arg3 = (int *) 0 ;
30922 int temp2 ;
30923 int res2 = 0 ;
30924 int temp3 ;
30925 int res3 = 0 ;
30926 PyObject * obj0 = 0 ;
30927 PyObject * obj1 = 0 ;
30928 PyObject * obj2 = 0 ;
30929 char *kwnames[] = {
30930 (char *) "self",(char *) "x",(char *) "y", NULL
30931 };
30932
30933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30935 if (SWIG_arg_fail(1)) SWIG_fail;
30936 {
30937 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30938 temp2 = SWIG_As_int(obj1);
30939 if (SWIG_arg_fail(2)) SWIG_fail;
30940 arg2 = &temp2;
30941 res2 = SWIG_NEWOBJ;
30942 }
30943 }
30944 {
30945 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30946 temp3 = SWIG_As_int(obj2);
30947 if (SWIG_arg_fail(3)) SWIG_fail;
30948 arg3 = &temp3;
30949 res3 = SWIG_NEWOBJ;
30950 }
30951 }
30952 {
30953 PyThreadState* __tstate = wxPyBeginAllowThreads();
30954 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30955
30956 wxPyEndAllowThreads(__tstate);
30957 if (PyErr_Occurred()) SWIG_fail;
30958 }
30959 Py_INCREF(Py_None); resultobj = Py_None;
30960 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30961 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30962 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30963 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30964 return resultobj;
30965 fail:
30966 return NULL;
30967 }
30968
30969
30970 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30971 PyObject *resultobj;
30972 wxWindow *arg1 = (wxWindow *) 0 ;
30973 int *arg2 = (int *) 0 ;
30974 int *arg3 = (int *) 0 ;
30975 int temp2 ;
30976 int res2 = 0 ;
30977 int temp3 ;
30978 int res3 = 0 ;
30979 PyObject * obj0 = 0 ;
30980 PyObject * obj1 = 0 ;
30981 PyObject * obj2 = 0 ;
30982 char *kwnames[] = {
30983 (char *) "self",(char *) "x",(char *) "y", NULL
30984 };
30985
30986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30988 if (SWIG_arg_fail(1)) SWIG_fail;
30989 {
30990 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30991 temp2 = SWIG_As_int(obj1);
30992 if (SWIG_arg_fail(2)) SWIG_fail;
30993 arg2 = &temp2;
30994 res2 = SWIG_NEWOBJ;
30995 }
30996 }
30997 {
30998 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30999 temp3 = SWIG_As_int(obj2);
31000 if (SWIG_arg_fail(3)) SWIG_fail;
31001 arg3 = &temp3;
31002 res3 = SWIG_NEWOBJ;
31003 }
31004 }
31005 {
31006 PyThreadState* __tstate = wxPyBeginAllowThreads();
31007 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
31008
31009 wxPyEndAllowThreads(__tstate);
31010 if (PyErr_Occurred()) SWIG_fail;
31011 }
31012 Py_INCREF(Py_None); resultobj = Py_None;
31013 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
31014 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
31015 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
31016 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
31017 return resultobj;
31018 fail:
31019 return NULL;
31020 }
31021
31022
31023 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
31024 PyObject *resultobj;
31025 wxWindow *arg1 = (wxWindow *) 0 ;
31026 wxPoint *arg2 = 0 ;
31027 wxPoint result;
31028 wxPoint temp2 ;
31029 PyObject * obj0 = 0 ;
31030 PyObject * obj1 = 0 ;
31031 char *kwnames[] = {
31032 (char *) "self",(char *) "pt", NULL
31033 };
31034
31035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
31036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31037 if (SWIG_arg_fail(1)) SWIG_fail;
31038 {
31039 arg2 = &temp2;
31040 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31041 }
31042 {
31043 PyThreadState* __tstate = wxPyBeginAllowThreads();
31044 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
31045
31046 wxPyEndAllowThreads(__tstate);
31047 if (PyErr_Occurred()) SWIG_fail;
31048 }
31049 {
31050 wxPoint * resultptr;
31051 resultptr = new wxPoint((wxPoint &)(result));
31052 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31053 }
31054 return resultobj;
31055 fail:
31056 return NULL;
31057 }
31058
31059
31060 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
31061 PyObject *resultobj;
31062 wxWindow *arg1 = (wxWindow *) 0 ;
31063 wxPoint *arg2 = 0 ;
31064 wxPoint result;
31065 wxPoint temp2 ;
31066 PyObject * obj0 = 0 ;
31067 PyObject * obj1 = 0 ;
31068 char *kwnames[] = {
31069 (char *) "self",(char *) "pt", NULL
31070 };
31071
31072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) goto fail;
31073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31074 if (SWIG_arg_fail(1)) SWIG_fail;
31075 {
31076 arg2 = &temp2;
31077 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31078 }
31079 {
31080 PyThreadState* __tstate = wxPyBeginAllowThreads();
31081 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
31082
31083 wxPyEndAllowThreads(__tstate);
31084 if (PyErr_Occurred()) SWIG_fail;
31085 }
31086 {
31087 wxPoint * resultptr;
31088 resultptr = new wxPoint((wxPoint &)(result));
31089 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
31090 }
31091 return resultobj;
31092 fail:
31093 return NULL;
31094 }
31095
31096
31097 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
31098 PyObject *resultobj;
31099 wxWindow *arg1 = (wxWindow *) 0 ;
31100 int arg2 ;
31101 int arg3 ;
31102 wxHitTest result;
31103 PyObject * obj0 = 0 ;
31104 PyObject * obj1 = 0 ;
31105 PyObject * obj2 = 0 ;
31106 char *kwnames[] = {
31107 (char *) "self",(char *) "x",(char *) "y", NULL
31108 };
31109
31110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
31111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31112 if (SWIG_arg_fail(1)) SWIG_fail;
31113 {
31114 arg2 = (int)(SWIG_As_int(obj1));
31115 if (SWIG_arg_fail(2)) SWIG_fail;
31116 }
31117 {
31118 arg3 = (int)(SWIG_As_int(obj2));
31119 if (SWIG_arg_fail(3)) SWIG_fail;
31120 }
31121 {
31122 PyThreadState* __tstate = wxPyBeginAllowThreads();
31123 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
31124
31125 wxPyEndAllowThreads(__tstate);
31126 if (PyErr_Occurred()) SWIG_fail;
31127 }
31128 resultobj = SWIG_From_int((result));
31129 return resultobj;
31130 fail:
31131 return NULL;
31132 }
31133
31134
31135 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
31136 PyObject *resultobj;
31137 wxWindow *arg1 = (wxWindow *) 0 ;
31138 wxPoint *arg2 = 0 ;
31139 wxHitTest result;
31140 wxPoint temp2 ;
31141 PyObject * obj0 = 0 ;
31142 PyObject * obj1 = 0 ;
31143 char *kwnames[] = {
31144 (char *) "self",(char *) "pt", NULL
31145 };
31146
31147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
31148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31149 if (SWIG_arg_fail(1)) SWIG_fail;
31150 {
31151 arg2 = &temp2;
31152 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
31153 }
31154 {
31155 PyThreadState* __tstate = wxPyBeginAllowThreads();
31156 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
31157
31158 wxPyEndAllowThreads(__tstate);
31159 if (PyErr_Occurred()) SWIG_fail;
31160 }
31161 resultobj = SWIG_From_int((result));
31162 return resultobj;
31163 fail:
31164 return NULL;
31165 }
31166
31167
31168 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
31169 PyObject *resultobj;
31170 wxWindow *arg1 = (wxWindow *) 0 ;
31171 long arg2 ;
31172 wxBorder result;
31173 PyObject * obj0 = 0 ;
31174 PyObject * obj1 = 0 ;
31175
31176 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
31177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31178 if (SWIG_arg_fail(1)) SWIG_fail;
31179 {
31180 arg2 = (long)(SWIG_As_long(obj1));
31181 if (SWIG_arg_fail(2)) SWIG_fail;
31182 }
31183 {
31184 PyThreadState* __tstate = wxPyBeginAllowThreads();
31185 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
31186
31187 wxPyEndAllowThreads(__tstate);
31188 if (PyErr_Occurred()) SWIG_fail;
31189 }
31190 resultobj = SWIG_From_int((result));
31191 return resultobj;
31192 fail:
31193 return NULL;
31194 }
31195
31196
31197 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
31198 PyObject *resultobj;
31199 wxWindow *arg1 = (wxWindow *) 0 ;
31200 wxBorder result;
31201 PyObject * obj0 = 0 ;
31202
31203 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
31204 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31205 if (SWIG_arg_fail(1)) SWIG_fail;
31206 {
31207 PyThreadState* __tstate = wxPyBeginAllowThreads();
31208 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
31209
31210 wxPyEndAllowThreads(__tstate);
31211 if (PyErr_Occurred()) SWIG_fail;
31212 }
31213 resultobj = SWIG_From_int((result));
31214 return resultobj;
31215 fail:
31216 return NULL;
31217 }
31218
31219
31220 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
31221 int argc;
31222 PyObject *argv[3];
31223 int ii;
31224
31225 argc = PyObject_Length(args);
31226 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
31227 argv[ii] = PyTuple_GetItem(args,ii);
31228 }
31229 if (argc == 1) {
31230 int _v;
31231 {
31232 void *ptr;
31233 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31234 _v = 0;
31235 PyErr_Clear();
31236 } else {
31237 _v = 1;
31238 }
31239 }
31240 if (_v) {
31241 return _wrap_Window_GetBorder__SWIG_1(self,args);
31242 }
31243 }
31244 if (argc == 2) {
31245 int _v;
31246 {
31247 void *ptr;
31248 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
31249 _v = 0;
31250 PyErr_Clear();
31251 } else {
31252 _v = 1;
31253 }
31254 }
31255 if (_v) {
31256 _v = SWIG_Check_long(argv[1]);
31257 if (_v) {
31258 return _wrap_Window_GetBorder__SWIG_0(self,args);
31259 }
31260 }
31261 }
31262
31263 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
31264 return NULL;
31265 }
31266
31267
31268 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
31269 PyObject *resultobj;
31270 wxWindow *arg1 = (wxWindow *) 0 ;
31271 long arg2 = (long) wxUPDATE_UI_NONE ;
31272 PyObject * obj0 = 0 ;
31273 PyObject * obj1 = 0 ;
31274 char *kwnames[] = {
31275 (char *) "self",(char *) "flags", NULL
31276 };
31277
31278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
31279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31280 if (SWIG_arg_fail(1)) SWIG_fail;
31281 if (obj1) {
31282 {
31283 arg2 = (long)(SWIG_As_long(obj1));
31284 if (SWIG_arg_fail(2)) SWIG_fail;
31285 }
31286 }
31287 {
31288 PyThreadState* __tstate = wxPyBeginAllowThreads();
31289 (arg1)->UpdateWindowUI(arg2);
31290
31291 wxPyEndAllowThreads(__tstate);
31292 if (PyErr_Occurred()) SWIG_fail;
31293 }
31294 Py_INCREF(Py_None); resultobj = Py_None;
31295 return resultobj;
31296 fail:
31297 return NULL;
31298 }
31299
31300
31301 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
31302 PyObject *resultobj;
31303 wxWindow *arg1 = (wxWindow *) 0 ;
31304 wxMenu *arg2 = (wxMenu *) 0 ;
31305 int arg3 = (int) -1 ;
31306 int arg4 = (int) -1 ;
31307 bool result;
31308 PyObject * obj0 = 0 ;
31309 PyObject * obj1 = 0 ;
31310 PyObject * obj2 = 0 ;
31311 PyObject * obj3 = 0 ;
31312 char *kwnames[] = {
31313 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
31314 };
31315
31316 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31317 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31318 if (SWIG_arg_fail(1)) SWIG_fail;
31319 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31320 if (SWIG_arg_fail(2)) SWIG_fail;
31321 if (obj2) {
31322 {
31323 arg3 = (int)(SWIG_As_int(obj2));
31324 if (SWIG_arg_fail(3)) SWIG_fail;
31325 }
31326 }
31327 if (obj3) {
31328 {
31329 arg4 = (int)(SWIG_As_int(obj3));
31330 if (SWIG_arg_fail(4)) SWIG_fail;
31331 }
31332 }
31333 {
31334 PyThreadState* __tstate = wxPyBeginAllowThreads();
31335 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
31336
31337 wxPyEndAllowThreads(__tstate);
31338 if (PyErr_Occurred()) SWIG_fail;
31339 }
31340 {
31341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31342 }
31343 return resultobj;
31344 fail:
31345 return NULL;
31346 }
31347
31348
31349 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
31350 PyObject *resultobj;
31351 wxWindow *arg1 = (wxWindow *) 0 ;
31352 wxMenu *arg2 = (wxMenu *) 0 ;
31353 wxPoint const &arg3_defvalue = wxDefaultPosition ;
31354 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
31355 bool result;
31356 wxPoint temp3 ;
31357 PyObject * obj0 = 0 ;
31358 PyObject * obj1 = 0 ;
31359 PyObject * obj2 = 0 ;
31360 char *kwnames[] = {
31361 (char *) "self",(char *) "menu",(char *) "pos", NULL
31362 };
31363
31364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
31365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31366 if (SWIG_arg_fail(1)) SWIG_fail;
31367 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
31368 if (SWIG_arg_fail(2)) SWIG_fail;
31369 if (obj2) {
31370 {
31371 arg3 = &temp3;
31372 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
31373 }
31374 }
31375 {
31376 PyThreadState* __tstate = wxPyBeginAllowThreads();
31377 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
31378
31379 wxPyEndAllowThreads(__tstate);
31380 if (PyErr_Occurred()) SWIG_fail;
31381 }
31382 {
31383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31384 }
31385 return resultobj;
31386 fail:
31387 return NULL;
31388 }
31389
31390
31391 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31392 PyObject *resultobj;
31393 wxWindow *arg1 = (wxWindow *) 0 ;
31394 long result;
31395 PyObject * obj0 = 0 ;
31396 char *kwnames[] = {
31397 (char *) "self", NULL
31398 };
31399
31400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
31401 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31402 if (SWIG_arg_fail(1)) SWIG_fail;
31403 {
31404 PyThreadState* __tstate = wxPyBeginAllowThreads();
31405 result = (long)wxWindow_GetHandle(arg1);
31406
31407 wxPyEndAllowThreads(__tstate);
31408 if (PyErr_Occurred()) SWIG_fail;
31409 }
31410 {
31411 resultobj = SWIG_From_long((long)(result));
31412 }
31413 return resultobj;
31414 fail:
31415 return NULL;
31416 }
31417
31418
31419 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31420 PyObject *resultobj;
31421 wxWindow *arg1 = (wxWindow *) 0 ;
31422 long arg2 ;
31423 PyObject * obj0 = 0 ;
31424 PyObject * obj1 = 0 ;
31425 char *kwnames[] = {
31426 (char *) "self",(char *) "handle", NULL
31427 };
31428
31429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
31430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31431 if (SWIG_arg_fail(1)) SWIG_fail;
31432 {
31433 arg2 = (long)(SWIG_As_long(obj1));
31434 if (SWIG_arg_fail(2)) SWIG_fail;
31435 }
31436 {
31437 PyThreadState* __tstate = wxPyBeginAllowThreads();
31438 wxWindow_AssociateHandle(arg1,arg2);
31439
31440 wxPyEndAllowThreads(__tstate);
31441 if (PyErr_Occurred()) SWIG_fail;
31442 }
31443 Py_INCREF(Py_None); resultobj = Py_None;
31444 return resultobj;
31445 fail:
31446 return NULL;
31447 }
31448
31449
31450 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
31451 PyObject *resultobj;
31452 wxWindow *arg1 = (wxWindow *) 0 ;
31453 PyObject * obj0 = 0 ;
31454 char *kwnames[] = {
31455 (char *) "self", NULL
31456 };
31457
31458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
31459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31460 if (SWIG_arg_fail(1)) SWIG_fail;
31461 {
31462 PyThreadState* __tstate = wxPyBeginAllowThreads();
31463 (arg1)->DissociateHandle();
31464
31465 wxPyEndAllowThreads(__tstate);
31466 if (PyErr_Occurred()) SWIG_fail;
31467 }
31468 Py_INCREF(Py_None); resultobj = Py_None;
31469 return resultobj;
31470 fail:
31471 return NULL;
31472 }
31473
31474
31475 static PyObject *_wrap_Window_OnPaint(PyObject *, PyObject *args, PyObject *kwargs) {
31476 PyObject *resultobj;
31477 wxWindow *arg1 = (wxWindow *) 0 ;
31478 wxPaintEvent *arg2 = 0 ;
31479 PyObject * obj0 = 0 ;
31480 PyObject * obj1 = 0 ;
31481 char *kwnames[] = {
31482 (char *) "self",(char *) "event", NULL
31483 };
31484
31485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) goto fail;
31486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31487 if (SWIG_arg_fail(1)) SWIG_fail;
31488 {
31489 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_EXCEPTION | 0);
31490 if (SWIG_arg_fail(2)) SWIG_fail;
31491 if (arg2 == NULL) {
31492 SWIG_null_ref("wxPaintEvent");
31493 }
31494 if (SWIG_arg_fail(2)) SWIG_fail;
31495 }
31496 {
31497 PyThreadState* __tstate = wxPyBeginAllowThreads();
31498 (arg1)->OnPaint(*arg2);
31499
31500 wxPyEndAllowThreads(__tstate);
31501 if (PyErr_Occurred()) SWIG_fail;
31502 }
31503 Py_INCREF(Py_None); resultobj = Py_None;
31504 return resultobj;
31505 fail:
31506 return NULL;
31507 }
31508
31509
31510 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31511 PyObject *resultobj;
31512 wxWindow *arg1 = (wxWindow *) 0 ;
31513 int arg2 ;
31514 bool result;
31515 PyObject * obj0 = 0 ;
31516 PyObject * obj1 = 0 ;
31517 char *kwnames[] = {
31518 (char *) "self",(char *) "orient", NULL
31519 };
31520
31521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31523 if (SWIG_arg_fail(1)) SWIG_fail;
31524 {
31525 arg2 = (int)(SWIG_As_int(obj1));
31526 if (SWIG_arg_fail(2)) SWIG_fail;
31527 }
31528 {
31529 PyThreadState* __tstate = wxPyBeginAllowThreads();
31530 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31531
31532 wxPyEndAllowThreads(__tstate);
31533 if (PyErr_Occurred()) SWIG_fail;
31534 }
31535 {
31536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31537 }
31538 return resultobj;
31539 fail:
31540 return NULL;
31541 }
31542
31543
31544 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31545 PyObject *resultobj;
31546 wxWindow *arg1 = (wxWindow *) 0 ;
31547 int arg2 ;
31548 int arg3 ;
31549 int arg4 ;
31550 int arg5 ;
31551 bool arg6 = (bool) true ;
31552 PyObject * obj0 = 0 ;
31553 PyObject * obj1 = 0 ;
31554 PyObject * obj2 = 0 ;
31555 PyObject * obj3 = 0 ;
31556 PyObject * obj4 = 0 ;
31557 PyObject * obj5 = 0 ;
31558 char *kwnames[] = {
31559 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31560 };
31561
31562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31564 if (SWIG_arg_fail(1)) SWIG_fail;
31565 {
31566 arg2 = (int)(SWIG_As_int(obj1));
31567 if (SWIG_arg_fail(2)) SWIG_fail;
31568 }
31569 {
31570 arg3 = (int)(SWIG_As_int(obj2));
31571 if (SWIG_arg_fail(3)) SWIG_fail;
31572 }
31573 {
31574 arg4 = (int)(SWIG_As_int(obj3));
31575 if (SWIG_arg_fail(4)) SWIG_fail;
31576 }
31577 {
31578 arg5 = (int)(SWIG_As_int(obj4));
31579 if (SWIG_arg_fail(5)) SWIG_fail;
31580 }
31581 if (obj5) {
31582 {
31583 arg6 = (bool)(SWIG_As_bool(obj5));
31584 if (SWIG_arg_fail(6)) SWIG_fail;
31585 }
31586 }
31587 {
31588 PyThreadState* __tstate = wxPyBeginAllowThreads();
31589 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31590
31591 wxPyEndAllowThreads(__tstate);
31592 if (PyErr_Occurred()) SWIG_fail;
31593 }
31594 Py_INCREF(Py_None); resultobj = Py_None;
31595 return resultobj;
31596 fail:
31597 return NULL;
31598 }
31599
31600
31601 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31602 PyObject *resultobj;
31603 wxWindow *arg1 = (wxWindow *) 0 ;
31604 int arg2 ;
31605 int arg3 ;
31606 bool arg4 = (bool) true ;
31607 PyObject * obj0 = 0 ;
31608 PyObject * obj1 = 0 ;
31609 PyObject * obj2 = 0 ;
31610 PyObject * obj3 = 0 ;
31611 char *kwnames[] = {
31612 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31613 };
31614
31615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31617 if (SWIG_arg_fail(1)) SWIG_fail;
31618 {
31619 arg2 = (int)(SWIG_As_int(obj1));
31620 if (SWIG_arg_fail(2)) SWIG_fail;
31621 }
31622 {
31623 arg3 = (int)(SWIG_As_int(obj2));
31624 if (SWIG_arg_fail(3)) SWIG_fail;
31625 }
31626 if (obj3) {
31627 {
31628 arg4 = (bool)(SWIG_As_bool(obj3));
31629 if (SWIG_arg_fail(4)) SWIG_fail;
31630 }
31631 }
31632 {
31633 PyThreadState* __tstate = wxPyBeginAllowThreads();
31634 (arg1)->SetScrollPos(arg2,arg3,arg4);
31635
31636 wxPyEndAllowThreads(__tstate);
31637 if (PyErr_Occurred()) SWIG_fail;
31638 }
31639 Py_INCREF(Py_None); resultobj = Py_None;
31640 return resultobj;
31641 fail:
31642 return NULL;
31643 }
31644
31645
31646 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31647 PyObject *resultobj;
31648 wxWindow *arg1 = (wxWindow *) 0 ;
31649 int arg2 ;
31650 int result;
31651 PyObject * obj0 = 0 ;
31652 PyObject * obj1 = 0 ;
31653 char *kwnames[] = {
31654 (char *) "self",(char *) "orientation", NULL
31655 };
31656
31657 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31658 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31659 if (SWIG_arg_fail(1)) SWIG_fail;
31660 {
31661 arg2 = (int)(SWIG_As_int(obj1));
31662 if (SWIG_arg_fail(2)) SWIG_fail;
31663 }
31664 {
31665 PyThreadState* __tstate = wxPyBeginAllowThreads();
31666 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31667
31668 wxPyEndAllowThreads(__tstate);
31669 if (PyErr_Occurred()) SWIG_fail;
31670 }
31671 {
31672 resultobj = SWIG_From_int((int)(result));
31673 }
31674 return resultobj;
31675 fail:
31676 return NULL;
31677 }
31678
31679
31680 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31681 PyObject *resultobj;
31682 wxWindow *arg1 = (wxWindow *) 0 ;
31683 int arg2 ;
31684 int result;
31685 PyObject * obj0 = 0 ;
31686 PyObject * obj1 = 0 ;
31687 char *kwnames[] = {
31688 (char *) "self",(char *) "orientation", NULL
31689 };
31690
31691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31692 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31693 if (SWIG_arg_fail(1)) SWIG_fail;
31694 {
31695 arg2 = (int)(SWIG_As_int(obj1));
31696 if (SWIG_arg_fail(2)) SWIG_fail;
31697 }
31698 {
31699 PyThreadState* __tstate = wxPyBeginAllowThreads();
31700 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31701
31702 wxPyEndAllowThreads(__tstate);
31703 if (PyErr_Occurred()) SWIG_fail;
31704 }
31705 {
31706 resultobj = SWIG_From_int((int)(result));
31707 }
31708 return resultobj;
31709 fail:
31710 return NULL;
31711 }
31712
31713
31714 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31715 PyObject *resultobj;
31716 wxWindow *arg1 = (wxWindow *) 0 ;
31717 int arg2 ;
31718 int result;
31719 PyObject * obj0 = 0 ;
31720 PyObject * obj1 = 0 ;
31721 char *kwnames[] = {
31722 (char *) "self",(char *) "orientation", NULL
31723 };
31724
31725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31727 if (SWIG_arg_fail(1)) SWIG_fail;
31728 {
31729 arg2 = (int)(SWIG_As_int(obj1));
31730 if (SWIG_arg_fail(2)) SWIG_fail;
31731 }
31732 {
31733 PyThreadState* __tstate = wxPyBeginAllowThreads();
31734 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31735
31736 wxPyEndAllowThreads(__tstate);
31737 if (PyErr_Occurred()) SWIG_fail;
31738 }
31739 {
31740 resultobj = SWIG_From_int((int)(result));
31741 }
31742 return resultobj;
31743 fail:
31744 return NULL;
31745 }
31746
31747
31748 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31749 PyObject *resultobj;
31750 wxWindow *arg1 = (wxWindow *) 0 ;
31751 int arg2 ;
31752 int arg3 ;
31753 wxRect *arg4 = (wxRect *) NULL ;
31754 PyObject * obj0 = 0 ;
31755 PyObject * obj1 = 0 ;
31756 PyObject * obj2 = 0 ;
31757 PyObject * obj3 = 0 ;
31758 char *kwnames[] = {
31759 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31760 };
31761
31762 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31763 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31764 if (SWIG_arg_fail(1)) SWIG_fail;
31765 {
31766 arg2 = (int)(SWIG_As_int(obj1));
31767 if (SWIG_arg_fail(2)) SWIG_fail;
31768 }
31769 {
31770 arg3 = (int)(SWIG_As_int(obj2));
31771 if (SWIG_arg_fail(3)) SWIG_fail;
31772 }
31773 if (obj3) {
31774 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31775 if (SWIG_arg_fail(4)) SWIG_fail;
31776 }
31777 {
31778 PyThreadState* __tstate = wxPyBeginAllowThreads();
31779 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31780
31781 wxPyEndAllowThreads(__tstate);
31782 if (PyErr_Occurred()) SWIG_fail;
31783 }
31784 Py_INCREF(Py_None); resultobj = Py_None;
31785 return resultobj;
31786 fail:
31787 return NULL;
31788 }
31789
31790
31791 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31792 PyObject *resultobj;
31793 wxWindow *arg1 = (wxWindow *) 0 ;
31794 int arg2 ;
31795 bool result;
31796 PyObject * obj0 = 0 ;
31797 PyObject * obj1 = 0 ;
31798 char *kwnames[] = {
31799 (char *) "self",(char *) "lines", NULL
31800 };
31801
31802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31803 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31804 if (SWIG_arg_fail(1)) SWIG_fail;
31805 {
31806 arg2 = (int)(SWIG_As_int(obj1));
31807 if (SWIG_arg_fail(2)) SWIG_fail;
31808 }
31809 {
31810 PyThreadState* __tstate = wxPyBeginAllowThreads();
31811 result = (bool)(arg1)->ScrollLines(arg2);
31812
31813 wxPyEndAllowThreads(__tstate);
31814 if (PyErr_Occurred()) SWIG_fail;
31815 }
31816 {
31817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31818 }
31819 return resultobj;
31820 fail:
31821 return NULL;
31822 }
31823
31824
31825 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31826 PyObject *resultobj;
31827 wxWindow *arg1 = (wxWindow *) 0 ;
31828 int arg2 ;
31829 bool result;
31830 PyObject * obj0 = 0 ;
31831 PyObject * obj1 = 0 ;
31832 char *kwnames[] = {
31833 (char *) "self",(char *) "pages", NULL
31834 };
31835
31836 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31837 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31838 if (SWIG_arg_fail(1)) SWIG_fail;
31839 {
31840 arg2 = (int)(SWIG_As_int(obj1));
31841 if (SWIG_arg_fail(2)) SWIG_fail;
31842 }
31843 {
31844 PyThreadState* __tstate = wxPyBeginAllowThreads();
31845 result = (bool)(arg1)->ScrollPages(arg2);
31846
31847 wxPyEndAllowThreads(__tstate);
31848 if (PyErr_Occurred()) SWIG_fail;
31849 }
31850 {
31851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31852 }
31853 return resultobj;
31854 fail:
31855 return NULL;
31856 }
31857
31858
31859 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31860 PyObject *resultobj;
31861 wxWindow *arg1 = (wxWindow *) 0 ;
31862 bool result;
31863 PyObject * obj0 = 0 ;
31864 char *kwnames[] = {
31865 (char *) "self", NULL
31866 };
31867
31868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31870 if (SWIG_arg_fail(1)) SWIG_fail;
31871 {
31872 PyThreadState* __tstate = wxPyBeginAllowThreads();
31873 result = (bool)(arg1)->LineUp();
31874
31875 wxPyEndAllowThreads(__tstate);
31876 if (PyErr_Occurred()) SWIG_fail;
31877 }
31878 {
31879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31880 }
31881 return resultobj;
31882 fail:
31883 return NULL;
31884 }
31885
31886
31887 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31888 PyObject *resultobj;
31889 wxWindow *arg1 = (wxWindow *) 0 ;
31890 bool result;
31891 PyObject * obj0 = 0 ;
31892 char *kwnames[] = {
31893 (char *) "self", NULL
31894 };
31895
31896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31898 if (SWIG_arg_fail(1)) SWIG_fail;
31899 {
31900 PyThreadState* __tstate = wxPyBeginAllowThreads();
31901 result = (bool)(arg1)->LineDown();
31902
31903 wxPyEndAllowThreads(__tstate);
31904 if (PyErr_Occurred()) SWIG_fail;
31905 }
31906 {
31907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31908 }
31909 return resultobj;
31910 fail:
31911 return NULL;
31912 }
31913
31914
31915 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31916 PyObject *resultobj;
31917 wxWindow *arg1 = (wxWindow *) 0 ;
31918 bool result;
31919 PyObject * obj0 = 0 ;
31920 char *kwnames[] = {
31921 (char *) "self", NULL
31922 };
31923
31924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31926 if (SWIG_arg_fail(1)) SWIG_fail;
31927 {
31928 PyThreadState* __tstate = wxPyBeginAllowThreads();
31929 result = (bool)(arg1)->PageUp();
31930
31931 wxPyEndAllowThreads(__tstate);
31932 if (PyErr_Occurred()) SWIG_fail;
31933 }
31934 {
31935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31936 }
31937 return resultobj;
31938 fail:
31939 return NULL;
31940 }
31941
31942
31943 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31944 PyObject *resultobj;
31945 wxWindow *arg1 = (wxWindow *) 0 ;
31946 bool result;
31947 PyObject * obj0 = 0 ;
31948 char *kwnames[] = {
31949 (char *) "self", NULL
31950 };
31951
31952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31954 if (SWIG_arg_fail(1)) SWIG_fail;
31955 {
31956 PyThreadState* __tstate = wxPyBeginAllowThreads();
31957 result = (bool)(arg1)->PageDown();
31958
31959 wxPyEndAllowThreads(__tstate);
31960 if (PyErr_Occurred()) SWIG_fail;
31961 }
31962 {
31963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31964 }
31965 return resultobj;
31966 fail:
31967 return NULL;
31968 }
31969
31970
31971 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31972 PyObject *resultobj;
31973 wxWindow *arg1 = (wxWindow *) 0 ;
31974 wxString *arg2 = 0 ;
31975 bool temp2 = false ;
31976 PyObject * obj0 = 0 ;
31977 PyObject * obj1 = 0 ;
31978 char *kwnames[] = {
31979 (char *) "self",(char *) "text", NULL
31980 };
31981
31982 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31983 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31984 if (SWIG_arg_fail(1)) SWIG_fail;
31985 {
31986 arg2 = wxString_in_helper(obj1);
31987 if (arg2 == NULL) SWIG_fail;
31988 temp2 = true;
31989 }
31990 {
31991 PyThreadState* __tstate = wxPyBeginAllowThreads();
31992 (arg1)->SetHelpText((wxString const &)*arg2);
31993
31994 wxPyEndAllowThreads(__tstate);
31995 if (PyErr_Occurred()) SWIG_fail;
31996 }
31997 Py_INCREF(Py_None); resultobj = Py_None;
31998 {
31999 if (temp2)
32000 delete arg2;
32001 }
32002 return resultobj;
32003 fail:
32004 {
32005 if (temp2)
32006 delete arg2;
32007 }
32008 return NULL;
32009 }
32010
32011
32012 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
32013 PyObject *resultobj;
32014 wxWindow *arg1 = (wxWindow *) 0 ;
32015 wxString *arg2 = 0 ;
32016 bool temp2 = false ;
32017 PyObject * obj0 = 0 ;
32018 PyObject * obj1 = 0 ;
32019 char *kwnames[] = {
32020 (char *) "self",(char *) "text", NULL
32021 };
32022
32023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
32024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32025 if (SWIG_arg_fail(1)) SWIG_fail;
32026 {
32027 arg2 = wxString_in_helper(obj1);
32028 if (arg2 == NULL) SWIG_fail;
32029 temp2 = true;
32030 }
32031 {
32032 PyThreadState* __tstate = wxPyBeginAllowThreads();
32033 (arg1)->SetHelpTextForId((wxString const &)*arg2);
32034
32035 wxPyEndAllowThreads(__tstate);
32036 if (PyErr_Occurred()) SWIG_fail;
32037 }
32038 Py_INCREF(Py_None); resultobj = Py_None;
32039 {
32040 if (temp2)
32041 delete arg2;
32042 }
32043 return resultobj;
32044 fail:
32045 {
32046 if (temp2)
32047 delete arg2;
32048 }
32049 return NULL;
32050 }
32051
32052
32053 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
32054 PyObject *resultobj;
32055 wxWindow *arg1 = (wxWindow *) 0 ;
32056 wxString result;
32057 PyObject * obj0 = 0 ;
32058 char *kwnames[] = {
32059 (char *) "self", NULL
32060 };
32061
32062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
32063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32064 if (SWIG_arg_fail(1)) SWIG_fail;
32065 {
32066 PyThreadState* __tstate = wxPyBeginAllowThreads();
32067 result = ((wxWindow const *)arg1)->GetHelpText();
32068
32069 wxPyEndAllowThreads(__tstate);
32070 if (PyErr_Occurred()) SWIG_fail;
32071 }
32072 {
32073 #if wxUSE_UNICODE
32074 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32075 #else
32076 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32077 #endif
32078 }
32079 return resultobj;
32080 fail:
32081 return NULL;
32082 }
32083
32084
32085 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
32086 PyObject *resultobj;
32087 wxWindow *arg1 = (wxWindow *) 0 ;
32088 wxString *arg2 = 0 ;
32089 bool temp2 = false ;
32090 PyObject * obj0 = 0 ;
32091 PyObject * obj1 = 0 ;
32092 char *kwnames[] = {
32093 (char *) "self",(char *) "tip", NULL
32094 };
32095
32096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
32097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32098 if (SWIG_arg_fail(1)) SWIG_fail;
32099 {
32100 arg2 = wxString_in_helper(obj1);
32101 if (arg2 == NULL) SWIG_fail;
32102 temp2 = true;
32103 }
32104 {
32105 PyThreadState* __tstate = wxPyBeginAllowThreads();
32106 (arg1)->SetToolTip((wxString const &)*arg2);
32107
32108 wxPyEndAllowThreads(__tstate);
32109 if (PyErr_Occurred()) SWIG_fail;
32110 }
32111 Py_INCREF(Py_None); resultobj = Py_None;
32112 {
32113 if (temp2)
32114 delete arg2;
32115 }
32116 return resultobj;
32117 fail:
32118 {
32119 if (temp2)
32120 delete arg2;
32121 }
32122 return NULL;
32123 }
32124
32125
32126 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32127 PyObject *resultobj;
32128 wxWindow *arg1 = (wxWindow *) 0 ;
32129 wxToolTip *arg2 = (wxToolTip *) 0 ;
32130 PyObject * obj0 = 0 ;
32131 PyObject * obj1 = 0 ;
32132 char *kwnames[] = {
32133 (char *) "self",(char *) "tip", NULL
32134 };
32135
32136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
32137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32138 if (SWIG_arg_fail(1)) SWIG_fail;
32139 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
32140 if (SWIG_arg_fail(2)) SWIG_fail;
32141 {
32142 PyThreadState* __tstate = wxPyBeginAllowThreads();
32143 (arg1)->SetToolTip(arg2);
32144
32145 wxPyEndAllowThreads(__tstate);
32146 if (PyErr_Occurred()) SWIG_fail;
32147 }
32148 Py_INCREF(Py_None); resultobj = Py_None;
32149 return resultobj;
32150 fail:
32151 return NULL;
32152 }
32153
32154
32155 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
32156 PyObject *resultobj;
32157 wxWindow *arg1 = (wxWindow *) 0 ;
32158 wxToolTip *result;
32159 PyObject * obj0 = 0 ;
32160 char *kwnames[] = {
32161 (char *) "self", NULL
32162 };
32163
32164 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
32165 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32166 if (SWIG_arg_fail(1)) SWIG_fail;
32167 {
32168 PyThreadState* __tstate = wxPyBeginAllowThreads();
32169 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
32170
32171 wxPyEndAllowThreads(__tstate);
32172 if (PyErr_Occurred()) SWIG_fail;
32173 }
32174 {
32175 resultobj = wxPyMake_wxObject(result, 0);
32176 }
32177 return resultobj;
32178 fail:
32179 return NULL;
32180 }
32181
32182
32183 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32184 PyObject *resultobj;
32185 wxWindow *arg1 = (wxWindow *) 0 ;
32186 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
32187 PyObject * obj0 = 0 ;
32188 PyObject * obj1 = 0 ;
32189 char *kwnames[] = {
32190 (char *) "self",(char *) "dropTarget", NULL
32191 };
32192
32193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
32194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32195 if (SWIG_arg_fail(1)) SWIG_fail;
32196 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
32197 if (SWIG_arg_fail(2)) SWIG_fail;
32198 {
32199 PyThreadState* __tstate = wxPyBeginAllowThreads();
32200 (arg1)->SetDropTarget(arg2);
32201
32202 wxPyEndAllowThreads(__tstate);
32203 if (PyErr_Occurred()) SWIG_fail;
32204 }
32205 Py_INCREF(Py_None); resultobj = Py_None;
32206 return resultobj;
32207 fail:
32208 return NULL;
32209 }
32210
32211
32212 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
32213 PyObject *resultobj;
32214 wxWindow *arg1 = (wxWindow *) 0 ;
32215 wxPyDropTarget *result;
32216 PyObject * obj0 = 0 ;
32217 char *kwnames[] = {
32218 (char *) "self", NULL
32219 };
32220
32221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
32222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32223 if (SWIG_arg_fail(1)) SWIG_fail;
32224 {
32225 PyThreadState* __tstate = wxPyBeginAllowThreads();
32226 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
32227
32228 wxPyEndAllowThreads(__tstate);
32229 if (PyErr_Occurred()) SWIG_fail;
32230 }
32231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
32232 return resultobj;
32233 fail:
32234 return NULL;
32235 }
32236
32237
32238 static PyObject *_wrap_Window_DragAcceptFiles(PyObject *, PyObject *args, PyObject *kwargs) {
32239 PyObject *resultobj;
32240 wxWindow *arg1 = (wxWindow *) 0 ;
32241 bool arg2 ;
32242 PyObject * obj0 = 0 ;
32243 PyObject * obj1 = 0 ;
32244 char *kwnames[] = {
32245 (char *) "self",(char *) "accept", NULL
32246 };
32247
32248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) goto fail;
32249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32250 if (SWIG_arg_fail(1)) SWIG_fail;
32251 {
32252 arg2 = (bool)(SWIG_As_bool(obj1));
32253 if (SWIG_arg_fail(2)) SWIG_fail;
32254 }
32255 {
32256 PyThreadState* __tstate = wxPyBeginAllowThreads();
32257 (arg1)->DragAcceptFiles(arg2);
32258
32259 wxPyEndAllowThreads(__tstate);
32260 if (PyErr_Occurred()) SWIG_fail;
32261 }
32262 Py_INCREF(Py_None); resultobj = Py_None;
32263 return resultobj;
32264 fail:
32265 return NULL;
32266 }
32267
32268
32269 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32270 PyObject *resultobj;
32271 wxWindow *arg1 = (wxWindow *) 0 ;
32272 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
32273 PyObject * obj0 = 0 ;
32274 PyObject * obj1 = 0 ;
32275 char *kwnames[] = {
32276 (char *) "self",(char *) "constraints", NULL
32277 };
32278
32279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
32280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32281 if (SWIG_arg_fail(1)) SWIG_fail;
32282 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
32283 if (SWIG_arg_fail(2)) SWIG_fail;
32284 {
32285 PyThreadState* __tstate = wxPyBeginAllowThreads();
32286 (arg1)->SetConstraints(arg2);
32287
32288 wxPyEndAllowThreads(__tstate);
32289 if (PyErr_Occurred()) SWIG_fail;
32290 }
32291 Py_INCREF(Py_None); resultobj = Py_None;
32292 return resultobj;
32293 fail:
32294 return NULL;
32295 }
32296
32297
32298 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
32299 PyObject *resultobj;
32300 wxWindow *arg1 = (wxWindow *) 0 ;
32301 wxLayoutConstraints *result;
32302 PyObject * obj0 = 0 ;
32303 char *kwnames[] = {
32304 (char *) "self", NULL
32305 };
32306
32307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
32308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32309 if (SWIG_arg_fail(1)) SWIG_fail;
32310 {
32311 PyThreadState* __tstate = wxPyBeginAllowThreads();
32312 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
32313
32314 wxPyEndAllowThreads(__tstate);
32315 if (PyErr_Occurred()) SWIG_fail;
32316 }
32317 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
32318 return resultobj;
32319 fail:
32320 return NULL;
32321 }
32322
32323
32324 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32325 PyObject *resultobj;
32326 wxWindow *arg1 = (wxWindow *) 0 ;
32327 bool arg2 ;
32328 PyObject * obj0 = 0 ;
32329 PyObject * obj1 = 0 ;
32330 char *kwnames[] = {
32331 (char *) "self",(char *) "autoLayout", NULL
32332 };
32333
32334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
32335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32336 if (SWIG_arg_fail(1)) SWIG_fail;
32337 {
32338 arg2 = (bool)(SWIG_As_bool(obj1));
32339 if (SWIG_arg_fail(2)) SWIG_fail;
32340 }
32341 {
32342 PyThreadState* __tstate = wxPyBeginAllowThreads();
32343 (arg1)->SetAutoLayout(arg2);
32344
32345 wxPyEndAllowThreads(__tstate);
32346 if (PyErr_Occurred()) SWIG_fail;
32347 }
32348 Py_INCREF(Py_None); resultobj = Py_None;
32349 return resultobj;
32350 fail:
32351 return NULL;
32352 }
32353
32354
32355 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
32356 PyObject *resultobj;
32357 wxWindow *arg1 = (wxWindow *) 0 ;
32358 bool result;
32359 PyObject * obj0 = 0 ;
32360 char *kwnames[] = {
32361 (char *) "self", NULL
32362 };
32363
32364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
32365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32366 if (SWIG_arg_fail(1)) SWIG_fail;
32367 {
32368 PyThreadState* __tstate = wxPyBeginAllowThreads();
32369 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
32370
32371 wxPyEndAllowThreads(__tstate);
32372 if (PyErr_Occurred()) SWIG_fail;
32373 }
32374 {
32375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32376 }
32377 return resultobj;
32378 fail:
32379 return NULL;
32380 }
32381
32382
32383 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
32384 PyObject *resultobj;
32385 wxWindow *arg1 = (wxWindow *) 0 ;
32386 bool result;
32387 PyObject * obj0 = 0 ;
32388 char *kwnames[] = {
32389 (char *) "self", NULL
32390 };
32391
32392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
32393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32394 if (SWIG_arg_fail(1)) SWIG_fail;
32395 {
32396 PyThreadState* __tstate = wxPyBeginAllowThreads();
32397 result = (bool)(arg1)->Layout();
32398
32399 wxPyEndAllowThreads(__tstate);
32400 if (PyErr_Occurred()) SWIG_fail;
32401 }
32402 {
32403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32404 }
32405 return resultobj;
32406 fail:
32407 return NULL;
32408 }
32409
32410
32411 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32412 PyObject *resultobj;
32413 wxWindow *arg1 = (wxWindow *) 0 ;
32414 wxSizer *arg2 = (wxSizer *) 0 ;
32415 bool arg3 = (bool) true ;
32416 PyObject * obj0 = 0 ;
32417 PyObject * obj1 = 0 ;
32418 PyObject * obj2 = 0 ;
32419 char *kwnames[] = {
32420 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32421 };
32422
32423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
32424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32425 if (SWIG_arg_fail(1)) SWIG_fail;
32426 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32427 if (SWIG_arg_fail(2)) SWIG_fail;
32428 if (obj2) {
32429 {
32430 arg3 = (bool)(SWIG_As_bool(obj2));
32431 if (SWIG_arg_fail(3)) SWIG_fail;
32432 }
32433 }
32434 {
32435 PyThreadState* __tstate = wxPyBeginAllowThreads();
32436 (arg1)->SetSizer(arg2,arg3);
32437
32438 wxPyEndAllowThreads(__tstate);
32439 if (PyErr_Occurred()) SWIG_fail;
32440 }
32441 Py_INCREF(Py_None); resultobj = Py_None;
32442 return resultobj;
32443 fail:
32444 return NULL;
32445 }
32446
32447
32448 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
32449 PyObject *resultobj;
32450 wxWindow *arg1 = (wxWindow *) 0 ;
32451 wxSizer *arg2 = (wxSizer *) 0 ;
32452 bool arg3 = (bool) true ;
32453 PyObject * obj0 = 0 ;
32454 PyObject * obj1 = 0 ;
32455 PyObject * obj2 = 0 ;
32456 char *kwnames[] = {
32457 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
32458 };
32459
32460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
32461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32462 if (SWIG_arg_fail(1)) SWIG_fail;
32463 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32464 if (SWIG_arg_fail(2)) SWIG_fail;
32465 if (obj2) {
32466 {
32467 arg3 = (bool)(SWIG_As_bool(obj2));
32468 if (SWIG_arg_fail(3)) SWIG_fail;
32469 }
32470 }
32471 {
32472 PyThreadState* __tstate = wxPyBeginAllowThreads();
32473 (arg1)->SetSizerAndFit(arg2,arg3);
32474
32475 wxPyEndAllowThreads(__tstate);
32476 if (PyErr_Occurred()) SWIG_fail;
32477 }
32478 Py_INCREF(Py_None); resultobj = Py_None;
32479 return resultobj;
32480 fail:
32481 return NULL;
32482 }
32483
32484
32485 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32486 PyObject *resultobj;
32487 wxWindow *arg1 = (wxWindow *) 0 ;
32488 wxSizer *result;
32489 PyObject * obj0 = 0 ;
32490 char *kwnames[] = {
32491 (char *) "self", NULL
32492 };
32493
32494 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
32495 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32496 if (SWIG_arg_fail(1)) SWIG_fail;
32497 {
32498 PyThreadState* __tstate = wxPyBeginAllowThreads();
32499 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
32500
32501 wxPyEndAllowThreads(__tstate);
32502 if (PyErr_Occurred()) SWIG_fail;
32503 }
32504 {
32505 resultobj = wxPyMake_wxObject(result, 0);
32506 }
32507 return resultobj;
32508 fail:
32509 return NULL;
32510 }
32511
32512
32513 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32514 PyObject *resultobj;
32515 wxWindow *arg1 = (wxWindow *) 0 ;
32516 wxSizer *arg2 = (wxSizer *) 0 ;
32517 PyObject * obj0 = 0 ;
32518 PyObject * obj1 = 0 ;
32519 char *kwnames[] = {
32520 (char *) "self",(char *) "sizer", NULL
32521 };
32522
32523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
32524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32525 if (SWIG_arg_fail(1)) SWIG_fail;
32526 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
32527 if (SWIG_arg_fail(2)) SWIG_fail;
32528 {
32529 PyThreadState* __tstate = wxPyBeginAllowThreads();
32530 (arg1)->SetContainingSizer(arg2);
32531
32532 wxPyEndAllowThreads(__tstate);
32533 if (PyErr_Occurred()) SWIG_fail;
32534 }
32535 Py_INCREF(Py_None); resultobj = Py_None;
32536 return resultobj;
32537 fail:
32538 return NULL;
32539 }
32540
32541
32542 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
32543 PyObject *resultobj;
32544 wxWindow *arg1 = (wxWindow *) 0 ;
32545 wxSizer *result;
32546 PyObject * obj0 = 0 ;
32547 char *kwnames[] = {
32548 (char *) "self", NULL
32549 };
32550
32551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32553 if (SWIG_arg_fail(1)) SWIG_fail;
32554 {
32555 PyThreadState* __tstate = wxPyBeginAllowThreads();
32556 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32557
32558 wxPyEndAllowThreads(__tstate);
32559 if (PyErr_Occurred()) SWIG_fail;
32560 }
32561 {
32562 resultobj = wxPyMake_wxObject(result, 0);
32563 }
32564 return resultobj;
32565 fail:
32566 return NULL;
32567 }
32568
32569
32570 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32571 PyObject *resultobj;
32572 wxWindow *arg1 = (wxWindow *) 0 ;
32573 PyObject * obj0 = 0 ;
32574 char *kwnames[] = {
32575 (char *) "self", NULL
32576 };
32577
32578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32580 if (SWIG_arg_fail(1)) SWIG_fail;
32581 {
32582 PyThreadState* __tstate = wxPyBeginAllowThreads();
32583 (arg1)->InheritAttributes();
32584
32585 wxPyEndAllowThreads(__tstate);
32586 if (PyErr_Occurred()) SWIG_fail;
32587 }
32588 Py_INCREF(Py_None); resultobj = Py_None;
32589 return resultobj;
32590 fail:
32591 return NULL;
32592 }
32593
32594
32595 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32596 PyObject *resultobj;
32597 wxWindow *arg1 = (wxWindow *) 0 ;
32598 bool result;
32599 PyObject * obj0 = 0 ;
32600 char *kwnames[] = {
32601 (char *) "self", NULL
32602 };
32603
32604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32606 if (SWIG_arg_fail(1)) SWIG_fail;
32607 {
32608 PyThreadState* __tstate = wxPyBeginAllowThreads();
32609 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32610
32611 wxPyEndAllowThreads(__tstate);
32612 if (PyErr_Occurred()) SWIG_fail;
32613 }
32614 {
32615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32616 }
32617 return resultobj;
32618 fail:
32619 return NULL;
32620 }
32621
32622
32623 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32624 PyObject *obj;
32625 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32626 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32627 Py_INCREF(obj);
32628 return Py_BuildValue((char *)"");
32629 }
32630 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32631 PyObject *resultobj;
32632 long arg1 ;
32633 wxWindow *arg2 = (wxWindow *) NULL ;
32634 wxWindow *result;
32635 PyObject * obj0 = 0 ;
32636 PyObject * obj1 = 0 ;
32637 char *kwnames[] = {
32638 (char *) "id",(char *) "parent", NULL
32639 };
32640
32641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32642 {
32643 arg1 = (long)(SWIG_As_long(obj0));
32644 if (SWIG_arg_fail(1)) SWIG_fail;
32645 }
32646 if (obj1) {
32647 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32648 if (SWIG_arg_fail(2)) SWIG_fail;
32649 }
32650 {
32651 if (!wxPyCheckForApp()) SWIG_fail;
32652 PyThreadState* __tstate = wxPyBeginAllowThreads();
32653 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32654
32655 wxPyEndAllowThreads(__tstate);
32656 if (PyErr_Occurred()) SWIG_fail;
32657 }
32658 {
32659 resultobj = wxPyMake_wxObject(result, 0);
32660 }
32661 return resultobj;
32662 fail:
32663 return NULL;
32664 }
32665
32666
32667 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32668 PyObject *resultobj;
32669 wxString *arg1 = 0 ;
32670 wxWindow *arg2 = (wxWindow *) NULL ;
32671 wxWindow *result;
32672 bool temp1 = false ;
32673 PyObject * obj0 = 0 ;
32674 PyObject * obj1 = 0 ;
32675 char *kwnames[] = {
32676 (char *) "name",(char *) "parent", NULL
32677 };
32678
32679 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32680 {
32681 arg1 = wxString_in_helper(obj0);
32682 if (arg1 == NULL) SWIG_fail;
32683 temp1 = true;
32684 }
32685 if (obj1) {
32686 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32687 if (SWIG_arg_fail(2)) SWIG_fail;
32688 }
32689 {
32690 if (!wxPyCheckForApp()) SWIG_fail;
32691 PyThreadState* __tstate = wxPyBeginAllowThreads();
32692 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32693
32694 wxPyEndAllowThreads(__tstate);
32695 if (PyErr_Occurred()) SWIG_fail;
32696 }
32697 {
32698 resultobj = wxPyMake_wxObject(result, 0);
32699 }
32700 {
32701 if (temp1)
32702 delete arg1;
32703 }
32704 return resultobj;
32705 fail:
32706 {
32707 if (temp1)
32708 delete arg1;
32709 }
32710 return NULL;
32711 }
32712
32713
32714 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32715 PyObject *resultobj;
32716 wxString *arg1 = 0 ;
32717 wxWindow *arg2 = (wxWindow *) NULL ;
32718 wxWindow *result;
32719 bool temp1 = false ;
32720 PyObject * obj0 = 0 ;
32721 PyObject * obj1 = 0 ;
32722 char *kwnames[] = {
32723 (char *) "label",(char *) "parent", NULL
32724 };
32725
32726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32727 {
32728 arg1 = wxString_in_helper(obj0);
32729 if (arg1 == NULL) SWIG_fail;
32730 temp1 = true;
32731 }
32732 if (obj1) {
32733 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32734 if (SWIG_arg_fail(2)) SWIG_fail;
32735 }
32736 {
32737 if (!wxPyCheckForApp()) SWIG_fail;
32738 PyThreadState* __tstate = wxPyBeginAllowThreads();
32739 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32740
32741 wxPyEndAllowThreads(__tstate);
32742 if (PyErr_Occurred()) SWIG_fail;
32743 }
32744 {
32745 resultobj = wxPyMake_wxObject(result, 0);
32746 }
32747 {
32748 if (temp1)
32749 delete arg1;
32750 }
32751 return resultobj;
32752 fail:
32753 {
32754 if (temp1)
32755 delete arg1;
32756 }
32757 return NULL;
32758 }
32759
32760
32761 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32762 PyObject *resultobj;
32763 wxWindow *arg1 = (wxWindow *) 0 ;
32764 unsigned long arg2 ;
32765 wxWindow *result;
32766 PyObject * obj0 = 0 ;
32767 PyObject * obj1 = 0 ;
32768 char *kwnames[] = {
32769 (char *) "parent",(char *) "_hWnd", NULL
32770 };
32771
32772 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32773 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32774 if (SWIG_arg_fail(1)) SWIG_fail;
32775 {
32776 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32777 if (SWIG_arg_fail(2)) SWIG_fail;
32778 }
32779 {
32780 PyThreadState* __tstate = wxPyBeginAllowThreads();
32781 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32782
32783 wxPyEndAllowThreads(__tstate);
32784 if (PyErr_Occurred()) SWIG_fail;
32785 }
32786 {
32787 resultobj = wxPyMake_wxObject(result, 0);
32788 }
32789 return resultobj;
32790 fail:
32791 return NULL;
32792 }
32793
32794
32795 static PyObject *_wrap_GetTopLevelWindows(PyObject *, PyObject *args, PyObject *kwargs) {
32796 PyObject *resultobj;
32797 PyObject *result;
32798 char *kwnames[] = {
32799 NULL
32800 };
32801
32802 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetTopLevelWindows",kwnames)) goto fail;
32803 {
32804 PyThreadState* __tstate = wxPyBeginAllowThreads();
32805 result = (PyObject *)GetTopLevelWindows();
32806
32807 wxPyEndAllowThreads(__tstate);
32808 if (PyErr_Occurred()) SWIG_fail;
32809 }
32810 resultobj = result;
32811 return resultobj;
32812 fail:
32813 return NULL;
32814 }
32815
32816
32817 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32818 PyObject *resultobj;
32819 wxValidator *result;
32820 char *kwnames[] = {
32821 NULL
32822 };
32823
32824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32825 {
32826 PyThreadState* __tstate = wxPyBeginAllowThreads();
32827 result = (wxValidator *)new wxValidator();
32828
32829 wxPyEndAllowThreads(__tstate);
32830 if (PyErr_Occurred()) SWIG_fail;
32831 }
32832 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32833 return resultobj;
32834 fail:
32835 return NULL;
32836 }
32837
32838
32839 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32840 PyObject *resultobj;
32841 wxValidator *arg1 = (wxValidator *) 0 ;
32842 wxValidator *result;
32843 PyObject * obj0 = 0 ;
32844 char *kwnames[] = {
32845 (char *) "self", NULL
32846 };
32847
32848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32850 if (SWIG_arg_fail(1)) SWIG_fail;
32851 {
32852 PyThreadState* __tstate = wxPyBeginAllowThreads();
32853 result = (wxValidator *)(arg1)->Clone();
32854
32855 wxPyEndAllowThreads(__tstate);
32856 if (PyErr_Occurred()) SWIG_fail;
32857 }
32858 {
32859 resultobj = wxPyMake_wxObject(result, 0);
32860 }
32861 return resultobj;
32862 fail:
32863 return NULL;
32864 }
32865
32866
32867 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32868 PyObject *resultobj;
32869 wxValidator *arg1 = (wxValidator *) 0 ;
32870 wxWindow *arg2 = (wxWindow *) 0 ;
32871 bool result;
32872 PyObject * obj0 = 0 ;
32873 PyObject * obj1 = 0 ;
32874 char *kwnames[] = {
32875 (char *) "self",(char *) "parent", NULL
32876 };
32877
32878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32880 if (SWIG_arg_fail(1)) SWIG_fail;
32881 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32882 if (SWIG_arg_fail(2)) SWIG_fail;
32883 {
32884 PyThreadState* __tstate = wxPyBeginAllowThreads();
32885 result = (bool)(arg1)->Validate(arg2);
32886
32887 wxPyEndAllowThreads(__tstate);
32888 if (PyErr_Occurred()) SWIG_fail;
32889 }
32890 {
32891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32892 }
32893 return resultobj;
32894 fail:
32895 return NULL;
32896 }
32897
32898
32899 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32900 PyObject *resultobj;
32901 wxValidator *arg1 = (wxValidator *) 0 ;
32902 bool result;
32903 PyObject * obj0 = 0 ;
32904 char *kwnames[] = {
32905 (char *) "self", NULL
32906 };
32907
32908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32910 if (SWIG_arg_fail(1)) SWIG_fail;
32911 {
32912 PyThreadState* __tstate = wxPyBeginAllowThreads();
32913 result = (bool)(arg1)->TransferToWindow();
32914
32915 wxPyEndAllowThreads(__tstate);
32916 if (PyErr_Occurred()) SWIG_fail;
32917 }
32918 {
32919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32920 }
32921 return resultobj;
32922 fail:
32923 return NULL;
32924 }
32925
32926
32927 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32928 PyObject *resultobj;
32929 wxValidator *arg1 = (wxValidator *) 0 ;
32930 bool result;
32931 PyObject * obj0 = 0 ;
32932 char *kwnames[] = {
32933 (char *) "self", NULL
32934 };
32935
32936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32937 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32938 if (SWIG_arg_fail(1)) SWIG_fail;
32939 {
32940 PyThreadState* __tstate = wxPyBeginAllowThreads();
32941 result = (bool)(arg1)->TransferFromWindow();
32942
32943 wxPyEndAllowThreads(__tstate);
32944 if (PyErr_Occurred()) SWIG_fail;
32945 }
32946 {
32947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32948 }
32949 return resultobj;
32950 fail:
32951 return NULL;
32952 }
32953
32954
32955 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32956 PyObject *resultobj;
32957 wxValidator *arg1 = (wxValidator *) 0 ;
32958 wxWindow *result;
32959 PyObject * obj0 = 0 ;
32960 char *kwnames[] = {
32961 (char *) "self", NULL
32962 };
32963
32964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32965 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32966 if (SWIG_arg_fail(1)) SWIG_fail;
32967 {
32968 PyThreadState* __tstate = wxPyBeginAllowThreads();
32969 result = (wxWindow *)(arg1)->GetWindow();
32970
32971 wxPyEndAllowThreads(__tstate);
32972 if (PyErr_Occurred()) SWIG_fail;
32973 }
32974 {
32975 resultobj = wxPyMake_wxObject(result, 0);
32976 }
32977 return resultobj;
32978 fail:
32979 return NULL;
32980 }
32981
32982
32983 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32984 PyObject *resultobj;
32985 wxValidator *arg1 = (wxValidator *) 0 ;
32986 wxWindow *arg2 = (wxWindow *) 0 ;
32987 PyObject * obj0 = 0 ;
32988 PyObject * obj1 = 0 ;
32989 char *kwnames[] = {
32990 (char *) "self",(char *) "window", NULL
32991 };
32992
32993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32994 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32995 if (SWIG_arg_fail(1)) SWIG_fail;
32996 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32997 if (SWIG_arg_fail(2)) SWIG_fail;
32998 {
32999 PyThreadState* __tstate = wxPyBeginAllowThreads();
33000 (arg1)->SetWindow(arg2);
33001
33002 wxPyEndAllowThreads(__tstate);
33003 if (PyErr_Occurred()) SWIG_fail;
33004 }
33005 Py_INCREF(Py_None); resultobj = Py_None;
33006 return resultobj;
33007 fail:
33008 return NULL;
33009 }
33010
33011
33012 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
33013 PyObject *resultobj;
33014 bool result;
33015 char *kwnames[] = {
33016 NULL
33017 };
33018
33019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
33020 {
33021 PyThreadState* __tstate = wxPyBeginAllowThreads();
33022 result = (bool)wxValidator::IsSilent();
33023
33024 wxPyEndAllowThreads(__tstate);
33025 if (PyErr_Occurred()) SWIG_fail;
33026 }
33027 {
33028 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33029 }
33030 return resultobj;
33031 fail:
33032 return NULL;
33033 }
33034
33035
33036 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
33037 PyObject *resultobj;
33038 int arg1 = (int) true ;
33039 PyObject * obj0 = 0 ;
33040 char *kwnames[] = {
33041 (char *) "doIt", NULL
33042 };
33043
33044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
33045 if (obj0) {
33046 {
33047 arg1 = (int)(SWIG_As_int(obj0));
33048 if (SWIG_arg_fail(1)) SWIG_fail;
33049 }
33050 }
33051 {
33052 PyThreadState* __tstate = wxPyBeginAllowThreads();
33053 wxValidator::SetBellOnError(arg1);
33054
33055 wxPyEndAllowThreads(__tstate);
33056 if (PyErr_Occurred()) SWIG_fail;
33057 }
33058 Py_INCREF(Py_None); resultobj = Py_None;
33059 return resultobj;
33060 fail:
33061 return NULL;
33062 }
33063
33064
33065 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
33066 PyObject *obj;
33067 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33068 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
33069 Py_INCREF(obj);
33070 return Py_BuildValue((char *)"");
33071 }
33072 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
33073 PyObject *resultobj;
33074 wxPyValidator *result;
33075 char *kwnames[] = {
33076 NULL
33077 };
33078
33079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
33080 {
33081 PyThreadState* __tstate = wxPyBeginAllowThreads();
33082 result = (wxPyValidator *)new wxPyValidator();
33083
33084 wxPyEndAllowThreads(__tstate);
33085 if (PyErr_Occurred()) SWIG_fail;
33086 }
33087 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
33088 return resultobj;
33089 fail:
33090 return NULL;
33091 }
33092
33093
33094 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
33095 PyObject *resultobj;
33096 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
33097 PyObject *arg2 = (PyObject *) 0 ;
33098 PyObject *arg3 = (PyObject *) 0 ;
33099 int arg4 = (int) true ;
33100 PyObject * obj0 = 0 ;
33101 PyObject * obj1 = 0 ;
33102 PyObject * obj2 = 0 ;
33103 PyObject * obj3 = 0 ;
33104 char *kwnames[] = {
33105 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
33106 };
33107
33108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
33110 if (SWIG_arg_fail(1)) SWIG_fail;
33111 arg2 = obj1;
33112 arg3 = obj2;
33113 if (obj3) {
33114 {
33115 arg4 = (int)(SWIG_As_int(obj3));
33116 if (SWIG_arg_fail(4)) SWIG_fail;
33117 }
33118 }
33119 {
33120 PyThreadState* __tstate = wxPyBeginAllowThreads();
33121 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
33122
33123 wxPyEndAllowThreads(__tstate);
33124 if (PyErr_Occurred()) SWIG_fail;
33125 }
33126 Py_INCREF(Py_None); resultobj = Py_None;
33127 return resultobj;
33128 fail:
33129 return NULL;
33130 }
33131
33132
33133 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
33134 PyObject *obj;
33135 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
33136 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
33137 Py_INCREF(obj);
33138 return Py_BuildValue((char *)"");
33139 }
33140 static int _wrap_DefaultValidator_set(PyObject *) {
33141 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
33142 return 1;
33143 }
33144
33145
33146 static PyObject *_wrap_DefaultValidator_get(void) {
33147 PyObject *pyobj;
33148
33149 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
33150 return pyobj;
33151 }
33152
33153
33154 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
33155 PyObject *resultobj;
33156 wxString const &arg1_defvalue = wxPyEmptyString ;
33157 wxString *arg1 = (wxString *) &arg1_defvalue ;
33158 long arg2 = (long) 0 ;
33159 wxMenu *result;
33160 bool temp1 = false ;
33161 PyObject * obj0 = 0 ;
33162 PyObject * obj1 = 0 ;
33163 char *kwnames[] = {
33164 (char *) "title",(char *) "style", NULL
33165 };
33166
33167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
33168 if (obj0) {
33169 {
33170 arg1 = wxString_in_helper(obj0);
33171 if (arg1 == NULL) SWIG_fail;
33172 temp1 = true;
33173 }
33174 }
33175 if (obj1) {
33176 {
33177 arg2 = (long)(SWIG_As_long(obj1));
33178 if (SWIG_arg_fail(2)) SWIG_fail;
33179 }
33180 }
33181 {
33182 if (!wxPyCheckForApp()) SWIG_fail;
33183 PyThreadState* __tstate = wxPyBeginAllowThreads();
33184 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
33185
33186 wxPyEndAllowThreads(__tstate);
33187 if (PyErr_Occurred()) SWIG_fail;
33188 }
33189 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
33190 {
33191 if (temp1)
33192 delete arg1;
33193 }
33194 return resultobj;
33195 fail:
33196 {
33197 if (temp1)
33198 delete arg1;
33199 }
33200 return NULL;
33201 }
33202
33203
33204 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
33205 PyObject *resultobj;
33206 wxMenu *arg1 = (wxMenu *) 0 ;
33207 int arg2 ;
33208 wxString *arg3 = 0 ;
33209 wxString const &arg4_defvalue = wxPyEmptyString ;
33210 wxString *arg4 = (wxString *) &arg4_defvalue ;
33211 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33212 wxMenuItem *result;
33213 bool temp3 = false ;
33214 bool temp4 = false ;
33215 PyObject * obj0 = 0 ;
33216 PyObject * obj1 = 0 ;
33217 PyObject * obj2 = 0 ;
33218 PyObject * obj3 = 0 ;
33219 PyObject * obj4 = 0 ;
33220 char *kwnames[] = {
33221 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33222 };
33223
33224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33226 if (SWIG_arg_fail(1)) SWIG_fail;
33227 {
33228 arg2 = (int)(SWIG_As_int(obj1));
33229 if (SWIG_arg_fail(2)) SWIG_fail;
33230 }
33231 {
33232 arg3 = wxString_in_helper(obj2);
33233 if (arg3 == NULL) SWIG_fail;
33234 temp3 = true;
33235 }
33236 if (obj3) {
33237 {
33238 arg4 = wxString_in_helper(obj3);
33239 if (arg4 == NULL) SWIG_fail;
33240 temp4 = true;
33241 }
33242 }
33243 if (obj4) {
33244 {
33245 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33246 if (SWIG_arg_fail(5)) SWIG_fail;
33247 }
33248 }
33249 {
33250 PyThreadState* __tstate = wxPyBeginAllowThreads();
33251 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33252
33253 wxPyEndAllowThreads(__tstate);
33254 if (PyErr_Occurred()) SWIG_fail;
33255 }
33256 {
33257 resultobj = wxPyMake_wxObject(result, 0);
33258 }
33259 {
33260 if (temp3)
33261 delete arg3;
33262 }
33263 {
33264 if (temp4)
33265 delete arg4;
33266 }
33267 return resultobj;
33268 fail:
33269 {
33270 if (temp3)
33271 delete arg3;
33272 }
33273 {
33274 if (temp4)
33275 delete arg4;
33276 }
33277 return NULL;
33278 }
33279
33280
33281 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33282 PyObject *resultobj;
33283 wxMenu *arg1 = (wxMenu *) 0 ;
33284 wxMenuItem *result;
33285 PyObject * obj0 = 0 ;
33286 char *kwnames[] = {
33287 (char *) "self", NULL
33288 };
33289
33290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
33291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33292 if (SWIG_arg_fail(1)) SWIG_fail;
33293 {
33294 PyThreadState* __tstate = wxPyBeginAllowThreads();
33295 result = (wxMenuItem *)(arg1)->AppendSeparator();
33296
33297 wxPyEndAllowThreads(__tstate);
33298 if (PyErr_Occurred()) SWIG_fail;
33299 }
33300 {
33301 resultobj = wxPyMake_wxObject(result, 0);
33302 }
33303 return resultobj;
33304 fail:
33305 return NULL;
33306 }
33307
33308
33309 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33310 PyObject *resultobj;
33311 wxMenu *arg1 = (wxMenu *) 0 ;
33312 int arg2 ;
33313 wxString *arg3 = 0 ;
33314 wxString const &arg4_defvalue = wxPyEmptyString ;
33315 wxString *arg4 = (wxString *) &arg4_defvalue ;
33316 wxMenuItem *result;
33317 bool temp3 = false ;
33318 bool temp4 = false ;
33319 PyObject * obj0 = 0 ;
33320 PyObject * obj1 = 0 ;
33321 PyObject * obj2 = 0 ;
33322 PyObject * obj3 = 0 ;
33323 char *kwnames[] = {
33324 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33325 };
33326
33327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33329 if (SWIG_arg_fail(1)) SWIG_fail;
33330 {
33331 arg2 = (int)(SWIG_As_int(obj1));
33332 if (SWIG_arg_fail(2)) SWIG_fail;
33333 }
33334 {
33335 arg3 = wxString_in_helper(obj2);
33336 if (arg3 == NULL) SWIG_fail;
33337 temp3 = true;
33338 }
33339 if (obj3) {
33340 {
33341 arg4 = wxString_in_helper(obj3);
33342 if (arg4 == NULL) SWIG_fail;
33343 temp4 = true;
33344 }
33345 }
33346 {
33347 PyThreadState* __tstate = wxPyBeginAllowThreads();
33348 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33349
33350 wxPyEndAllowThreads(__tstate);
33351 if (PyErr_Occurred()) SWIG_fail;
33352 }
33353 {
33354 resultobj = wxPyMake_wxObject(result, 0);
33355 }
33356 {
33357 if (temp3)
33358 delete arg3;
33359 }
33360 {
33361 if (temp4)
33362 delete arg4;
33363 }
33364 return resultobj;
33365 fail:
33366 {
33367 if (temp3)
33368 delete arg3;
33369 }
33370 {
33371 if (temp4)
33372 delete arg4;
33373 }
33374 return NULL;
33375 }
33376
33377
33378 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33379 PyObject *resultobj;
33380 wxMenu *arg1 = (wxMenu *) 0 ;
33381 int arg2 ;
33382 wxString *arg3 = 0 ;
33383 wxString const &arg4_defvalue = wxPyEmptyString ;
33384 wxString *arg4 = (wxString *) &arg4_defvalue ;
33385 wxMenuItem *result;
33386 bool temp3 = false ;
33387 bool temp4 = false ;
33388 PyObject * obj0 = 0 ;
33389 PyObject * obj1 = 0 ;
33390 PyObject * obj2 = 0 ;
33391 PyObject * obj3 = 0 ;
33392 char *kwnames[] = {
33393 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33394 };
33395
33396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33398 if (SWIG_arg_fail(1)) SWIG_fail;
33399 {
33400 arg2 = (int)(SWIG_As_int(obj1));
33401 if (SWIG_arg_fail(2)) SWIG_fail;
33402 }
33403 {
33404 arg3 = wxString_in_helper(obj2);
33405 if (arg3 == NULL) SWIG_fail;
33406 temp3 = true;
33407 }
33408 if (obj3) {
33409 {
33410 arg4 = wxString_in_helper(obj3);
33411 if (arg4 == NULL) SWIG_fail;
33412 temp4 = true;
33413 }
33414 }
33415 {
33416 PyThreadState* __tstate = wxPyBeginAllowThreads();
33417 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33418
33419 wxPyEndAllowThreads(__tstate);
33420 if (PyErr_Occurred()) SWIG_fail;
33421 }
33422 {
33423 resultobj = wxPyMake_wxObject(result, 0);
33424 }
33425 {
33426 if (temp3)
33427 delete arg3;
33428 }
33429 {
33430 if (temp4)
33431 delete arg4;
33432 }
33433 return resultobj;
33434 fail:
33435 {
33436 if (temp3)
33437 delete arg3;
33438 }
33439 {
33440 if (temp4)
33441 delete arg4;
33442 }
33443 return NULL;
33444 }
33445
33446
33447 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33448 PyObject *resultobj;
33449 wxMenu *arg1 = (wxMenu *) 0 ;
33450 int arg2 ;
33451 wxString *arg3 = 0 ;
33452 wxMenu *arg4 = (wxMenu *) 0 ;
33453 wxString const &arg5_defvalue = wxPyEmptyString ;
33454 wxString *arg5 = (wxString *) &arg5_defvalue ;
33455 wxMenuItem *result;
33456 bool temp3 = false ;
33457 bool temp5 = false ;
33458 PyObject * obj0 = 0 ;
33459 PyObject * obj1 = 0 ;
33460 PyObject * obj2 = 0 ;
33461 PyObject * obj3 = 0 ;
33462 PyObject * obj4 = 0 ;
33463 char *kwnames[] = {
33464 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33465 };
33466
33467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33469 if (SWIG_arg_fail(1)) SWIG_fail;
33470 {
33471 arg2 = (int)(SWIG_As_int(obj1));
33472 if (SWIG_arg_fail(2)) SWIG_fail;
33473 }
33474 {
33475 arg3 = wxString_in_helper(obj2);
33476 if (arg3 == NULL) SWIG_fail;
33477 temp3 = true;
33478 }
33479 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33480 if (SWIG_arg_fail(4)) SWIG_fail;
33481 if (obj4) {
33482 {
33483 arg5 = wxString_in_helper(obj4);
33484 if (arg5 == NULL) SWIG_fail;
33485 temp5 = true;
33486 }
33487 }
33488 {
33489 PyThreadState* __tstate = wxPyBeginAllowThreads();
33490 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33491
33492 wxPyEndAllowThreads(__tstate);
33493 if (PyErr_Occurred()) SWIG_fail;
33494 }
33495 {
33496 resultobj = wxPyMake_wxObject(result, 0);
33497 }
33498 {
33499 if (temp3)
33500 delete arg3;
33501 }
33502 {
33503 if (temp5)
33504 delete arg5;
33505 }
33506 return resultobj;
33507 fail:
33508 {
33509 if (temp3)
33510 delete arg3;
33511 }
33512 {
33513 if (temp5)
33514 delete arg5;
33515 }
33516 return NULL;
33517 }
33518
33519
33520 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
33521 PyObject *resultobj;
33522 wxMenu *arg1 = (wxMenu *) 0 ;
33523 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33524 wxMenuItem *result;
33525 PyObject * obj0 = 0 ;
33526 PyObject * obj1 = 0 ;
33527 char *kwnames[] = {
33528 (char *) "self",(char *) "item", NULL
33529 };
33530
33531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
33532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33533 if (SWIG_arg_fail(1)) SWIG_fail;
33534 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33535 if (SWIG_arg_fail(2)) SWIG_fail;
33536 {
33537 PyThreadState* __tstate = wxPyBeginAllowThreads();
33538 result = (wxMenuItem *)(arg1)->Append(arg2);
33539
33540 wxPyEndAllowThreads(__tstate);
33541 if (PyErr_Occurred()) SWIG_fail;
33542 }
33543 {
33544 resultobj = wxPyMake_wxObject(result, 0);
33545 }
33546 return resultobj;
33547 fail:
33548 return NULL;
33549 }
33550
33551
33552 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
33553 PyObject *resultobj;
33554 wxMenu *arg1 = (wxMenu *) 0 ;
33555 PyObject * obj0 = 0 ;
33556 char *kwnames[] = {
33557 (char *) "self", NULL
33558 };
33559
33560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
33561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33562 if (SWIG_arg_fail(1)) SWIG_fail;
33563 {
33564 PyThreadState* __tstate = wxPyBeginAllowThreads();
33565 (arg1)->Break();
33566
33567 wxPyEndAllowThreads(__tstate);
33568 if (PyErr_Occurred()) SWIG_fail;
33569 }
33570 Py_INCREF(Py_None); resultobj = Py_None;
33571 return resultobj;
33572 fail:
33573 return NULL;
33574 }
33575
33576
33577 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33578 PyObject *resultobj;
33579 wxMenu *arg1 = (wxMenu *) 0 ;
33580 size_t arg2 ;
33581 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33582 wxMenuItem *result;
33583 PyObject * obj0 = 0 ;
33584 PyObject * obj1 = 0 ;
33585 PyObject * obj2 = 0 ;
33586 char *kwnames[] = {
33587 (char *) "self",(char *) "pos",(char *) "item", NULL
33588 };
33589
33590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33592 if (SWIG_arg_fail(1)) SWIG_fail;
33593 {
33594 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33595 if (SWIG_arg_fail(2)) SWIG_fail;
33596 }
33597 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33598 if (SWIG_arg_fail(3)) SWIG_fail;
33599 {
33600 PyThreadState* __tstate = wxPyBeginAllowThreads();
33601 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33602
33603 wxPyEndAllowThreads(__tstate);
33604 if (PyErr_Occurred()) SWIG_fail;
33605 }
33606 {
33607 resultobj = wxPyMake_wxObject(result, 0);
33608 }
33609 return resultobj;
33610 fail:
33611 return NULL;
33612 }
33613
33614
33615 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33616 PyObject *resultobj;
33617 wxMenu *arg1 = (wxMenu *) 0 ;
33618 size_t arg2 ;
33619 int arg3 ;
33620 wxString *arg4 = 0 ;
33621 wxString const &arg5_defvalue = wxPyEmptyString ;
33622 wxString *arg5 = (wxString *) &arg5_defvalue ;
33623 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33624 wxMenuItem *result;
33625 bool temp4 = false ;
33626 bool temp5 = false ;
33627 PyObject * obj0 = 0 ;
33628 PyObject * obj1 = 0 ;
33629 PyObject * obj2 = 0 ;
33630 PyObject * obj3 = 0 ;
33631 PyObject * obj4 = 0 ;
33632 PyObject * obj5 = 0 ;
33633 char *kwnames[] = {
33634 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33635 };
33636
33637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33639 if (SWIG_arg_fail(1)) SWIG_fail;
33640 {
33641 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33642 if (SWIG_arg_fail(2)) SWIG_fail;
33643 }
33644 {
33645 arg3 = (int)(SWIG_As_int(obj2));
33646 if (SWIG_arg_fail(3)) SWIG_fail;
33647 }
33648 {
33649 arg4 = wxString_in_helper(obj3);
33650 if (arg4 == NULL) SWIG_fail;
33651 temp4 = true;
33652 }
33653 if (obj4) {
33654 {
33655 arg5 = wxString_in_helper(obj4);
33656 if (arg5 == NULL) SWIG_fail;
33657 temp5 = true;
33658 }
33659 }
33660 if (obj5) {
33661 {
33662 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33663 if (SWIG_arg_fail(6)) SWIG_fail;
33664 }
33665 }
33666 {
33667 PyThreadState* __tstate = wxPyBeginAllowThreads();
33668 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33669
33670 wxPyEndAllowThreads(__tstate);
33671 if (PyErr_Occurred()) SWIG_fail;
33672 }
33673 {
33674 resultobj = wxPyMake_wxObject(result, 0);
33675 }
33676 {
33677 if (temp4)
33678 delete arg4;
33679 }
33680 {
33681 if (temp5)
33682 delete arg5;
33683 }
33684 return resultobj;
33685 fail:
33686 {
33687 if (temp4)
33688 delete arg4;
33689 }
33690 {
33691 if (temp5)
33692 delete arg5;
33693 }
33694 return NULL;
33695 }
33696
33697
33698 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33699 PyObject *resultobj;
33700 wxMenu *arg1 = (wxMenu *) 0 ;
33701 size_t arg2 ;
33702 wxMenuItem *result;
33703 PyObject * obj0 = 0 ;
33704 PyObject * obj1 = 0 ;
33705 char *kwnames[] = {
33706 (char *) "self",(char *) "pos", NULL
33707 };
33708
33709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33711 if (SWIG_arg_fail(1)) SWIG_fail;
33712 {
33713 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33714 if (SWIG_arg_fail(2)) SWIG_fail;
33715 }
33716 {
33717 PyThreadState* __tstate = wxPyBeginAllowThreads();
33718 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33719
33720 wxPyEndAllowThreads(__tstate);
33721 if (PyErr_Occurred()) SWIG_fail;
33722 }
33723 {
33724 resultobj = wxPyMake_wxObject(result, 0);
33725 }
33726 return resultobj;
33727 fail:
33728 return NULL;
33729 }
33730
33731
33732 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33733 PyObject *resultobj;
33734 wxMenu *arg1 = (wxMenu *) 0 ;
33735 size_t arg2 ;
33736 int arg3 ;
33737 wxString *arg4 = 0 ;
33738 wxString const &arg5_defvalue = wxPyEmptyString ;
33739 wxString *arg5 = (wxString *) &arg5_defvalue ;
33740 wxMenuItem *result;
33741 bool temp4 = false ;
33742 bool temp5 = false ;
33743 PyObject * obj0 = 0 ;
33744 PyObject * obj1 = 0 ;
33745 PyObject * obj2 = 0 ;
33746 PyObject * obj3 = 0 ;
33747 PyObject * obj4 = 0 ;
33748 char *kwnames[] = {
33749 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33750 };
33751
33752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33754 if (SWIG_arg_fail(1)) SWIG_fail;
33755 {
33756 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33757 if (SWIG_arg_fail(2)) SWIG_fail;
33758 }
33759 {
33760 arg3 = (int)(SWIG_As_int(obj2));
33761 if (SWIG_arg_fail(3)) SWIG_fail;
33762 }
33763 {
33764 arg4 = wxString_in_helper(obj3);
33765 if (arg4 == NULL) SWIG_fail;
33766 temp4 = true;
33767 }
33768 if (obj4) {
33769 {
33770 arg5 = wxString_in_helper(obj4);
33771 if (arg5 == NULL) SWIG_fail;
33772 temp5 = true;
33773 }
33774 }
33775 {
33776 PyThreadState* __tstate = wxPyBeginAllowThreads();
33777 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33778
33779 wxPyEndAllowThreads(__tstate);
33780 if (PyErr_Occurred()) SWIG_fail;
33781 }
33782 {
33783 resultobj = wxPyMake_wxObject(result, 0);
33784 }
33785 {
33786 if (temp4)
33787 delete arg4;
33788 }
33789 {
33790 if (temp5)
33791 delete arg5;
33792 }
33793 return resultobj;
33794 fail:
33795 {
33796 if (temp4)
33797 delete arg4;
33798 }
33799 {
33800 if (temp5)
33801 delete arg5;
33802 }
33803 return NULL;
33804 }
33805
33806
33807 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33808 PyObject *resultobj;
33809 wxMenu *arg1 = (wxMenu *) 0 ;
33810 size_t arg2 ;
33811 int arg3 ;
33812 wxString *arg4 = 0 ;
33813 wxString const &arg5_defvalue = wxPyEmptyString ;
33814 wxString *arg5 = (wxString *) &arg5_defvalue ;
33815 wxMenuItem *result;
33816 bool temp4 = false ;
33817 bool temp5 = false ;
33818 PyObject * obj0 = 0 ;
33819 PyObject * obj1 = 0 ;
33820 PyObject * obj2 = 0 ;
33821 PyObject * obj3 = 0 ;
33822 PyObject * obj4 = 0 ;
33823 char *kwnames[] = {
33824 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33825 };
33826
33827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33829 if (SWIG_arg_fail(1)) SWIG_fail;
33830 {
33831 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33832 if (SWIG_arg_fail(2)) SWIG_fail;
33833 }
33834 {
33835 arg3 = (int)(SWIG_As_int(obj2));
33836 if (SWIG_arg_fail(3)) SWIG_fail;
33837 }
33838 {
33839 arg4 = wxString_in_helper(obj3);
33840 if (arg4 == NULL) SWIG_fail;
33841 temp4 = true;
33842 }
33843 if (obj4) {
33844 {
33845 arg5 = wxString_in_helper(obj4);
33846 if (arg5 == NULL) SWIG_fail;
33847 temp5 = true;
33848 }
33849 }
33850 {
33851 PyThreadState* __tstate = wxPyBeginAllowThreads();
33852 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33853
33854 wxPyEndAllowThreads(__tstate);
33855 if (PyErr_Occurred()) SWIG_fail;
33856 }
33857 {
33858 resultobj = wxPyMake_wxObject(result, 0);
33859 }
33860 {
33861 if (temp4)
33862 delete arg4;
33863 }
33864 {
33865 if (temp5)
33866 delete arg5;
33867 }
33868 return resultobj;
33869 fail:
33870 {
33871 if (temp4)
33872 delete arg4;
33873 }
33874 {
33875 if (temp5)
33876 delete arg5;
33877 }
33878 return NULL;
33879 }
33880
33881
33882 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33883 PyObject *resultobj;
33884 wxMenu *arg1 = (wxMenu *) 0 ;
33885 size_t arg2 ;
33886 int arg3 ;
33887 wxString *arg4 = 0 ;
33888 wxMenu *arg5 = (wxMenu *) 0 ;
33889 wxString const &arg6_defvalue = wxPyEmptyString ;
33890 wxString *arg6 = (wxString *) &arg6_defvalue ;
33891 wxMenuItem *result;
33892 bool temp4 = false ;
33893 bool temp6 = false ;
33894 PyObject * obj0 = 0 ;
33895 PyObject * obj1 = 0 ;
33896 PyObject * obj2 = 0 ;
33897 PyObject * obj3 = 0 ;
33898 PyObject * obj4 = 0 ;
33899 PyObject * obj5 = 0 ;
33900 char *kwnames[] = {
33901 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33902 };
33903
33904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33906 if (SWIG_arg_fail(1)) SWIG_fail;
33907 {
33908 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33909 if (SWIG_arg_fail(2)) SWIG_fail;
33910 }
33911 {
33912 arg3 = (int)(SWIG_As_int(obj2));
33913 if (SWIG_arg_fail(3)) SWIG_fail;
33914 }
33915 {
33916 arg4 = wxString_in_helper(obj3);
33917 if (arg4 == NULL) SWIG_fail;
33918 temp4 = true;
33919 }
33920 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33921 if (SWIG_arg_fail(5)) SWIG_fail;
33922 if (obj5) {
33923 {
33924 arg6 = wxString_in_helper(obj5);
33925 if (arg6 == NULL) SWIG_fail;
33926 temp6 = true;
33927 }
33928 }
33929 {
33930 PyThreadState* __tstate = wxPyBeginAllowThreads();
33931 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33932
33933 wxPyEndAllowThreads(__tstate);
33934 if (PyErr_Occurred()) SWIG_fail;
33935 }
33936 {
33937 resultobj = wxPyMake_wxObject(result, 0);
33938 }
33939 {
33940 if (temp4)
33941 delete arg4;
33942 }
33943 {
33944 if (temp6)
33945 delete arg6;
33946 }
33947 return resultobj;
33948 fail:
33949 {
33950 if (temp4)
33951 delete arg4;
33952 }
33953 {
33954 if (temp6)
33955 delete arg6;
33956 }
33957 return NULL;
33958 }
33959
33960
33961 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33962 PyObject *resultobj;
33963 wxMenu *arg1 = (wxMenu *) 0 ;
33964 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33965 wxMenuItem *result;
33966 PyObject * obj0 = 0 ;
33967 PyObject * obj1 = 0 ;
33968 char *kwnames[] = {
33969 (char *) "self",(char *) "item", NULL
33970 };
33971
33972 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33973 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33974 if (SWIG_arg_fail(1)) SWIG_fail;
33975 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33976 if (SWIG_arg_fail(2)) SWIG_fail;
33977 {
33978 PyThreadState* __tstate = wxPyBeginAllowThreads();
33979 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33980
33981 wxPyEndAllowThreads(__tstate);
33982 if (PyErr_Occurred()) SWIG_fail;
33983 }
33984 {
33985 resultobj = wxPyMake_wxObject(result, 0);
33986 }
33987 return resultobj;
33988 fail:
33989 return NULL;
33990 }
33991
33992
33993 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33994 PyObject *resultobj;
33995 wxMenu *arg1 = (wxMenu *) 0 ;
33996 int arg2 ;
33997 wxString *arg3 = 0 ;
33998 wxString const &arg4_defvalue = wxPyEmptyString ;
33999 wxString *arg4 = (wxString *) &arg4_defvalue ;
34000 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
34001 wxMenuItem *result;
34002 bool temp3 = false ;
34003 bool temp4 = false ;
34004 PyObject * obj0 = 0 ;
34005 PyObject * obj1 = 0 ;
34006 PyObject * obj2 = 0 ;
34007 PyObject * obj3 = 0 ;
34008 PyObject * obj4 = 0 ;
34009 char *kwnames[] = {
34010 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
34011 };
34012
34013 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34014 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34015 if (SWIG_arg_fail(1)) SWIG_fail;
34016 {
34017 arg2 = (int)(SWIG_As_int(obj1));
34018 if (SWIG_arg_fail(2)) SWIG_fail;
34019 }
34020 {
34021 arg3 = wxString_in_helper(obj2);
34022 if (arg3 == NULL) SWIG_fail;
34023 temp3 = true;
34024 }
34025 if (obj3) {
34026 {
34027 arg4 = wxString_in_helper(obj3);
34028 if (arg4 == NULL) SWIG_fail;
34029 temp4 = true;
34030 }
34031 }
34032 if (obj4) {
34033 {
34034 arg5 = (wxItemKind)(SWIG_As_int(obj4));
34035 if (SWIG_arg_fail(5)) SWIG_fail;
34036 }
34037 }
34038 {
34039 PyThreadState* __tstate = wxPyBeginAllowThreads();
34040 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
34041
34042 wxPyEndAllowThreads(__tstate);
34043 if (PyErr_Occurred()) SWIG_fail;
34044 }
34045 {
34046 resultobj = wxPyMake_wxObject(result, 0);
34047 }
34048 {
34049 if (temp3)
34050 delete arg3;
34051 }
34052 {
34053 if (temp4)
34054 delete arg4;
34055 }
34056 return resultobj;
34057 fail:
34058 {
34059 if (temp3)
34060 delete arg3;
34061 }
34062 {
34063 if (temp4)
34064 delete arg4;
34065 }
34066 return NULL;
34067 }
34068
34069
34070 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
34071 PyObject *resultobj;
34072 wxMenu *arg1 = (wxMenu *) 0 ;
34073 wxMenuItem *result;
34074 PyObject * obj0 = 0 ;
34075 char *kwnames[] = {
34076 (char *) "self", NULL
34077 };
34078
34079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
34080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34081 if (SWIG_arg_fail(1)) SWIG_fail;
34082 {
34083 PyThreadState* __tstate = wxPyBeginAllowThreads();
34084 result = (wxMenuItem *)(arg1)->PrependSeparator();
34085
34086 wxPyEndAllowThreads(__tstate);
34087 if (PyErr_Occurred()) SWIG_fail;
34088 }
34089 {
34090 resultobj = wxPyMake_wxObject(result, 0);
34091 }
34092 return resultobj;
34093 fail:
34094 return NULL;
34095 }
34096
34097
34098 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
34099 PyObject *resultobj;
34100 wxMenu *arg1 = (wxMenu *) 0 ;
34101 int arg2 ;
34102 wxString *arg3 = 0 ;
34103 wxString const &arg4_defvalue = wxPyEmptyString ;
34104 wxString *arg4 = (wxString *) &arg4_defvalue ;
34105 wxMenuItem *result;
34106 bool temp3 = false ;
34107 bool temp4 = false ;
34108 PyObject * obj0 = 0 ;
34109 PyObject * obj1 = 0 ;
34110 PyObject * obj2 = 0 ;
34111 PyObject * obj3 = 0 ;
34112 char *kwnames[] = {
34113 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34114 };
34115
34116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34118 if (SWIG_arg_fail(1)) SWIG_fail;
34119 {
34120 arg2 = (int)(SWIG_As_int(obj1));
34121 if (SWIG_arg_fail(2)) SWIG_fail;
34122 }
34123 {
34124 arg3 = wxString_in_helper(obj2);
34125 if (arg3 == NULL) SWIG_fail;
34126 temp3 = true;
34127 }
34128 if (obj3) {
34129 {
34130 arg4 = wxString_in_helper(obj3);
34131 if (arg4 == NULL) SWIG_fail;
34132 temp4 = true;
34133 }
34134 }
34135 {
34136 PyThreadState* __tstate = wxPyBeginAllowThreads();
34137 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34138
34139 wxPyEndAllowThreads(__tstate);
34140 if (PyErr_Occurred()) SWIG_fail;
34141 }
34142 {
34143 resultobj = wxPyMake_wxObject(result, 0);
34144 }
34145 {
34146 if (temp3)
34147 delete arg3;
34148 }
34149 {
34150 if (temp4)
34151 delete arg4;
34152 }
34153 return resultobj;
34154 fail:
34155 {
34156 if (temp3)
34157 delete arg3;
34158 }
34159 {
34160 if (temp4)
34161 delete arg4;
34162 }
34163 return NULL;
34164 }
34165
34166
34167 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
34168 PyObject *resultobj;
34169 wxMenu *arg1 = (wxMenu *) 0 ;
34170 int arg2 ;
34171 wxString *arg3 = 0 ;
34172 wxString const &arg4_defvalue = wxPyEmptyString ;
34173 wxString *arg4 = (wxString *) &arg4_defvalue ;
34174 wxMenuItem *result;
34175 bool temp3 = false ;
34176 bool temp4 = false ;
34177 PyObject * obj0 = 0 ;
34178 PyObject * obj1 = 0 ;
34179 PyObject * obj2 = 0 ;
34180 PyObject * obj3 = 0 ;
34181 char *kwnames[] = {
34182 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
34183 };
34184
34185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34187 if (SWIG_arg_fail(1)) SWIG_fail;
34188 {
34189 arg2 = (int)(SWIG_As_int(obj1));
34190 if (SWIG_arg_fail(2)) SWIG_fail;
34191 }
34192 {
34193 arg3 = wxString_in_helper(obj2);
34194 if (arg3 == NULL) SWIG_fail;
34195 temp3 = true;
34196 }
34197 if (obj3) {
34198 {
34199 arg4 = wxString_in_helper(obj3);
34200 if (arg4 == NULL) SWIG_fail;
34201 temp4 = true;
34202 }
34203 }
34204 {
34205 PyThreadState* __tstate = wxPyBeginAllowThreads();
34206 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
34207
34208 wxPyEndAllowThreads(__tstate);
34209 if (PyErr_Occurred()) SWIG_fail;
34210 }
34211 {
34212 resultobj = wxPyMake_wxObject(result, 0);
34213 }
34214 {
34215 if (temp3)
34216 delete arg3;
34217 }
34218 {
34219 if (temp4)
34220 delete arg4;
34221 }
34222 return resultobj;
34223 fail:
34224 {
34225 if (temp3)
34226 delete arg3;
34227 }
34228 {
34229 if (temp4)
34230 delete arg4;
34231 }
34232 return NULL;
34233 }
34234
34235
34236 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
34237 PyObject *resultobj;
34238 wxMenu *arg1 = (wxMenu *) 0 ;
34239 int arg2 ;
34240 wxString *arg3 = 0 ;
34241 wxMenu *arg4 = (wxMenu *) 0 ;
34242 wxString const &arg5_defvalue = wxPyEmptyString ;
34243 wxString *arg5 = (wxString *) &arg5_defvalue ;
34244 wxMenuItem *result;
34245 bool temp3 = false ;
34246 bool temp5 = false ;
34247 PyObject * obj0 = 0 ;
34248 PyObject * obj1 = 0 ;
34249 PyObject * obj2 = 0 ;
34250 PyObject * obj3 = 0 ;
34251 PyObject * obj4 = 0 ;
34252 char *kwnames[] = {
34253 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
34254 };
34255
34256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
34257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34258 if (SWIG_arg_fail(1)) SWIG_fail;
34259 {
34260 arg2 = (int)(SWIG_As_int(obj1));
34261 if (SWIG_arg_fail(2)) SWIG_fail;
34262 }
34263 {
34264 arg3 = wxString_in_helper(obj2);
34265 if (arg3 == NULL) SWIG_fail;
34266 temp3 = true;
34267 }
34268 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34269 if (SWIG_arg_fail(4)) SWIG_fail;
34270 if (obj4) {
34271 {
34272 arg5 = wxString_in_helper(obj4);
34273 if (arg5 == NULL) SWIG_fail;
34274 temp5 = true;
34275 }
34276 }
34277 {
34278 PyThreadState* __tstate = wxPyBeginAllowThreads();
34279 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
34280
34281 wxPyEndAllowThreads(__tstate);
34282 if (PyErr_Occurred()) SWIG_fail;
34283 }
34284 {
34285 resultobj = wxPyMake_wxObject(result, 0);
34286 }
34287 {
34288 if (temp3)
34289 delete arg3;
34290 }
34291 {
34292 if (temp5)
34293 delete arg5;
34294 }
34295 return resultobj;
34296 fail:
34297 {
34298 if (temp3)
34299 delete arg3;
34300 }
34301 {
34302 if (temp5)
34303 delete arg5;
34304 }
34305 return NULL;
34306 }
34307
34308
34309 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
34310 PyObject *resultobj;
34311 wxMenu *arg1 = (wxMenu *) 0 ;
34312 int arg2 ;
34313 wxMenuItem *result;
34314 PyObject * obj0 = 0 ;
34315 PyObject * obj1 = 0 ;
34316 char *kwnames[] = {
34317 (char *) "self",(char *) "id", NULL
34318 };
34319
34320 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
34321 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34322 if (SWIG_arg_fail(1)) SWIG_fail;
34323 {
34324 arg2 = (int)(SWIG_As_int(obj1));
34325 if (SWIG_arg_fail(2)) SWIG_fail;
34326 }
34327 {
34328 PyThreadState* __tstate = wxPyBeginAllowThreads();
34329 result = (wxMenuItem *)(arg1)->Remove(arg2);
34330
34331 wxPyEndAllowThreads(__tstate);
34332 if (PyErr_Occurred()) SWIG_fail;
34333 }
34334 {
34335 resultobj = wxPyMake_wxObject(result, 0);
34336 }
34337 return resultobj;
34338 fail:
34339 return NULL;
34340 }
34341
34342
34343 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
34344 PyObject *resultobj;
34345 wxMenu *arg1 = (wxMenu *) 0 ;
34346 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34347 wxMenuItem *result;
34348 PyObject * obj0 = 0 ;
34349 PyObject * obj1 = 0 ;
34350 char *kwnames[] = {
34351 (char *) "self",(char *) "item", NULL
34352 };
34353
34354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
34355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34356 if (SWIG_arg_fail(1)) SWIG_fail;
34357 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34358 if (SWIG_arg_fail(2)) SWIG_fail;
34359 {
34360 PyThreadState* __tstate = wxPyBeginAllowThreads();
34361 result = (wxMenuItem *)(arg1)->Remove(arg2);
34362
34363 wxPyEndAllowThreads(__tstate);
34364 if (PyErr_Occurred()) SWIG_fail;
34365 }
34366 {
34367 resultobj = wxPyMake_wxObject(result, 0);
34368 }
34369 return resultobj;
34370 fail:
34371 return NULL;
34372 }
34373
34374
34375 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
34376 PyObject *resultobj;
34377 wxMenu *arg1 = (wxMenu *) 0 ;
34378 int arg2 ;
34379 bool result;
34380 PyObject * obj0 = 0 ;
34381 PyObject * obj1 = 0 ;
34382 char *kwnames[] = {
34383 (char *) "self",(char *) "id", NULL
34384 };
34385
34386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
34387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34388 if (SWIG_arg_fail(1)) SWIG_fail;
34389 {
34390 arg2 = (int)(SWIG_As_int(obj1));
34391 if (SWIG_arg_fail(2)) SWIG_fail;
34392 }
34393 {
34394 PyThreadState* __tstate = wxPyBeginAllowThreads();
34395 result = (bool)(arg1)->Delete(arg2);
34396
34397 wxPyEndAllowThreads(__tstate);
34398 if (PyErr_Occurred()) SWIG_fail;
34399 }
34400 {
34401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34402 }
34403 return resultobj;
34404 fail:
34405 return NULL;
34406 }
34407
34408
34409 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
34410 PyObject *resultobj;
34411 wxMenu *arg1 = (wxMenu *) 0 ;
34412 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34413 bool result;
34414 PyObject * obj0 = 0 ;
34415 PyObject * obj1 = 0 ;
34416 char *kwnames[] = {
34417 (char *) "self",(char *) "item", NULL
34418 };
34419
34420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
34421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34422 if (SWIG_arg_fail(1)) SWIG_fail;
34423 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34424 if (SWIG_arg_fail(2)) SWIG_fail;
34425 {
34426 PyThreadState* __tstate = wxPyBeginAllowThreads();
34427 result = (bool)(arg1)->Delete(arg2);
34428
34429 wxPyEndAllowThreads(__tstate);
34430 if (PyErr_Occurred()) SWIG_fail;
34431 }
34432 {
34433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34434 }
34435 return resultobj;
34436 fail:
34437 return NULL;
34438 }
34439
34440
34441 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
34442 PyObject *resultobj;
34443 wxMenu *arg1 = (wxMenu *) 0 ;
34444 PyObject * obj0 = 0 ;
34445 char *kwnames[] = {
34446 (char *) "self", NULL
34447 };
34448
34449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
34450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34451 if (SWIG_arg_fail(1)) SWIG_fail;
34452 {
34453 PyThreadState* __tstate = wxPyBeginAllowThreads();
34454 wxMenu_Destroy(arg1);
34455
34456 wxPyEndAllowThreads(__tstate);
34457 if (PyErr_Occurred()) SWIG_fail;
34458 }
34459 Py_INCREF(Py_None); resultobj = Py_None;
34460 return resultobj;
34461 fail:
34462 return NULL;
34463 }
34464
34465
34466 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
34467 PyObject *resultobj;
34468 wxMenu *arg1 = (wxMenu *) 0 ;
34469 int arg2 ;
34470 bool result;
34471 PyObject * obj0 = 0 ;
34472 PyObject * obj1 = 0 ;
34473 char *kwnames[] = {
34474 (char *) "self",(char *) "id", NULL
34475 };
34476
34477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
34478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34479 if (SWIG_arg_fail(1)) SWIG_fail;
34480 {
34481 arg2 = (int)(SWIG_As_int(obj1));
34482 if (SWIG_arg_fail(2)) SWIG_fail;
34483 }
34484 {
34485 PyThreadState* __tstate = wxPyBeginAllowThreads();
34486 result = (bool)(arg1)->Destroy(arg2);
34487
34488 wxPyEndAllowThreads(__tstate);
34489 if (PyErr_Occurred()) SWIG_fail;
34490 }
34491 {
34492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34493 }
34494 return resultobj;
34495 fail:
34496 return NULL;
34497 }
34498
34499
34500 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
34501 PyObject *resultobj;
34502 wxMenu *arg1 = (wxMenu *) 0 ;
34503 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
34504 bool result;
34505 PyObject * obj0 = 0 ;
34506 PyObject * obj1 = 0 ;
34507 char *kwnames[] = {
34508 (char *) "self",(char *) "item", NULL
34509 };
34510
34511 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
34512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34513 if (SWIG_arg_fail(1)) SWIG_fail;
34514 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
34515 if (SWIG_arg_fail(2)) SWIG_fail;
34516 {
34517 PyThreadState* __tstate = wxPyBeginAllowThreads();
34518 result = (bool)(arg1)->Destroy(arg2);
34519
34520 wxPyEndAllowThreads(__tstate);
34521 if (PyErr_Occurred()) SWIG_fail;
34522 }
34523 {
34524 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34525 }
34526 return resultobj;
34527 fail:
34528 return NULL;
34529 }
34530
34531
34532 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
34533 PyObject *resultobj;
34534 wxMenu *arg1 = (wxMenu *) 0 ;
34535 size_t result;
34536 PyObject * obj0 = 0 ;
34537 char *kwnames[] = {
34538 (char *) "self", NULL
34539 };
34540
34541 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
34542 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34543 if (SWIG_arg_fail(1)) SWIG_fail;
34544 {
34545 PyThreadState* __tstate = wxPyBeginAllowThreads();
34546 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
34547
34548 wxPyEndAllowThreads(__tstate);
34549 if (PyErr_Occurred()) SWIG_fail;
34550 }
34551 {
34552 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
34553 }
34554 return resultobj;
34555 fail:
34556 return NULL;
34557 }
34558
34559
34560 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
34561 PyObject *resultobj;
34562 wxMenu *arg1 = (wxMenu *) 0 ;
34563 PyObject *result;
34564 PyObject * obj0 = 0 ;
34565 char *kwnames[] = {
34566 (char *) "self", NULL
34567 };
34568
34569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34571 if (SWIG_arg_fail(1)) SWIG_fail;
34572 {
34573 PyThreadState* __tstate = wxPyBeginAllowThreads();
34574 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34575
34576 wxPyEndAllowThreads(__tstate);
34577 if (PyErr_Occurred()) SWIG_fail;
34578 }
34579 resultobj = result;
34580 return resultobj;
34581 fail:
34582 return NULL;
34583 }
34584
34585
34586 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34587 PyObject *resultobj;
34588 wxMenu *arg1 = (wxMenu *) 0 ;
34589 wxString *arg2 = 0 ;
34590 int result;
34591 bool temp2 = false ;
34592 PyObject * obj0 = 0 ;
34593 PyObject * obj1 = 0 ;
34594 char *kwnames[] = {
34595 (char *) "self",(char *) "item", NULL
34596 };
34597
34598 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34599 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34600 if (SWIG_arg_fail(1)) SWIG_fail;
34601 {
34602 arg2 = wxString_in_helper(obj1);
34603 if (arg2 == NULL) SWIG_fail;
34604 temp2 = true;
34605 }
34606 {
34607 PyThreadState* __tstate = wxPyBeginAllowThreads();
34608 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34609
34610 wxPyEndAllowThreads(__tstate);
34611 if (PyErr_Occurred()) SWIG_fail;
34612 }
34613 {
34614 resultobj = SWIG_From_int((int)(result));
34615 }
34616 {
34617 if (temp2)
34618 delete arg2;
34619 }
34620 return resultobj;
34621 fail:
34622 {
34623 if (temp2)
34624 delete arg2;
34625 }
34626 return NULL;
34627 }
34628
34629
34630 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34631 PyObject *resultobj;
34632 wxMenu *arg1 = (wxMenu *) 0 ;
34633 int arg2 ;
34634 wxMenuItem *result;
34635 PyObject * obj0 = 0 ;
34636 PyObject * obj1 = 0 ;
34637 char *kwnames[] = {
34638 (char *) "self",(char *) "id", NULL
34639 };
34640
34641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34643 if (SWIG_arg_fail(1)) SWIG_fail;
34644 {
34645 arg2 = (int)(SWIG_As_int(obj1));
34646 if (SWIG_arg_fail(2)) SWIG_fail;
34647 }
34648 {
34649 PyThreadState* __tstate = wxPyBeginAllowThreads();
34650 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34651
34652 wxPyEndAllowThreads(__tstate);
34653 if (PyErr_Occurred()) SWIG_fail;
34654 }
34655 {
34656 resultobj = wxPyMake_wxObject(result, 0);
34657 }
34658 return resultobj;
34659 fail:
34660 return NULL;
34661 }
34662
34663
34664 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34665 PyObject *resultobj;
34666 wxMenu *arg1 = (wxMenu *) 0 ;
34667 size_t arg2 ;
34668 wxMenuItem *result;
34669 PyObject * obj0 = 0 ;
34670 PyObject * obj1 = 0 ;
34671 char *kwnames[] = {
34672 (char *) "self",(char *) "position", NULL
34673 };
34674
34675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34677 if (SWIG_arg_fail(1)) SWIG_fail;
34678 {
34679 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34680 if (SWIG_arg_fail(2)) SWIG_fail;
34681 }
34682 {
34683 PyThreadState* __tstate = wxPyBeginAllowThreads();
34684 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34685
34686 wxPyEndAllowThreads(__tstate);
34687 if (PyErr_Occurred()) SWIG_fail;
34688 }
34689 {
34690 resultobj = wxPyMake_wxObject(result, 0);
34691 }
34692 return resultobj;
34693 fail:
34694 return NULL;
34695 }
34696
34697
34698 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34699 PyObject *resultobj;
34700 wxMenu *arg1 = (wxMenu *) 0 ;
34701 int arg2 ;
34702 bool arg3 ;
34703 PyObject * obj0 = 0 ;
34704 PyObject * obj1 = 0 ;
34705 PyObject * obj2 = 0 ;
34706 char *kwnames[] = {
34707 (char *) "self",(char *) "id",(char *) "enable", NULL
34708 };
34709
34710 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34711 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34712 if (SWIG_arg_fail(1)) SWIG_fail;
34713 {
34714 arg2 = (int)(SWIG_As_int(obj1));
34715 if (SWIG_arg_fail(2)) SWIG_fail;
34716 }
34717 {
34718 arg3 = (bool)(SWIG_As_bool(obj2));
34719 if (SWIG_arg_fail(3)) SWIG_fail;
34720 }
34721 {
34722 PyThreadState* __tstate = wxPyBeginAllowThreads();
34723 (arg1)->Enable(arg2,arg3);
34724
34725 wxPyEndAllowThreads(__tstate);
34726 if (PyErr_Occurred()) SWIG_fail;
34727 }
34728 Py_INCREF(Py_None); resultobj = Py_None;
34729 return resultobj;
34730 fail:
34731 return NULL;
34732 }
34733
34734
34735 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34736 PyObject *resultobj;
34737 wxMenu *arg1 = (wxMenu *) 0 ;
34738 int arg2 ;
34739 bool result;
34740 PyObject * obj0 = 0 ;
34741 PyObject * obj1 = 0 ;
34742 char *kwnames[] = {
34743 (char *) "self",(char *) "id", NULL
34744 };
34745
34746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34747 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34748 if (SWIG_arg_fail(1)) SWIG_fail;
34749 {
34750 arg2 = (int)(SWIG_As_int(obj1));
34751 if (SWIG_arg_fail(2)) SWIG_fail;
34752 }
34753 {
34754 PyThreadState* __tstate = wxPyBeginAllowThreads();
34755 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34756
34757 wxPyEndAllowThreads(__tstate);
34758 if (PyErr_Occurred()) SWIG_fail;
34759 }
34760 {
34761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34762 }
34763 return resultobj;
34764 fail:
34765 return NULL;
34766 }
34767
34768
34769 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34770 PyObject *resultobj;
34771 wxMenu *arg1 = (wxMenu *) 0 ;
34772 int arg2 ;
34773 bool arg3 ;
34774 PyObject * obj0 = 0 ;
34775 PyObject * obj1 = 0 ;
34776 PyObject * obj2 = 0 ;
34777 char *kwnames[] = {
34778 (char *) "self",(char *) "id",(char *) "check", NULL
34779 };
34780
34781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34783 if (SWIG_arg_fail(1)) SWIG_fail;
34784 {
34785 arg2 = (int)(SWIG_As_int(obj1));
34786 if (SWIG_arg_fail(2)) SWIG_fail;
34787 }
34788 {
34789 arg3 = (bool)(SWIG_As_bool(obj2));
34790 if (SWIG_arg_fail(3)) SWIG_fail;
34791 }
34792 {
34793 PyThreadState* __tstate = wxPyBeginAllowThreads();
34794 (arg1)->Check(arg2,arg3);
34795
34796 wxPyEndAllowThreads(__tstate);
34797 if (PyErr_Occurred()) SWIG_fail;
34798 }
34799 Py_INCREF(Py_None); resultobj = Py_None;
34800 return resultobj;
34801 fail:
34802 return NULL;
34803 }
34804
34805
34806 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34807 PyObject *resultobj;
34808 wxMenu *arg1 = (wxMenu *) 0 ;
34809 int arg2 ;
34810 bool result;
34811 PyObject * obj0 = 0 ;
34812 PyObject * obj1 = 0 ;
34813 char *kwnames[] = {
34814 (char *) "self",(char *) "id", NULL
34815 };
34816
34817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34819 if (SWIG_arg_fail(1)) SWIG_fail;
34820 {
34821 arg2 = (int)(SWIG_As_int(obj1));
34822 if (SWIG_arg_fail(2)) SWIG_fail;
34823 }
34824 {
34825 PyThreadState* __tstate = wxPyBeginAllowThreads();
34826 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34827
34828 wxPyEndAllowThreads(__tstate);
34829 if (PyErr_Occurred()) SWIG_fail;
34830 }
34831 {
34832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34833 }
34834 return resultobj;
34835 fail:
34836 return NULL;
34837 }
34838
34839
34840 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34841 PyObject *resultobj;
34842 wxMenu *arg1 = (wxMenu *) 0 ;
34843 int arg2 ;
34844 wxString *arg3 = 0 ;
34845 bool temp3 = false ;
34846 PyObject * obj0 = 0 ;
34847 PyObject * obj1 = 0 ;
34848 PyObject * obj2 = 0 ;
34849 char *kwnames[] = {
34850 (char *) "self",(char *) "id",(char *) "label", NULL
34851 };
34852
34853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34855 if (SWIG_arg_fail(1)) SWIG_fail;
34856 {
34857 arg2 = (int)(SWIG_As_int(obj1));
34858 if (SWIG_arg_fail(2)) SWIG_fail;
34859 }
34860 {
34861 arg3 = wxString_in_helper(obj2);
34862 if (arg3 == NULL) SWIG_fail;
34863 temp3 = true;
34864 }
34865 {
34866 PyThreadState* __tstate = wxPyBeginAllowThreads();
34867 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34868
34869 wxPyEndAllowThreads(__tstate);
34870 if (PyErr_Occurred()) SWIG_fail;
34871 }
34872 Py_INCREF(Py_None); resultobj = Py_None;
34873 {
34874 if (temp3)
34875 delete arg3;
34876 }
34877 return resultobj;
34878 fail:
34879 {
34880 if (temp3)
34881 delete arg3;
34882 }
34883 return NULL;
34884 }
34885
34886
34887 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34888 PyObject *resultobj;
34889 wxMenu *arg1 = (wxMenu *) 0 ;
34890 int arg2 ;
34891 wxString result;
34892 PyObject * obj0 = 0 ;
34893 PyObject * obj1 = 0 ;
34894 char *kwnames[] = {
34895 (char *) "self",(char *) "id", NULL
34896 };
34897
34898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34900 if (SWIG_arg_fail(1)) SWIG_fail;
34901 {
34902 arg2 = (int)(SWIG_As_int(obj1));
34903 if (SWIG_arg_fail(2)) SWIG_fail;
34904 }
34905 {
34906 PyThreadState* __tstate = wxPyBeginAllowThreads();
34907 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34908
34909 wxPyEndAllowThreads(__tstate);
34910 if (PyErr_Occurred()) SWIG_fail;
34911 }
34912 {
34913 #if wxUSE_UNICODE
34914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34915 #else
34916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34917 #endif
34918 }
34919 return resultobj;
34920 fail:
34921 return NULL;
34922 }
34923
34924
34925 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34926 PyObject *resultobj;
34927 wxMenu *arg1 = (wxMenu *) 0 ;
34928 int arg2 ;
34929 wxString *arg3 = 0 ;
34930 bool temp3 = false ;
34931 PyObject * obj0 = 0 ;
34932 PyObject * obj1 = 0 ;
34933 PyObject * obj2 = 0 ;
34934 char *kwnames[] = {
34935 (char *) "self",(char *) "id",(char *) "helpString", NULL
34936 };
34937
34938 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34939 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34940 if (SWIG_arg_fail(1)) SWIG_fail;
34941 {
34942 arg2 = (int)(SWIG_As_int(obj1));
34943 if (SWIG_arg_fail(2)) SWIG_fail;
34944 }
34945 {
34946 arg3 = wxString_in_helper(obj2);
34947 if (arg3 == NULL) SWIG_fail;
34948 temp3 = true;
34949 }
34950 {
34951 PyThreadState* __tstate = wxPyBeginAllowThreads();
34952 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34953
34954 wxPyEndAllowThreads(__tstate);
34955 if (PyErr_Occurred()) SWIG_fail;
34956 }
34957 Py_INCREF(Py_None); resultobj = Py_None;
34958 {
34959 if (temp3)
34960 delete arg3;
34961 }
34962 return resultobj;
34963 fail:
34964 {
34965 if (temp3)
34966 delete arg3;
34967 }
34968 return NULL;
34969 }
34970
34971
34972 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34973 PyObject *resultobj;
34974 wxMenu *arg1 = (wxMenu *) 0 ;
34975 int arg2 ;
34976 wxString result;
34977 PyObject * obj0 = 0 ;
34978 PyObject * obj1 = 0 ;
34979 char *kwnames[] = {
34980 (char *) "self",(char *) "id", NULL
34981 };
34982
34983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34985 if (SWIG_arg_fail(1)) SWIG_fail;
34986 {
34987 arg2 = (int)(SWIG_As_int(obj1));
34988 if (SWIG_arg_fail(2)) SWIG_fail;
34989 }
34990 {
34991 PyThreadState* __tstate = wxPyBeginAllowThreads();
34992 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34993
34994 wxPyEndAllowThreads(__tstate);
34995 if (PyErr_Occurred()) SWIG_fail;
34996 }
34997 {
34998 #if wxUSE_UNICODE
34999 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35000 #else
35001 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35002 #endif
35003 }
35004 return resultobj;
35005 fail:
35006 return NULL;
35007 }
35008
35009
35010 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35011 PyObject *resultobj;
35012 wxMenu *arg1 = (wxMenu *) 0 ;
35013 wxString *arg2 = 0 ;
35014 bool temp2 = false ;
35015 PyObject * obj0 = 0 ;
35016 PyObject * obj1 = 0 ;
35017 char *kwnames[] = {
35018 (char *) "self",(char *) "title", NULL
35019 };
35020
35021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
35022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35023 if (SWIG_arg_fail(1)) SWIG_fail;
35024 {
35025 arg2 = wxString_in_helper(obj1);
35026 if (arg2 == NULL) SWIG_fail;
35027 temp2 = true;
35028 }
35029 {
35030 PyThreadState* __tstate = wxPyBeginAllowThreads();
35031 (arg1)->SetTitle((wxString const &)*arg2);
35032
35033 wxPyEndAllowThreads(__tstate);
35034 if (PyErr_Occurred()) SWIG_fail;
35035 }
35036 Py_INCREF(Py_None); resultobj = Py_None;
35037 {
35038 if (temp2)
35039 delete arg2;
35040 }
35041 return resultobj;
35042 fail:
35043 {
35044 if (temp2)
35045 delete arg2;
35046 }
35047 return NULL;
35048 }
35049
35050
35051 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
35052 PyObject *resultobj;
35053 wxMenu *arg1 = (wxMenu *) 0 ;
35054 wxString result;
35055 PyObject * obj0 = 0 ;
35056 char *kwnames[] = {
35057 (char *) "self", NULL
35058 };
35059
35060 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
35061 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35062 if (SWIG_arg_fail(1)) SWIG_fail;
35063 {
35064 PyThreadState* __tstate = wxPyBeginAllowThreads();
35065 result = ((wxMenu const *)arg1)->GetTitle();
35066
35067 wxPyEndAllowThreads(__tstate);
35068 if (PyErr_Occurred()) SWIG_fail;
35069 }
35070 {
35071 #if wxUSE_UNICODE
35072 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35073 #else
35074 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35075 #endif
35076 }
35077 return resultobj;
35078 fail:
35079 return NULL;
35080 }
35081
35082
35083 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35084 PyObject *resultobj;
35085 wxMenu *arg1 = (wxMenu *) 0 ;
35086 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
35087 PyObject * obj0 = 0 ;
35088 PyObject * obj1 = 0 ;
35089 char *kwnames[] = {
35090 (char *) "self",(char *) "handler", NULL
35091 };
35092
35093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
35094 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35095 if (SWIG_arg_fail(1)) SWIG_fail;
35096 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35097 if (SWIG_arg_fail(2)) SWIG_fail;
35098 {
35099 PyThreadState* __tstate = wxPyBeginAllowThreads();
35100 (arg1)->SetEventHandler(arg2);
35101
35102 wxPyEndAllowThreads(__tstate);
35103 if (PyErr_Occurred()) SWIG_fail;
35104 }
35105 Py_INCREF(Py_None); resultobj = Py_None;
35106 return resultobj;
35107 fail:
35108 return NULL;
35109 }
35110
35111
35112 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
35113 PyObject *resultobj;
35114 wxMenu *arg1 = (wxMenu *) 0 ;
35115 wxEvtHandler *result;
35116 PyObject * obj0 = 0 ;
35117 char *kwnames[] = {
35118 (char *) "self", NULL
35119 };
35120
35121 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
35122 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35123 if (SWIG_arg_fail(1)) SWIG_fail;
35124 {
35125 PyThreadState* __tstate = wxPyBeginAllowThreads();
35126 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
35127
35128 wxPyEndAllowThreads(__tstate);
35129 if (PyErr_Occurred()) SWIG_fail;
35130 }
35131 {
35132 resultobj = wxPyMake_wxObject(result, 0);
35133 }
35134 return resultobj;
35135 fail:
35136 return NULL;
35137 }
35138
35139
35140 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35141 PyObject *resultobj;
35142 wxMenu *arg1 = (wxMenu *) 0 ;
35143 wxWindow *arg2 = (wxWindow *) 0 ;
35144 PyObject * obj0 = 0 ;
35145 PyObject * obj1 = 0 ;
35146 char *kwnames[] = {
35147 (char *) "self",(char *) "win", NULL
35148 };
35149
35150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
35151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35152 if (SWIG_arg_fail(1)) SWIG_fail;
35153 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
35154 if (SWIG_arg_fail(2)) SWIG_fail;
35155 {
35156 PyThreadState* __tstate = wxPyBeginAllowThreads();
35157 (arg1)->SetInvokingWindow(arg2);
35158
35159 wxPyEndAllowThreads(__tstate);
35160 if (PyErr_Occurred()) SWIG_fail;
35161 }
35162 Py_INCREF(Py_None); resultobj = Py_None;
35163 return resultobj;
35164 fail:
35165 return NULL;
35166 }
35167
35168
35169 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
35170 PyObject *resultobj;
35171 wxMenu *arg1 = (wxMenu *) 0 ;
35172 wxWindow *result;
35173 PyObject * obj0 = 0 ;
35174 char *kwnames[] = {
35175 (char *) "self", NULL
35176 };
35177
35178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
35179 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35180 if (SWIG_arg_fail(1)) SWIG_fail;
35181 {
35182 PyThreadState* __tstate = wxPyBeginAllowThreads();
35183 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
35184
35185 wxPyEndAllowThreads(__tstate);
35186 if (PyErr_Occurred()) SWIG_fail;
35187 }
35188 {
35189 resultobj = wxPyMake_wxObject(result, 0);
35190 }
35191 return resultobj;
35192 fail:
35193 return NULL;
35194 }
35195
35196
35197 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
35198 PyObject *resultobj;
35199 wxMenu *arg1 = (wxMenu *) 0 ;
35200 long result;
35201 PyObject * obj0 = 0 ;
35202 char *kwnames[] = {
35203 (char *) "self", NULL
35204 };
35205
35206 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
35207 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35208 if (SWIG_arg_fail(1)) SWIG_fail;
35209 {
35210 PyThreadState* __tstate = wxPyBeginAllowThreads();
35211 result = (long)((wxMenu const *)arg1)->GetStyle();
35212
35213 wxPyEndAllowThreads(__tstate);
35214 if (PyErr_Occurred()) SWIG_fail;
35215 }
35216 {
35217 resultobj = SWIG_From_long((long)(result));
35218 }
35219 return resultobj;
35220 fail:
35221 return NULL;
35222 }
35223
35224
35225 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
35226 PyObject *resultobj;
35227 wxMenu *arg1 = (wxMenu *) 0 ;
35228 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
35229 PyObject * obj0 = 0 ;
35230 PyObject * obj1 = 0 ;
35231 char *kwnames[] = {
35232 (char *) "self",(char *) "source", NULL
35233 };
35234
35235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
35236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35237 if (SWIG_arg_fail(1)) SWIG_fail;
35238 if (obj1) {
35239 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
35240 if (SWIG_arg_fail(2)) SWIG_fail;
35241 }
35242 {
35243 PyThreadState* __tstate = wxPyBeginAllowThreads();
35244 (arg1)->UpdateUI(arg2);
35245
35246 wxPyEndAllowThreads(__tstate);
35247 if (PyErr_Occurred()) SWIG_fail;
35248 }
35249 Py_INCREF(Py_None); resultobj = Py_None;
35250 return resultobj;
35251 fail:
35252 return NULL;
35253 }
35254
35255
35256 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35257 PyObject *resultobj;
35258 wxMenu *arg1 = (wxMenu *) 0 ;
35259 wxMenuBar *result;
35260 PyObject * obj0 = 0 ;
35261 char *kwnames[] = {
35262 (char *) "self", NULL
35263 };
35264
35265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
35266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35267 if (SWIG_arg_fail(1)) SWIG_fail;
35268 {
35269 PyThreadState* __tstate = wxPyBeginAllowThreads();
35270 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
35271
35272 wxPyEndAllowThreads(__tstate);
35273 if (PyErr_Occurred()) SWIG_fail;
35274 }
35275 {
35276 resultobj = wxPyMake_wxObject(result, 0);
35277 }
35278 return resultobj;
35279 fail:
35280 return NULL;
35281 }
35282
35283
35284 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35285 PyObject *resultobj;
35286 wxMenu *arg1 = (wxMenu *) 0 ;
35287 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
35288 PyObject * obj0 = 0 ;
35289 PyObject * obj1 = 0 ;
35290 char *kwnames[] = {
35291 (char *) "self",(char *) "menubar", NULL
35292 };
35293
35294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
35295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35296 if (SWIG_arg_fail(1)) SWIG_fail;
35297 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
35298 if (SWIG_arg_fail(2)) SWIG_fail;
35299 {
35300 PyThreadState* __tstate = wxPyBeginAllowThreads();
35301 (arg1)->Attach(arg2);
35302
35303 wxPyEndAllowThreads(__tstate);
35304 if (PyErr_Occurred()) SWIG_fail;
35305 }
35306 Py_INCREF(Py_None); resultobj = Py_None;
35307 return resultobj;
35308 fail:
35309 return NULL;
35310 }
35311
35312
35313 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35314 PyObject *resultobj;
35315 wxMenu *arg1 = (wxMenu *) 0 ;
35316 PyObject * obj0 = 0 ;
35317 char *kwnames[] = {
35318 (char *) "self", NULL
35319 };
35320
35321 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
35322 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35323 if (SWIG_arg_fail(1)) SWIG_fail;
35324 {
35325 PyThreadState* __tstate = wxPyBeginAllowThreads();
35326 (arg1)->Detach();
35327
35328 wxPyEndAllowThreads(__tstate);
35329 if (PyErr_Occurred()) SWIG_fail;
35330 }
35331 Py_INCREF(Py_None); resultobj = Py_None;
35332 return resultobj;
35333 fail:
35334 return NULL;
35335 }
35336
35337
35338 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35339 PyObject *resultobj;
35340 wxMenu *arg1 = (wxMenu *) 0 ;
35341 bool result;
35342 PyObject * obj0 = 0 ;
35343 char *kwnames[] = {
35344 (char *) "self", NULL
35345 };
35346
35347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
35348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35349 if (SWIG_arg_fail(1)) SWIG_fail;
35350 {
35351 PyThreadState* __tstate = wxPyBeginAllowThreads();
35352 result = (bool)((wxMenu const *)arg1)->IsAttached();
35353
35354 wxPyEndAllowThreads(__tstate);
35355 if (PyErr_Occurred()) SWIG_fail;
35356 }
35357 {
35358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35359 }
35360 return resultobj;
35361 fail:
35362 return NULL;
35363 }
35364
35365
35366 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35367 PyObject *resultobj;
35368 wxMenu *arg1 = (wxMenu *) 0 ;
35369 wxMenu *arg2 = (wxMenu *) 0 ;
35370 PyObject * obj0 = 0 ;
35371 PyObject * obj1 = 0 ;
35372 char *kwnames[] = {
35373 (char *) "self",(char *) "parent", NULL
35374 };
35375
35376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
35377 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35378 if (SWIG_arg_fail(1)) SWIG_fail;
35379 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35380 if (SWIG_arg_fail(2)) SWIG_fail;
35381 {
35382 PyThreadState* __tstate = wxPyBeginAllowThreads();
35383 (arg1)->SetParent(arg2);
35384
35385 wxPyEndAllowThreads(__tstate);
35386 if (PyErr_Occurred()) SWIG_fail;
35387 }
35388 Py_INCREF(Py_None); resultobj = Py_None;
35389 return resultobj;
35390 fail:
35391 return NULL;
35392 }
35393
35394
35395 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
35396 PyObject *resultobj;
35397 wxMenu *arg1 = (wxMenu *) 0 ;
35398 wxMenu *result;
35399 PyObject * obj0 = 0 ;
35400 char *kwnames[] = {
35401 (char *) "self", NULL
35402 };
35403
35404 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
35405 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35406 if (SWIG_arg_fail(1)) SWIG_fail;
35407 {
35408 PyThreadState* __tstate = wxPyBeginAllowThreads();
35409 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
35410
35411 wxPyEndAllowThreads(__tstate);
35412 if (PyErr_Occurred()) SWIG_fail;
35413 }
35414 {
35415 resultobj = wxPyMake_wxObject(result, 0);
35416 }
35417 return resultobj;
35418 fail:
35419 return NULL;
35420 }
35421
35422
35423 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
35424 PyObject *obj;
35425 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35426 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
35427 Py_INCREF(obj);
35428 return Py_BuildValue((char *)"");
35429 }
35430 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
35431 PyObject *resultobj;
35432 long arg1 = (long) 0 ;
35433 wxMenuBar *result;
35434 PyObject * obj0 = 0 ;
35435 char *kwnames[] = {
35436 (char *) "style", NULL
35437 };
35438
35439 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
35440 if (obj0) {
35441 {
35442 arg1 = (long)(SWIG_As_long(obj0));
35443 if (SWIG_arg_fail(1)) SWIG_fail;
35444 }
35445 }
35446 {
35447 if (!wxPyCheckForApp()) SWIG_fail;
35448 PyThreadState* __tstate = wxPyBeginAllowThreads();
35449 result = (wxMenuBar *)new wxMenuBar(arg1);
35450
35451 wxPyEndAllowThreads(__tstate);
35452 if (PyErr_Occurred()) SWIG_fail;
35453 }
35454 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
35455 return resultobj;
35456 fail:
35457 return NULL;
35458 }
35459
35460
35461 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
35462 PyObject *resultobj;
35463 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35464 wxMenu *arg2 = (wxMenu *) 0 ;
35465 wxString *arg3 = 0 ;
35466 bool result;
35467 bool temp3 = false ;
35468 PyObject * obj0 = 0 ;
35469 PyObject * obj1 = 0 ;
35470 PyObject * obj2 = 0 ;
35471 char *kwnames[] = {
35472 (char *) "self",(char *) "menu",(char *) "title", NULL
35473 };
35474
35475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
35476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35477 if (SWIG_arg_fail(1)) SWIG_fail;
35478 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35479 if (SWIG_arg_fail(2)) SWIG_fail;
35480 {
35481 arg3 = wxString_in_helper(obj2);
35482 if (arg3 == NULL) SWIG_fail;
35483 temp3 = true;
35484 }
35485 {
35486 PyThreadState* __tstate = wxPyBeginAllowThreads();
35487 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
35488
35489 wxPyEndAllowThreads(__tstate);
35490 if (PyErr_Occurred()) SWIG_fail;
35491 }
35492 {
35493 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35494 }
35495 {
35496 if (temp3)
35497 delete arg3;
35498 }
35499 return resultobj;
35500 fail:
35501 {
35502 if (temp3)
35503 delete arg3;
35504 }
35505 return NULL;
35506 }
35507
35508
35509 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
35510 PyObject *resultobj;
35511 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35512 size_t arg2 ;
35513 wxMenu *arg3 = (wxMenu *) 0 ;
35514 wxString *arg4 = 0 ;
35515 bool result;
35516 bool temp4 = false ;
35517 PyObject * obj0 = 0 ;
35518 PyObject * obj1 = 0 ;
35519 PyObject * obj2 = 0 ;
35520 PyObject * obj3 = 0 ;
35521 char *kwnames[] = {
35522 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35523 };
35524
35525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35527 if (SWIG_arg_fail(1)) SWIG_fail;
35528 {
35529 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35530 if (SWIG_arg_fail(2)) SWIG_fail;
35531 }
35532 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35533 if (SWIG_arg_fail(3)) SWIG_fail;
35534 {
35535 arg4 = wxString_in_helper(obj3);
35536 if (arg4 == NULL) SWIG_fail;
35537 temp4 = true;
35538 }
35539 {
35540 PyThreadState* __tstate = wxPyBeginAllowThreads();
35541 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
35542
35543 wxPyEndAllowThreads(__tstate);
35544 if (PyErr_Occurred()) SWIG_fail;
35545 }
35546 {
35547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35548 }
35549 {
35550 if (temp4)
35551 delete arg4;
35552 }
35553 return resultobj;
35554 fail:
35555 {
35556 if (temp4)
35557 delete arg4;
35558 }
35559 return NULL;
35560 }
35561
35562
35563 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
35564 PyObject *resultobj;
35565 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35566 size_t result;
35567 PyObject * obj0 = 0 ;
35568 char *kwnames[] = {
35569 (char *) "self", NULL
35570 };
35571
35572 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35573 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35574 if (SWIG_arg_fail(1)) SWIG_fail;
35575 {
35576 PyThreadState* __tstate = wxPyBeginAllowThreads();
35577 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35578
35579 wxPyEndAllowThreads(__tstate);
35580 if (PyErr_Occurred()) SWIG_fail;
35581 }
35582 {
35583 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35584 }
35585 return resultobj;
35586 fail:
35587 return NULL;
35588 }
35589
35590
35591 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35592 PyObject *resultobj;
35593 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35594 size_t arg2 ;
35595 wxMenu *result;
35596 PyObject * obj0 = 0 ;
35597 PyObject * obj1 = 0 ;
35598 char *kwnames[] = {
35599 (char *) "self",(char *) "pos", NULL
35600 };
35601
35602 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35603 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35604 if (SWIG_arg_fail(1)) SWIG_fail;
35605 {
35606 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35607 if (SWIG_arg_fail(2)) SWIG_fail;
35608 }
35609 {
35610 PyThreadState* __tstate = wxPyBeginAllowThreads();
35611 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35612
35613 wxPyEndAllowThreads(__tstate);
35614 if (PyErr_Occurred()) SWIG_fail;
35615 }
35616 {
35617 resultobj = wxPyMake_wxObject(result, 0);
35618 }
35619 return resultobj;
35620 fail:
35621 return NULL;
35622 }
35623
35624
35625 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35626 PyObject *resultobj;
35627 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35628 size_t arg2 ;
35629 wxMenu *arg3 = (wxMenu *) 0 ;
35630 wxString *arg4 = 0 ;
35631 wxMenu *result;
35632 bool temp4 = false ;
35633 PyObject * obj0 = 0 ;
35634 PyObject * obj1 = 0 ;
35635 PyObject * obj2 = 0 ;
35636 PyObject * obj3 = 0 ;
35637 char *kwnames[] = {
35638 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35639 };
35640
35641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35643 if (SWIG_arg_fail(1)) SWIG_fail;
35644 {
35645 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35646 if (SWIG_arg_fail(2)) SWIG_fail;
35647 }
35648 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35649 if (SWIG_arg_fail(3)) SWIG_fail;
35650 {
35651 arg4 = wxString_in_helper(obj3);
35652 if (arg4 == NULL) SWIG_fail;
35653 temp4 = true;
35654 }
35655 {
35656 PyThreadState* __tstate = wxPyBeginAllowThreads();
35657 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35658
35659 wxPyEndAllowThreads(__tstate);
35660 if (PyErr_Occurred()) SWIG_fail;
35661 }
35662 {
35663 resultobj = wxPyMake_wxObject(result, 0);
35664 }
35665 {
35666 if (temp4)
35667 delete arg4;
35668 }
35669 return resultobj;
35670 fail:
35671 {
35672 if (temp4)
35673 delete arg4;
35674 }
35675 return NULL;
35676 }
35677
35678
35679 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35680 PyObject *resultobj;
35681 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35682 size_t arg2 ;
35683 wxMenu *result;
35684 PyObject * obj0 = 0 ;
35685 PyObject * obj1 = 0 ;
35686 char *kwnames[] = {
35687 (char *) "self",(char *) "pos", NULL
35688 };
35689
35690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35692 if (SWIG_arg_fail(1)) SWIG_fail;
35693 {
35694 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35695 if (SWIG_arg_fail(2)) SWIG_fail;
35696 }
35697 {
35698 PyThreadState* __tstate = wxPyBeginAllowThreads();
35699 result = (wxMenu *)(arg1)->Remove(arg2);
35700
35701 wxPyEndAllowThreads(__tstate);
35702 if (PyErr_Occurred()) SWIG_fail;
35703 }
35704 {
35705 resultobj = wxPyMake_wxObject(result, 0);
35706 }
35707 return resultobj;
35708 fail:
35709 return NULL;
35710 }
35711
35712
35713 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35714 PyObject *resultobj;
35715 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35716 size_t arg2 ;
35717 bool arg3 ;
35718 PyObject * obj0 = 0 ;
35719 PyObject * obj1 = 0 ;
35720 PyObject * obj2 = 0 ;
35721 char *kwnames[] = {
35722 (char *) "self",(char *) "pos",(char *) "enable", NULL
35723 };
35724
35725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35727 if (SWIG_arg_fail(1)) SWIG_fail;
35728 {
35729 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35730 if (SWIG_arg_fail(2)) SWIG_fail;
35731 }
35732 {
35733 arg3 = (bool)(SWIG_As_bool(obj2));
35734 if (SWIG_arg_fail(3)) SWIG_fail;
35735 }
35736 {
35737 PyThreadState* __tstate = wxPyBeginAllowThreads();
35738 (arg1)->EnableTop(arg2,arg3);
35739
35740 wxPyEndAllowThreads(__tstate);
35741 if (PyErr_Occurred()) SWIG_fail;
35742 }
35743 Py_INCREF(Py_None); resultobj = Py_None;
35744 return resultobj;
35745 fail:
35746 return NULL;
35747 }
35748
35749
35750 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35751 PyObject *resultobj;
35752 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35753 size_t arg2 ;
35754 bool result;
35755 PyObject * obj0 = 0 ;
35756 PyObject * obj1 = 0 ;
35757 char *kwnames[] = {
35758 (char *) "self",(char *) "pos", NULL
35759 };
35760
35761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35763 if (SWIG_arg_fail(1)) SWIG_fail;
35764 {
35765 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35766 if (SWIG_arg_fail(2)) SWIG_fail;
35767 }
35768 {
35769 PyThreadState* __tstate = wxPyBeginAllowThreads();
35770 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35771
35772 wxPyEndAllowThreads(__tstate);
35773 if (PyErr_Occurred()) SWIG_fail;
35774 }
35775 {
35776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35777 }
35778 return resultobj;
35779 fail:
35780 return NULL;
35781 }
35782
35783
35784 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35785 PyObject *resultobj;
35786 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35787 size_t arg2 ;
35788 wxString *arg3 = 0 ;
35789 bool temp3 = false ;
35790 PyObject * obj0 = 0 ;
35791 PyObject * obj1 = 0 ;
35792 PyObject * obj2 = 0 ;
35793 char *kwnames[] = {
35794 (char *) "self",(char *) "pos",(char *) "label", NULL
35795 };
35796
35797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35799 if (SWIG_arg_fail(1)) SWIG_fail;
35800 {
35801 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35802 if (SWIG_arg_fail(2)) SWIG_fail;
35803 }
35804 {
35805 arg3 = wxString_in_helper(obj2);
35806 if (arg3 == NULL) SWIG_fail;
35807 temp3 = true;
35808 }
35809 {
35810 PyThreadState* __tstate = wxPyBeginAllowThreads();
35811 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35812
35813 wxPyEndAllowThreads(__tstate);
35814 if (PyErr_Occurred()) SWIG_fail;
35815 }
35816 Py_INCREF(Py_None); resultobj = Py_None;
35817 {
35818 if (temp3)
35819 delete arg3;
35820 }
35821 return resultobj;
35822 fail:
35823 {
35824 if (temp3)
35825 delete arg3;
35826 }
35827 return NULL;
35828 }
35829
35830
35831 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35832 PyObject *resultobj;
35833 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35834 size_t arg2 ;
35835 wxString result;
35836 PyObject * obj0 = 0 ;
35837 PyObject * obj1 = 0 ;
35838 char *kwnames[] = {
35839 (char *) "self",(char *) "pos", NULL
35840 };
35841
35842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35844 if (SWIG_arg_fail(1)) SWIG_fail;
35845 {
35846 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35847 if (SWIG_arg_fail(2)) SWIG_fail;
35848 }
35849 {
35850 PyThreadState* __tstate = wxPyBeginAllowThreads();
35851 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35852
35853 wxPyEndAllowThreads(__tstate);
35854 if (PyErr_Occurred()) SWIG_fail;
35855 }
35856 {
35857 #if wxUSE_UNICODE
35858 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35859 #else
35860 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35861 #endif
35862 }
35863 return resultobj;
35864 fail:
35865 return NULL;
35866 }
35867
35868
35869 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35870 PyObject *resultobj;
35871 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35872 wxString *arg2 = 0 ;
35873 wxString *arg3 = 0 ;
35874 int result;
35875 bool temp2 = false ;
35876 bool temp3 = false ;
35877 PyObject * obj0 = 0 ;
35878 PyObject * obj1 = 0 ;
35879 PyObject * obj2 = 0 ;
35880 char *kwnames[] = {
35881 (char *) "self",(char *) "menu",(char *) "item", NULL
35882 };
35883
35884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35885 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35886 if (SWIG_arg_fail(1)) SWIG_fail;
35887 {
35888 arg2 = wxString_in_helper(obj1);
35889 if (arg2 == NULL) SWIG_fail;
35890 temp2 = true;
35891 }
35892 {
35893 arg3 = wxString_in_helper(obj2);
35894 if (arg3 == NULL) SWIG_fail;
35895 temp3 = true;
35896 }
35897 {
35898 PyThreadState* __tstate = wxPyBeginAllowThreads();
35899 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35900
35901 wxPyEndAllowThreads(__tstate);
35902 if (PyErr_Occurred()) SWIG_fail;
35903 }
35904 {
35905 resultobj = SWIG_From_int((int)(result));
35906 }
35907 {
35908 if (temp2)
35909 delete arg2;
35910 }
35911 {
35912 if (temp3)
35913 delete arg3;
35914 }
35915 return resultobj;
35916 fail:
35917 {
35918 if (temp2)
35919 delete arg2;
35920 }
35921 {
35922 if (temp3)
35923 delete arg3;
35924 }
35925 return NULL;
35926 }
35927
35928
35929 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35930 PyObject *resultobj;
35931 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35932 int arg2 ;
35933 wxMenuItem *result;
35934 PyObject * obj0 = 0 ;
35935 PyObject * obj1 = 0 ;
35936 char *kwnames[] = {
35937 (char *) "self",(char *) "id", NULL
35938 };
35939
35940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35942 if (SWIG_arg_fail(1)) SWIG_fail;
35943 {
35944 arg2 = (int)(SWIG_As_int(obj1));
35945 if (SWIG_arg_fail(2)) SWIG_fail;
35946 }
35947 {
35948 PyThreadState* __tstate = wxPyBeginAllowThreads();
35949 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35950
35951 wxPyEndAllowThreads(__tstate);
35952 if (PyErr_Occurred()) SWIG_fail;
35953 }
35954 {
35955 resultobj = wxPyMake_wxObject(result, 0);
35956 }
35957 return resultobj;
35958 fail:
35959 return NULL;
35960 }
35961
35962
35963 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35964 PyObject *resultobj;
35965 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35966 wxString *arg2 = 0 ;
35967 int result;
35968 bool temp2 = false ;
35969 PyObject * obj0 = 0 ;
35970 PyObject * obj1 = 0 ;
35971 char *kwnames[] = {
35972 (char *) "self",(char *) "title", NULL
35973 };
35974
35975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35977 if (SWIG_arg_fail(1)) SWIG_fail;
35978 {
35979 arg2 = wxString_in_helper(obj1);
35980 if (arg2 == NULL) SWIG_fail;
35981 temp2 = true;
35982 }
35983 {
35984 PyThreadState* __tstate = wxPyBeginAllowThreads();
35985 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
35986
35987 wxPyEndAllowThreads(__tstate);
35988 if (PyErr_Occurred()) SWIG_fail;
35989 }
35990 {
35991 resultobj = SWIG_From_int((int)(result));
35992 }
35993 {
35994 if (temp2)
35995 delete arg2;
35996 }
35997 return resultobj;
35998 fail:
35999 {
36000 if (temp2)
36001 delete arg2;
36002 }
36003 return NULL;
36004 }
36005
36006
36007 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36008 PyObject *resultobj;
36009 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36010 int arg2 ;
36011 bool arg3 ;
36012 PyObject * obj0 = 0 ;
36013 PyObject * obj1 = 0 ;
36014 PyObject * obj2 = 0 ;
36015 char *kwnames[] = {
36016 (char *) "self",(char *) "id",(char *) "enable", NULL
36017 };
36018
36019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
36020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36021 if (SWIG_arg_fail(1)) SWIG_fail;
36022 {
36023 arg2 = (int)(SWIG_As_int(obj1));
36024 if (SWIG_arg_fail(2)) SWIG_fail;
36025 }
36026 {
36027 arg3 = (bool)(SWIG_As_bool(obj2));
36028 if (SWIG_arg_fail(3)) SWIG_fail;
36029 }
36030 {
36031 PyThreadState* __tstate = wxPyBeginAllowThreads();
36032 (arg1)->Enable(arg2,arg3);
36033
36034 wxPyEndAllowThreads(__tstate);
36035 if (PyErr_Occurred()) SWIG_fail;
36036 }
36037 Py_INCREF(Py_None); resultobj = Py_None;
36038 return resultobj;
36039 fail:
36040 return NULL;
36041 }
36042
36043
36044 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36045 PyObject *resultobj;
36046 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36047 int arg2 ;
36048 bool arg3 ;
36049 PyObject * obj0 = 0 ;
36050 PyObject * obj1 = 0 ;
36051 PyObject * obj2 = 0 ;
36052 char *kwnames[] = {
36053 (char *) "self",(char *) "id",(char *) "check", NULL
36054 };
36055
36056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
36057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36058 if (SWIG_arg_fail(1)) SWIG_fail;
36059 {
36060 arg2 = (int)(SWIG_As_int(obj1));
36061 if (SWIG_arg_fail(2)) SWIG_fail;
36062 }
36063 {
36064 arg3 = (bool)(SWIG_As_bool(obj2));
36065 if (SWIG_arg_fail(3)) SWIG_fail;
36066 }
36067 {
36068 PyThreadState* __tstate = wxPyBeginAllowThreads();
36069 (arg1)->Check(arg2,arg3);
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_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36082 PyObject *resultobj;
36083 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36084 int arg2 ;
36085 bool result;
36086 PyObject * obj0 = 0 ;
36087 PyObject * obj1 = 0 ;
36088 char *kwnames[] = {
36089 (char *) "self",(char *) "id", NULL
36090 };
36091
36092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
36093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36094 if (SWIG_arg_fail(1)) SWIG_fail;
36095 {
36096 arg2 = (int)(SWIG_As_int(obj1));
36097 if (SWIG_arg_fail(2)) SWIG_fail;
36098 }
36099 {
36100 PyThreadState* __tstate = wxPyBeginAllowThreads();
36101 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
36102
36103 wxPyEndAllowThreads(__tstate);
36104 if (PyErr_Occurred()) SWIG_fail;
36105 }
36106 {
36107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36108 }
36109 return resultobj;
36110 fail:
36111 return NULL;
36112 }
36113
36114
36115 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36116 PyObject *resultobj;
36117 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36118 int arg2 ;
36119 bool result;
36120 PyObject * obj0 = 0 ;
36121 PyObject * obj1 = 0 ;
36122 char *kwnames[] = {
36123 (char *) "self",(char *) "id", NULL
36124 };
36125
36126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
36127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36128 if (SWIG_arg_fail(1)) SWIG_fail;
36129 {
36130 arg2 = (int)(SWIG_As_int(obj1));
36131 if (SWIG_arg_fail(2)) SWIG_fail;
36132 }
36133 {
36134 PyThreadState* __tstate = wxPyBeginAllowThreads();
36135 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
36136
36137 wxPyEndAllowThreads(__tstate);
36138 if (PyErr_Occurred()) SWIG_fail;
36139 }
36140 {
36141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36142 }
36143 return resultobj;
36144 fail:
36145 return NULL;
36146 }
36147
36148
36149 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36150 PyObject *resultobj;
36151 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36152 int arg2 ;
36153 wxString *arg3 = 0 ;
36154 bool temp3 = false ;
36155 PyObject * obj0 = 0 ;
36156 PyObject * obj1 = 0 ;
36157 PyObject * obj2 = 0 ;
36158 char *kwnames[] = {
36159 (char *) "self",(char *) "id",(char *) "label", NULL
36160 };
36161
36162 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
36163 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36164 if (SWIG_arg_fail(1)) SWIG_fail;
36165 {
36166 arg2 = (int)(SWIG_As_int(obj1));
36167 if (SWIG_arg_fail(2)) SWIG_fail;
36168 }
36169 {
36170 arg3 = wxString_in_helper(obj2);
36171 if (arg3 == NULL) SWIG_fail;
36172 temp3 = true;
36173 }
36174 {
36175 PyThreadState* __tstate = wxPyBeginAllowThreads();
36176 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
36177
36178 wxPyEndAllowThreads(__tstate);
36179 if (PyErr_Occurred()) SWIG_fail;
36180 }
36181 Py_INCREF(Py_None); resultobj = Py_None;
36182 {
36183 if (temp3)
36184 delete arg3;
36185 }
36186 return resultobj;
36187 fail:
36188 {
36189 if (temp3)
36190 delete arg3;
36191 }
36192 return NULL;
36193 }
36194
36195
36196 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36197 PyObject *resultobj;
36198 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36199 int arg2 ;
36200 wxString result;
36201 PyObject * obj0 = 0 ;
36202 PyObject * obj1 = 0 ;
36203 char *kwnames[] = {
36204 (char *) "self",(char *) "id", NULL
36205 };
36206
36207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
36208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36209 if (SWIG_arg_fail(1)) SWIG_fail;
36210 {
36211 arg2 = (int)(SWIG_As_int(obj1));
36212 if (SWIG_arg_fail(2)) SWIG_fail;
36213 }
36214 {
36215 PyThreadState* __tstate = wxPyBeginAllowThreads();
36216 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
36217
36218 wxPyEndAllowThreads(__tstate);
36219 if (PyErr_Occurred()) SWIG_fail;
36220 }
36221 {
36222 #if wxUSE_UNICODE
36223 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36224 #else
36225 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36226 #endif
36227 }
36228 return resultobj;
36229 fail:
36230 return NULL;
36231 }
36232
36233
36234 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36235 PyObject *resultobj;
36236 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36237 int arg2 ;
36238 wxString *arg3 = 0 ;
36239 bool temp3 = false ;
36240 PyObject * obj0 = 0 ;
36241 PyObject * obj1 = 0 ;
36242 PyObject * obj2 = 0 ;
36243 char *kwnames[] = {
36244 (char *) "self",(char *) "id",(char *) "helpString", NULL
36245 };
36246
36247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
36248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36249 if (SWIG_arg_fail(1)) SWIG_fail;
36250 {
36251 arg2 = (int)(SWIG_As_int(obj1));
36252 if (SWIG_arg_fail(2)) SWIG_fail;
36253 }
36254 {
36255 arg3 = wxString_in_helper(obj2);
36256 if (arg3 == NULL) SWIG_fail;
36257 temp3 = true;
36258 }
36259 {
36260 PyThreadState* __tstate = wxPyBeginAllowThreads();
36261 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
36262
36263 wxPyEndAllowThreads(__tstate);
36264 if (PyErr_Occurred()) SWIG_fail;
36265 }
36266 Py_INCREF(Py_None); resultobj = Py_None;
36267 {
36268 if (temp3)
36269 delete arg3;
36270 }
36271 return resultobj;
36272 fail:
36273 {
36274 if (temp3)
36275 delete arg3;
36276 }
36277 return NULL;
36278 }
36279
36280
36281 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
36282 PyObject *resultobj;
36283 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36284 int arg2 ;
36285 wxString result;
36286 PyObject * obj0 = 0 ;
36287 PyObject * obj1 = 0 ;
36288 char *kwnames[] = {
36289 (char *) "self",(char *) "id", NULL
36290 };
36291
36292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
36293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36294 if (SWIG_arg_fail(1)) SWIG_fail;
36295 {
36296 arg2 = (int)(SWIG_As_int(obj1));
36297 if (SWIG_arg_fail(2)) SWIG_fail;
36298 }
36299 {
36300 PyThreadState* __tstate = wxPyBeginAllowThreads();
36301 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
36302
36303 wxPyEndAllowThreads(__tstate);
36304 if (PyErr_Occurred()) SWIG_fail;
36305 }
36306 {
36307 #if wxUSE_UNICODE
36308 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36309 #else
36310 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36311 #endif
36312 }
36313 return resultobj;
36314 fail:
36315 return NULL;
36316 }
36317
36318
36319 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
36320 PyObject *resultobj;
36321 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36322 wxFrame *result;
36323 PyObject * obj0 = 0 ;
36324 char *kwnames[] = {
36325 (char *) "self", NULL
36326 };
36327
36328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
36329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36330 if (SWIG_arg_fail(1)) SWIG_fail;
36331 {
36332 PyThreadState* __tstate = wxPyBeginAllowThreads();
36333 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
36334
36335 wxPyEndAllowThreads(__tstate);
36336 if (PyErr_Occurred()) SWIG_fail;
36337 }
36338 {
36339 resultobj = wxPyMake_wxObject(result, 0);
36340 }
36341 return resultobj;
36342 fail:
36343 return NULL;
36344 }
36345
36346
36347 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
36348 PyObject *resultobj;
36349 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36350 bool result;
36351 PyObject * obj0 = 0 ;
36352 char *kwnames[] = {
36353 (char *) "self", NULL
36354 };
36355
36356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
36357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36358 if (SWIG_arg_fail(1)) SWIG_fail;
36359 {
36360 PyThreadState* __tstate = wxPyBeginAllowThreads();
36361 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
36362
36363 wxPyEndAllowThreads(__tstate);
36364 if (PyErr_Occurred()) SWIG_fail;
36365 }
36366 {
36367 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36368 }
36369 return resultobj;
36370 fail:
36371 return NULL;
36372 }
36373
36374
36375 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
36376 PyObject *resultobj;
36377 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36378 wxFrame *arg2 = (wxFrame *) 0 ;
36379 PyObject * obj0 = 0 ;
36380 PyObject * obj1 = 0 ;
36381 char *kwnames[] = {
36382 (char *) "self",(char *) "frame", NULL
36383 };
36384
36385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
36386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36387 if (SWIG_arg_fail(1)) SWIG_fail;
36388 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
36389 if (SWIG_arg_fail(2)) SWIG_fail;
36390 {
36391 PyThreadState* __tstate = wxPyBeginAllowThreads();
36392 (arg1)->Attach(arg2);
36393
36394 wxPyEndAllowThreads(__tstate);
36395 if (PyErr_Occurred()) SWIG_fail;
36396 }
36397 Py_INCREF(Py_None); resultobj = Py_None;
36398 return resultobj;
36399 fail:
36400 return NULL;
36401 }
36402
36403
36404 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
36405 PyObject *resultobj;
36406 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
36407 PyObject * obj0 = 0 ;
36408 char *kwnames[] = {
36409 (char *) "self", NULL
36410 };
36411
36412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) goto fail;
36413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
36414 if (SWIG_arg_fail(1)) SWIG_fail;
36415 {
36416 PyThreadState* __tstate = wxPyBeginAllowThreads();
36417 (arg1)->Detach();
36418
36419 wxPyEndAllowThreads(__tstate);
36420 if (PyErr_Occurred()) SWIG_fail;
36421 }
36422 Py_INCREF(Py_None); resultobj = Py_None;
36423 return resultobj;
36424 fail:
36425 return NULL;
36426 }
36427
36428
36429 static PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36430 PyObject *resultobj;
36431 bool arg1 ;
36432 PyObject * obj0 = 0 ;
36433 char *kwnames[] = {
36434 (char *) "enable", NULL
36435 };
36436
36437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) goto fail;
36438 {
36439 arg1 = (bool)(SWIG_As_bool(obj0));
36440 if (SWIG_arg_fail(1)) SWIG_fail;
36441 }
36442 {
36443 PyThreadState* __tstate = wxPyBeginAllowThreads();
36444 MenuBar_SetAutoWindowMenu(arg1);
36445
36446 wxPyEndAllowThreads(__tstate);
36447 if (PyErr_Occurred()) SWIG_fail;
36448 }
36449 Py_INCREF(Py_None); resultobj = Py_None;
36450 return resultobj;
36451 fail:
36452 return NULL;
36453 }
36454
36455
36456 static PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36457 PyObject *resultobj;
36458 bool result;
36459 char *kwnames[] = {
36460 NULL
36461 };
36462
36463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuBar_GetAutoWindowMenu",kwnames)) goto fail;
36464 {
36465 PyThreadState* __tstate = wxPyBeginAllowThreads();
36466 result = (bool)MenuBar_GetAutoWindowMenu();
36467
36468 wxPyEndAllowThreads(__tstate);
36469 if (PyErr_Occurred()) SWIG_fail;
36470 }
36471 {
36472 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36473 }
36474 return resultobj;
36475 fail:
36476 return NULL;
36477 }
36478
36479
36480 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
36481 PyObject *obj;
36482 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
36483 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
36484 Py_INCREF(obj);
36485 return Py_BuildValue((char *)"");
36486 }
36487 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
36488 PyObject *resultobj;
36489 wxMenu *arg1 = (wxMenu *) NULL ;
36490 int arg2 = (int) wxID_ANY ;
36491 wxString const &arg3_defvalue = wxPyEmptyString ;
36492 wxString *arg3 = (wxString *) &arg3_defvalue ;
36493 wxString const &arg4_defvalue = wxPyEmptyString ;
36494 wxString *arg4 = (wxString *) &arg4_defvalue ;
36495 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
36496 wxMenu *arg6 = (wxMenu *) NULL ;
36497 wxMenuItem *result;
36498 bool temp3 = false ;
36499 bool temp4 = false ;
36500 PyObject * obj0 = 0 ;
36501 PyObject * obj1 = 0 ;
36502 PyObject * obj2 = 0 ;
36503 PyObject * obj3 = 0 ;
36504 PyObject * obj4 = 0 ;
36505 PyObject * obj5 = 0 ;
36506 char *kwnames[] = {
36507 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
36508 };
36509
36510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
36511 if (obj0) {
36512 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36513 if (SWIG_arg_fail(1)) SWIG_fail;
36514 }
36515 if (obj1) {
36516 {
36517 arg2 = (int)(SWIG_As_int(obj1));
36518 if (SWIG_arg_fail(2)) SWIG_fail;
36519 }
36520 }
36521 if (obj2) {
36522 {
36523 arg3 = wxString_in_helper(obj2);
36524 if (arg3 == NULL) SWIG_fail;
36525 temp3 = true;
36526 }
36527 }
36528 if (obj3) {
36529 {
36530 arg4 = wxString_in_helper(obj3);
36531 if (arg4 == NULL) SWIG_fail;
36532 temp4 = true;
36533 }
36534 }
36535 if (obj4) {
36536 {
36537 arg5 = (wxItemKind)(SWIG_As_int(obj4));
36538 if (SWIG_arg_fail(5)) SWIG_fail;
36539 }
36540 }
36541 if (obj5) {
36542 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36543 if (SWIG_arg_fail(6)) SWIG_fail;
36544 }
36545 {
36546 PyThreadState* __tstate = wxPyBeginAllowThreads();
36547 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
36548
36549 wxPyEndAllowThreads(__tstate);
36550 if (PyErr_Occurred()) SWIG_fail;
36551 }
36552 {
36553 resultobj = wxPyMake_wxObject(result, 1);
36554 }
36555 {
36556 if (temp3)
36557 delete arg3;
36558 }
36559 {
36560 if (temp4)
36561 delete arg4;
36562 }
36563 return resultobj;
36564 fail:
36565 {
36566 if (temp3)
36567 delete arg3;
36568 }
36569 {
36570 if (temp4)
36571 delete arg4;
36572 }
36573 return NULL;
36574 }
36575
36576
36577 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36578 PyObject *resultobj;
36579 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36580 wxMenu *result;
36581 PyObject * obj0 = 0 ;
36582 char *kwnames[] = {
36583 (char *) "self", NULL
36584 };
36585
36586 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
36587 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36588 if (SWIG_arg_fail(1)) SWIG_fail;
36589 {
36590 PyThreadState* __tstate = wxPyBeginAllowThreads();
36591 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
36592
36593 wxPyEndAllowThreads(__tstate);
36594 if (PyErr_Occurred()) SWIG_fail;
36595 }
36596 {
36597 resultobj = wxPyMake_wxObject(result, 0);
36598 }
36599 return resultobj;
36600 fail:
36601 return NULL;
36602 }
36603
36604
36605 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36606 PyObject *resultobj;
36607 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36608 wxMenu *arg2 = (wxMenu *) 0 ;
36609 PyObject * obj0 = 0 ;
36610 PyObject * obj1 = 0 ;
36611 char *kwnames[] = {
36612 (char *) "self",(char *) "menu", NULL
36613 };
36614
36615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
36616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36617 if (SWIG_arg_fail(1)) SWIG_fail;
36618 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36619 if (SWIG_arg_fail(2)) SWIG_fail;
36620 {
36621 PyThreadState* __tstate = wxPyBeginAllowThreads();
36622 (arg1)->SetMenu(arg2);
36623
36624 wxPyEndAllowThreads(__tstate);
36625 if (PyErr_Occurred()) SWIG_fail;
36626 }
36627 Py_INCREF(Py_None); resultobj = Py_None;
36628 return resultobj;
36629 fail:
36630 return NULL;
36631 }
36632
36633
36634 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36635 PyObject *resultobj;
36636 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36637 int arg2 ;
36638 PyObject * obj0 = 0 ;
36639 PyObject * obj1 = 0 ;
36640 char *kwnames[] = {
36641 (char *) "self",(char *) "id", NULL
36642 };
36643
36644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36646 if (SWIG_arg_fail(1)) SWIG_fail;
36647 {
36648 arg2 = (int)(SWIG_As_int(obj1));
36649 if (SWIG_arg_fail(2)) SWIG_fail;
36650 }
36651 {
36652 PyThreadState* __tstate = wxPyBeginAllowThreads();
36653 (arg1)->SetId(arg2);
36654
36655 wxPyEndAllowThreads(__tstate);
36656 if (PyErr_Occurred()) SWIG_fail;
36657 }
36658 Py_INCREF(Py_None); resultobj = Py_None;
36659 return resultobj;
36660 fail:
36661 return NULL;
36662 }
36663
36664
36665 static PyObject *_wrap_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36666 PyObject *resultobj;
36667 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36668 int result;
36669 PyObject * obj0 = 0 ;
36670 char *kwnames[] = {
36671 (char *) "self", NULL
36672 };
36673
36674 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36675 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36676 if (SWIG_arg_fail(1)) SWIG_fail;
36677 {
36678 PyThreadState* __tstate = wxPyBeginAllowThreads();
36679 result = (int)((wxMenuItem const *)arg1)->GetId();
36680
36681 wxPyEndAllowThreads(__tstate);
36682 if (PyErr_Occurred()) SWIG_fail;
36683 }
36684 {
36685 resultobj = SWIG_From_int((int)(result));
36686 }
36687 return resultobj;
36688 fail:
36689 return NULL;
36690 }
36691
36692
36693 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36694 PyObject *resultobj;
36695 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36696 bool result;
36697 PyObject * obj0 = 0 ;
36698 char *kwnames[] = {
36699 (char *) "self", NULL
36700 };
36701
36702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36704 if (SWIG_arg_fail(1)) SWIG_fail;
36705 {
36706 PyThreadState* __tstate = wxPyBeginAllowThreads();
36707 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36708
36709 wxPyEndAllowThreads(__tstate);
36710 if (PyErr_Occurred()) SWIG_fail;
36711 }
36712 {
36713 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36714 }
36715 return resultobj;
36716 fail:
36717 return NULL;
36718 }
36719
36720
36721 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36722 PyObject *resultobj;
36723 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36724 wxString *arg2 = 0 ;
36725 bool temp2 = false ;
36726 PyObject * obj0 = 0 ;
36727 PyObject * obj1 = 0 ;
36728 char *kwnames[] = {
36729 (char *) "self",(char *) "str", NULL
36730 };
36731
36732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
36733 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36734 if (SWIG_arg_fail(1)) SWIG_fail;
36735 {
36736 arg2 = wxString_in_helper(obj1);
36737 if (arg2 == NULL) SWIG_fail;
36738 temp2 = true;
36739 }
36740 {
36741 PyThreadState* __tstate = wxPyBeginAllowThreads();
36742 (arg1)->SetText((wxString const &)*arg2);
36743
36744 wxPyEndAllowThreads(__tstate);
36745 if (PyErr_Occurred()) SWIG_fail;
36746 }
36747 Py_INCREF(Py_None); resultobj = Py_None;
36748 {
36749 if (temp2)
36750 delete arg2;
36751 }
36752 return resultobj;
36753 fail:
36754 {
36755 if (temp2)
36756 delete arg2;
36757 }
36758 return NULL;
36759 }
36760
36761
36762 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36763 PyObject *resultobj;
36764 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36765 wxString result;
36766 PyObject * obj0 = 0 ;
36767 char *kwnames[] = {
36768 (char *) "self", NULL
36769 };
36770
36771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36772 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36773 if (SWIG_arg_fail(1)) SWIG_fail;
36774 {
36775 PyThreadState* __tstate = wxPyBeginAllowThreads();
36776 result = ((wxMenuItem const *)arg1)->GetLabel();
36777
36778 wxPyEndAllowThreads(__tstate);
36779 if (PyErr_Occurred()) SWIG_fail;
36780 }
36781 {
36782 #if wxUSE_UNICODE
36783 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36784 #else
36785 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36786 #endif
36787 }
36788 return resultobj;
36789 fail:
36790 return NULL;
36791 }
36792
36793
36794 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36795 PyObject *resultobj;
36796 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36797 wxString *result;
36798 PyObject * obj0 = 0 ;
36799 char *kwnames[] = {
36800 (char *) "self", NULL
36801 };
36802
36803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36805 if (SWIG_arg_fail(1)) SWIG_fail;
36806 {
36807 PyThreadState* __tstate = wxPyBeginAllowThreads();
36808 {
36809 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36810 result = (wxString *) &_result_ref;
36811 }
36812
36813 wxPyEndAllowThreads(__tstate);
36814 if (PyErr_Occurred()) SWIG_fail;
36815 }
36816 {
36817 #if wxUSE_UNICODE
36818 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36819 #else
36820 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36821 #endif
36822 }
36823 return resultobj;
36824 fail:
36825 return NULL;
36826 }
36827
36828
36829 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36830 PyObject *resultobj;
36831 wxString *arg1 = 0 ;
36832 wxString result;
36833 bool temp1 = false ;
36834 PyObject * obj0 = 0 ;
36835 char *kwnames[] = {
36836 (char *) "text", NULL
36837 };
36838
36839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36840 {
36841 arg1 = wxString_in_helper(obj0);
36842 if (arg1 == NULL) SWIG_fail;
36843 temp1 = true;
36844 }
36845 {
36846 PyThreadState* __tstate = wxPyBeginAllowThreads();
36847 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36848
36849 wxPyEndAllowThreads(__tstate);
36850 if (PyErr_Occurred()) SWIG_fail;
36851 }
36852 {
36853 #if wxUSE_UNICODE
36854 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36855 #else
36856 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36857 #endif
36858 }
36859 {
36860 if (temp1)
36861 delete arg1;
36862 }
36863 return resultobj;
36864 fail:
36865 {
36866 if (temp1)
36867 delete arg1;
36868 }
36869 return NULL;
36870 }
36871
36872
36873 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36874 PyObject *resultobj;
36875 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36876 wxItemKind result;
36877 PyObject * obj0 = 0 ;
36878 char *kwnames[] = {
36879 (char *) "self", NULL
36880 };
36881
36882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36884 if (SWIG_arg_fail(1)) SWIG_fail;
36885 {
36886 PyThreadState* __tstate = wxPyBeginAllowThreads();
36887 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36888
36889 wxPyEndAllowThreads(__tstate);
36890 if (PyErr_Occurred()) SWIG_fail;
36891 }
36892 resultobj = SWIG_From_int((result));
36893 return resultobj;
36894 fail:
36895 return NULL;
36896 }
36897
36898
36899 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36900 PyObject *resultobj;
36901 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36902 wxItemKind arg2 ;
36903 PyObject * obj0 = 0 ;
36904 PyObject * obj1 = 0 ;
36905 char *kwnames[] = {
36906 (char *) "self",(char *) "kind", NULL
36907 };
36908
36909 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36910 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36911 if (SWIG_arg_fail(1)) SWIG_fail;
36912 {
36913 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36914 if (SWIG_arg_fail(2)) SWIG_fail;
36915 }
36916 {
36917 PyThreadState* __tstate = wxPyBeginAllowThreads();
36918 (arg1)->SetKind((wxItemKind )arg2);
36919
36920 wxPyEndAllowThreads(__tstate);
36921 if (PyErr_Occurred()) SWIG_fail;
36922 }
36923 Py_INCREF(Py_None); resultobj = Py_None;
36924 return resultobj;
36925 fail:
36926 return NULL;
36927 }
36928
36929
36930 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36931 PyObject *resultobj;
36932 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36933 bool arg2 ;
36934 PyObject * obj0 = 0 ;
36935 PyObject * obj1 = 0 ;
36936 char *kwnames[] = {
36937 (char *) "self",(char *) "checkable", NULL
36938 };
36939
36940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36942 if (SWIG_arg_fail(1)) SWIG_fail;
36943 {
36944 arg2 = (bool)(SWIG_As_bool(obj1));
36945 if (SWIG_arg_fail(2)) SWIG_fail;
36946 }
36947 {
36948 PyThreadState* __tstate = wxPyBeginAllowThreads();
36949 (arg1)->SetCheckable(arg2);
36950
36951 wxPyEndAllowThreads(__tstate);
36952 if (PyErr_Occurred()) SWIG_fail;
36953 }
36954 Py_INCREF(Py_None); resultobj = Py_None;
36955 return resultobj;
36956 fail:
36957 return NULL;
36958 }
36959
36960
36961 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36962 PyObject *resultobj;
36963 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36964 bool result;
36965 PyObject * obj0 = 0 ;
36966 char *kwnames[] = {
36967 (char *) "self", NULL
36968 };
36969
36970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36972 if (SWIG_arg_fail(1)) SWIG_fail;
36973 {
36974 PyThreadState* __tstate = wxPyBeginAllowThreads();
36975 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36976
36977 wxPyEndAllowThreads(__tstate);
36978 if (PyErr_Occurred()) SWIG_fail;
36979 }
36980 {
36981 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36982 }
36983 return resultobj;
36984 fail:
36985 return NULL;
36986 }
36987
36988
36989 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36990 PyObject *resultobj;
36991 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36992 bool result;
36993 PyObject * obj0 = 0 ;
36994 char *kwnames[] = {
36995 (char *) "self", NULL
36996 };
36997
36998 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36999 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37000 if (SWIG_arg_fail(1)) SWIG_fail;
37001 {
37002 PyThreadState* __tstate = wxPyBeginAllowThreads();
37003 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
37004
37005 wxPyEndAllowThreads(__tstate);
37006 if (PyErr_Occurred()) SWIG_fail;
37007 }
37008 {
37009 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37010 }
37011 return resultobj;
37012 fail:
37013 return NULL;
37014 }
37015
37016
37017 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37018 PyObject *resultobj;
37019 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37020 wxMenu *arg2 = (wxMenu *) 0 ;
37021 PyObject * obj0 = 0 ;
37022 PyObject * obj1 = 0 ;
37023 char *kwnames[] = {
37024 (char *) "self",(char *) "menu", NULL
37025 };
37026
37027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
37028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37029 if (SWIG_arg_fail(1)) SWIG_fail;
37030 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
37031 if (SWIG_arg_fail(2)) SWIG_fail;
37032 {
37033 PyThreadState* __tstate = wxPyBeginAllowThreads();
37034 (arg1)->SetSubMenu(arg2);
37035
37036 wxPyEndAllowThreads(__tstate);
37037 if (PyErr_Occurred()) SWIG_fail;
37038 }
37039 Py_INCREF(Py_None); resultobj = Py_None;
37040 return resultobj;
37041 fail:
37042 return NULL;
37043 }
37044
37045
37046 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
37047 PyObject *resultobj;
37048 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37049 wxMenu *result;
37050 PyObject * obj0 = 0 ;
37051 char *kwnames[] = {
37052 (char *) "self", NULL
37053 };
37054
37055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
37056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37057 if (SWIG_arg_fail(1)) SWIG_fail;
37058 {
37059 PyThreadState* __tstate = wxPyBeginAllowThreads();
37060 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
37061
37062 wxPyEndAllowThreads(__tstate);
37063 if (PyErr_Occurred()) SWIG_fail;
37064 }
37065 {
37066 resultobj = wxPyMake_wxObject(result, 0);
37067 }
37068 return resultobj;
37069 fail:
37070 return NULL;
37071 }
37072
37073
37074 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
37075 PyObject *resultobj;
37076 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37077 bool arg2 = (bool) true ;
37078 PyObject * obj0 = 0 ;
37079 PyObject * obj1 = 0 ;
37080 char *kwnames[] = {
37081 (char *) "self",(char *) "enable", NULL
37082 };
37083
37084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
37085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37086 if (SWIG_arg_fail(1)) SWIG_fail;
37087 if (obj1) {
37088 {
37089 arg2 = (bool)(SWIG_As_bool(obj1));
37090 if (SWIG_arg_fail(2)) SWIG_fail;
37091 }
37092 }
37093 {
37094 PyThreadState* __tstate = wxPyBeginAllowThreads();
37095 (arg1)->Enable(arg2);
37096
37097 wxPyEndAllowThreads(__tstate);
37098 if (PyErr_Occurred()) SWIG_fail;
37099 }
37100 Py_INCREF(Py_None); resultobj = Py_None;
37101 return resultobj;
37102 fail:
37103 return NULL;
37104 }
37105
37106
37107 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
37108 PyObject *resultobj;
37109 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37110 bool result;
37111 PyObject * obj0 = 0 ;
37112 char *kwnames[] = {
37113 (char *) "self", NULL
37114 };
37115
37116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
37117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37118 if (SWIG_arg_fail(1)) SWIG_fail;
37119 {
37120 PyThreadState* __tstate = wxPyBeginAllowThreads();
37121 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
37122
37123 wxPyEndAllowThreads(__tstate);
37124 if (PyErr_Occurred()) SWIG_fail;
37125 }
37126 {
37127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37128 }
37129 return resultobj;
37130 fail:
37131 return NULL;
37132 }
37133
37134
37135 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
37136 PyObject *resultobj;
37137 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37138 bool arg2 = (bool) true ;
37139 PyObject * obj0 = 0 ;
37140 PyObject * obj1 = 0 ;
37141 char *kwnames[] = {
37142 (char *) "self",(char *) "check", NULL
37143 };
37144
37145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
37146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37147 if (SWIG_arg_fail(1)) SWIG_fail;
37148 if (obj1) {
37149 {
37150 arg2 = (bool)(SWIG_As_bool(obj1));
37151 if (SWIG_arg_fail(2)) SWIG_fail;
37152 }
37153 }
37154 {
37155 PyThreadState* __tstate = wxPyBeginAllowThreads();
37156 (arg1)->Check(arg2);
37157
37158 wxPyEndAllowThreads(__tstate);
37159 if (PyErr_Occurred()) SWIG_fail;
37160 }
37161 Py_INCREF(Py_None); resultobj = Py_None;
37162 return resultobj;
37163 fail:
37164 return NULL;
37165 }
37166
37167
37168 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
37169 PyObject *resultobj;
37170 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37171 bool result;
37172 PyObject * obj0 = 0 ;
37173 char *kwnames[] = {
37174 (char *) "self", NULL
37175 };
37176
37177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
37178 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37179 if (SWIG_arg_fail(1)) SWIG_fail;
37180 {
37181 PyThreadState* __tstate = wxPyBeginAllowThreads();
37182 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
37183
37184 wxPyEndAllowThreads(__tstate);
37185 if (PyErr_Occurred()) SWIG_fail;
37186 }
37187 {
37188 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37189 }
37190 return resultobj;
37191 fail:
37192 return NULL;
37193 }
37194
37195
37196 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
37197 PyObject *resultobj;
37198 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37199 PyObject * obj0 = 0 ;
37200 char *kwnames[] = {
37201 (char *) "self", NULL
37202 };
37203
37204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
37205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37206 if (SWIG_arg_fail(1)) SWIG_fail;
37207 {
37208 PyThreadState* __tstate = wxPyBeginAllowThreads();
37209 (arg1)->Toggle();
37210
37211 wxPyEndAllowThreads(__tstate);
37212 if (PyErr_Occurred()) SWIG_fail;
37213 }
37214 Py_INCREF(Py_None); resultobj = Py_None;
37215 return resultobj;
37216 fail:
37217 return NULL;
37218 }
37219
37220
37221 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37222 PyObject *resultobj;
37223 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37224 wxString *arg2 = 0 ;
37225 bool temp2 = false ;
37226 PyObject * obj0 = 0 ;
37227 PyObject * obj1 = 0 ;
37228 char *kwnames[] = {
37229 (char *) "self",(char *) "str", NULL
37230 };
37231
37232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
37233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37234 if (SWIG_arg_fail(1)) SWIG_fail;
37235 {
37236 arg2 = wxString_in_helper(obj1);
37237 if (arg2 == NULL) SWIG_fail;
37238 temp2 = true;
37239 }
37240 {
37241 PyThreadState* __tstate = wxPyBeginAllowThreads();
37242 (arg1)->SetHelp((wxString const &)*arg2);
37243
37244 wxPyEndAllowThreads(__tstate);
37245 if (PyErr_Occurred()) SWIG_fail;
37246 }
37247 Py_INCREF(Py_None); resultobj = Py_None;
37248 {
37249 if (temp2)
37250 delete arg2;
37251 }
37252 return resultobj;
37253 fail:
37254 {
37255 if (temp2)
37256 delete arg2;
37257 }
37258 return NULL;
37259 }
37260
37261
37262 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
37263 PyObject *resultobj;
37264 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37265 wxString *result;
37266 PyObject * obj0 = 0 ;
37267 char *kwnames[] = {
37268 (char *) "self", NULL
37269 };
37270
37271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
37272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37273 if (SWIG_arg_fail(1)) SWIG_fail;
37274 {
37275 PyThreadState* __tstate = wxPyBeginAllowThreads();
37276 {
37277 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
37278 result = (wxString *) &_result_ref;
37279 }
37280
37281 wxPyEndAllowThreads(__tstate);
37282 if (PyErr_Occurred()) SWIG_fail;
37283 }
37284 {
37285 #if wxUSE_UNICODE
37286 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
37287 #else
37288 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
37289 #endif
37290 }
37291 return resultobj;
37292 fail:
37293 return NULL;
37294 }
37295
37296
37297 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37298 PyObject *resultobj;
37299 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37300 wxAcceleratorEntry *result;
37301 PyObject * obj0 = 0 ;
37302 char *kwnames[] = {
37303 (char *) "self", NULL
37304 };
37305
37306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
37307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37308 if (SWIG_arg_fail(1)) SWIG_fail;
37309 {
37310 PyThreadState* __tstate = wxPyBeginAllowThreads();
37311 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
37312
37313 wxPyEndAllowThreads(__tstate);
37314 if (PyErr_Occurred()) SWIG_fail;
37315 }
37316 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
37317 return resultobj;
37318 fail:
37319 return NULL;
37320 }
37321
37322
37323 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
37324 PyObject *resultobj;
37325 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37326 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
37327 PyObject * obj0 = 0 ;
37328 PyObject * obj1 = 0 ;
37329 char *kwnames[] = {
37330 (char *) "self",(char *) "accel", NULL
37331 };
37332
37333 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
37334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37335 if (SWIG_arg_fail(1)) SWIG_fail;
37336 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
37337 if (SWIG_arg_fail(2)) SWIG_fail;
37338 {
37339 PyThreadState* __tstate = wxPyBeginAllowThreads();
37340 (arg1)->SetAccel(arg2);
37341
37342 wxPyEndAllowThreads(__tstate);
37343 if (PyErr_Occurred()) SWIG_fail;
37344 }
37345 Py_INCREF(Py_None); resultobj = Py_None;
37346 return resultobj;
37347 fail:
37348 return NULL;
37349 }
37350
37351
37352 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37353 PyObject *resultobj;
37354 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37355 wxFont *arg2 = 0 ;
37356 PyObject * obj0 = 0 ;
37357 PyObject * obj1 = 0 ;
37358 char *kwnames[] = {
37359 (char *) "self",(char *) "font", NULL
37360 };
37361
37362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
37363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37364 if (SWIG_arg_fail(1)) SWIG_fail;
37365 {
37366 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
37367 if (SWIG_arg_fail(2)) SWIG_fail;
37368 if (arg2 == NULL) {
37369 SWIG_null_ref("wxFont");
37370 }
37371 if (SWIG_arg_fail(2)) SWIG_fail;
37372 }
37373 {
37374 PyThreadState* __tstate = wxPyBeginAllowThreads();
37375 (arg1)->SetFont((wxFont const &)*arg2);
37376
37377 wxPyEndAllowThreads(__tstate);
37378 if (PyErr_Occurred()) SWIG_fail;
37379 }
37380 Py_INCREF(Py_None); resultobj = Py_None;
37381 return resultobj;
37382 fail:
37383 return NULL;
37384 }
37385
37386
37387 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
37388 PyObject *resultobj;
37389 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37390 wxFont result;
37391 PyObject * obj0 = 0 ;
37392 char *kwnames[] = {
37393 (char *) "self", NULL
37394 };
37395
37396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
37397 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37398 if (SWIG_arg_fail(1)) SWIG_fail;
37399 {
37400 PyThreadState* __tstate = wxPyBeginAllowThreads();
37401 result = (arg1)->GetFont();
37402
37403 wxPyEndAllowThreads(__tstate);
37404 if (PyErr_Occurred()) SWIG_fail;
37405 }
37406 {
37407 wxFont * resultptr;
37408 resultptr = new wxFont((wxFont &)(result));
37409 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
37410 }
37411 return resultobj;
37412 fail:
37413 return NULL;
37414 }
37415
37416
37417 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37418 PyObject *resultobj;
37419 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37420 wxColour *arg2 = 0 ;
37421 wxColour temp2 ;
37422 PyObject * obj0 = 0 ;
37423 PyObject * obj1 = 0 ;
37424 char *kwnames[] = {
37425 (char *) "self",(char *) "colText", NULL
37426 };
37427
37428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
37429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37430 if (SWIG_arg_fail(1)) SWIG_fail;
37431 {
37432 arg2 = &temp2;
37433 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37434 }
37435 {
37436 PyThreadState* __tstate = wxPyBeginAllowThreads();
37437 (arg1)->SetTextColour((wxColour const &)*arg2);
37438
37439 wxPyEndAllowThreads(__tstate);
37440 if (PyErr_Occurred()) SWIG_fail;
37441 }
37442 Py_INCREF(Py_None); resultobj = Py_None;
37443 return resultobj;
37444 fail:
37445 return NULL;
37446 }
37447
37448
37449 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
37450 PyObject *resultobj;
37451 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37452 wxColour result;
37453 PyObject * obj0 = 0 ;
37454 char *kwnames[] = {
37455 (char *) "self", NULL
37456 };
37457
37458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
37459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37460 if (SWIG_arg_fail(1)) SWIG_fail;
37461 {
37462 PyThreadState* __tstate = wxPyBeginAllowThreads();
37463 result = (arg1)->GetTextColour();
37464
37465 wxPyEndAllowThreads(__tstate);
37466 if (PyErr_Occurred()) SWIG_fail;
37467 }
37468 {
37469 wxColour * resultptr;
37470 resultptr = new wxColour((wxColour &)(result));
37471 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37472 }
37473 return resultobj;
37474 fail:
37475 return NULL;
37476 }
37477
37478
37479 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37480 PyObject *resultobj;
37481 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37482 wxColour *arg2 = 0 ;
37483 wxColour temp2 ;
37484 PyObject * obj0 = 0 ;
37485 PyObject * obj1 = 0 ;
37486 char *kwnames[] = {
37487 (char *) "self",(char *) "colBack", NULL
37488 };
37489
37490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
37491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37492 if (SWIG_arg_fail(1)) SWIG_fail;
37493 {
37494 arg2 = &temp2;
37495 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
37496 }
37497 {
37498 PyThreadState* __tstate = wxPyBeginAllowThreads();
37499 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
37500
37501 wxPyEndAllowThreads(__tstate);
37502 if (PyErr_Occurred()) SWIG_fail;
37503 }
37504 Py_INCREF(Py_None); resultobj = Py_None;
37505 return resultobj;
37506 fail:
37507 return NULL;
37508 }
37509
37510
37511 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
37512 PyObject *resultobj;
37513 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37514 wxColour result;
37515 PyObject * obj0 = 0 ;
37516 char *kwnames[] = {
37517 (char *) "self", NULL
37518 };
37519
37520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
37521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37522 if (SWIG_arg_fail(1)) SWIG_fail;
37523 {
37524 PyThreadState* __tstate = wxPyBeginAllowThreads();
37525 result = (arg1)->GetBackgroundColour();
37526
37527 wxPyEndAllowThreads(__tstate);
37528 if (PyErr_Occurred()) SWIG_fail;
37529 }
37530 {
37531 wxColour * resultptr;
37532 resultptr = new wxColour((wxColour &)(result));
37533 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
37534 }
37535 return resultobj;
37536 fail:
37537 return NULL;
37538 }
37539
37540
37541 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
37542 PyObject *resultobj;
37543 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37544 wxBitmap *arg2 = 0 ;
37545 wxBitmap const &arg3_defvalue = wxNullBitmap ;
37546 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
37547 PyObject * obj0 = 0 ;
37548 PyObject * obj1 = 0 ;
37549 PyObject * obj2 = 0 ;
37550 char *kwnames[] = {
37551 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
37552 };
37553
37554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
37555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37556 if (SWIG_arg_fail(1)) SWIG_fail;
37557 {
37558 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37559 if (SWIG_arg_fail(2)) SWIG_fail;
37560 if (arg2 == NULL) {
37561 SWIG_null_ref("wxBitmap");
37562 }
37563 if (SWIG_arg_fail(2)) SWIG_fail;
37564 }
37565 if (obj2) {
37566 {
37567 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37568 if (SWIG_arg_fail(3)) SWIG_fail;
37569 if (arg3 == NULL) {
37570 SWIG_null_ref("wxBitmap");
37571 }
37572 if (SWIG_arg_fail(3)) SWIG_fail;
37573 }
37574 }
37575 {
37576 PyThreadState* __tstate = wxPyBeginAllowThreads();
37577 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
37578
37579 wxPyEndAllowThreads(__tstate);
37580 if (PyErr_Occurred()) SWIG_fail;
37581 }
37582 Py_INCREF(Py_None); resultobj = Py_None;
37583 return resultobj;
37584 fail:
37585 return NULL;
37586 }
37587
37588
37589 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37590 PyObject *resultobj;
37591 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37592 wxBitmap *arg2 = 0 ;
37593 PyObject * obj0 = 0 ;
37594 PyObject * obj1 = 0 ;
37595 char *kwnames[] = {
37596 (char *) "self",(char *) "bmpDisabled", NULL
37597 };
37598
37599 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
37600 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37601 if (SWIG_arg_fail(1)) SWIG_fail;
37602 {
37603 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37604 if (SWIG_arg_fail(2)) SWIG_fail;
37605 if (arg2 == NULL) {
37606 SWIG_null_ref("wxBitmap");
37607 }
37608 if (SWIG_arg_fail(2)) SWIG_fail;
37609 }
37610 {
37611 PyThreadState* __tstate = wxPyBeginAllowThreads();
37612 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
37613
37614 wxPyEndAllowThreads(__tstate);
37615 if (PyErr_Occurred()) SWIG_fail;
37616 }
37617 Py_INCREF(Py_None); resultobj = Py_None;
37618 return resultobj;
37619 fail:
37620 return NULL;
37621 }
37622
37623
37624 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37625 PyObject *resultobj;
37626 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37627 wxBitmap *result;
37628 PyObject * obj0 = 0 ;
37629 char *kwnames[] = {
37630 (char *) "self", NULL
37631 };
37632
37633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37635 if (SWIG_arg_fail(1)) SWIG_fail;
37636 {
37637 PyThreadState* __tstate = wxPyBeginAllowThreads();
37638 {
37639 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
37640 result = (wxBitmap *) &_result_ref;
37641 }
37642
37643 wxPyEndAllowThreads(__tstate);
37644 if (PyErr_Occurred()) SWIG_fail;
37645 }
37646 {
37647 wxBitmap* resultptr = new wxBitmap(*result);
37648 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37649 }
37650 return resultobj;
37651 fail:
37652 return NULL;
37653 }
37654
37655
37656 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37657 PyObject *resultobj;
37658 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37659 int arg2 ;
37660 PyObject * obj0 = 0 ;
37661 PyObject * obj1 = 0 ;
37662 char *kwnames[] = {
37663 (char *) "self",(char *) "nWidth", NULL
37664 };
37665
37666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
37667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37668 if (SWIG_arg_fail(1)) SWIG_fail;
37669 {
37670 arg2 = (int)(SWIG_As_int(obj1));
37671 if (SWIG_arg_fail(2)) SWIG_fail;
37672 }
37673 {
37674 PyThreadState* __tstate = wxPyBeginAllowThreads();
37675 (arg1)->SetMarginWidth(arg2);
37676
37677 wxPyEndAllowThreads(__tstate);
37678 if (PyErr_Occurred()) SWIG_fail;
37679 }
37680 Py_INCREF(Py_None); resultobj = Py_None;
37681 return resultobj;
37682 fail:
37683 return NULL;
37684 }
37685
37686
37687 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37688 PyObject *resultobj;
37689 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37690 int result;
37691 PyObject * obj0 = 0 ;
37692 char *kwnames[] = {
37693 (char *) "self", NULL
37694 };
37695
37696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37698 if (SWIG_arg_fail(1)) SWIG_fail;
37699 {
37700 PyThreadState* __tstate = wxPyBeginAllowThreads();
37701 result = (int)(arg1)->GetMarginWidth();
37702
37703 wxPyEndAllowThreads(__tstate);
37704 if (PyErr_Occurred()) SWIG_fail;
37705 }
37706 {
37707 resultobj = SWIG_From_int((int)(result));
37708 }
37709 return resultobj;
37710 fail:
37711 return NULL;
37712 }
37713
37714
37715 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37716 PyObject *resultobj;
37717 int result;
37718 char *kwnames[] = {
37719 NULL
37720 };
37721
37722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37723 {
37724 PyThreadState* __tstate = wxPyBeginAllowThreads();
37725 result = (int)wxMenuItem::GetDefaultMarginWidth();
37726
37727 wxPyEndAllowThreads(__tstate);
37728 if (PyErr_Occurred()) SWIG_fail;
37729 }
37730 {
37731 resultobj = SWIG_From_int((int)(result));
37732 }
37733 return resultobj;
37734 fail:
37735 return NULL;
37736 }
37737
37738
37739 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37740 PyObject *resultobj;
37741 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37742 bool result;
37743 PyObject * obj0 = 0 ;
37744 char *kwnames[] = {
37745 (char *) "self", NULL
37746 };
37747
37748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37750 if (SWIG_arg_fail(1)) SWIG_fail;
37751 {
37752 PyThreadState* __tstate = wxPyBeginAllowThreads();
37753 result = (bool)(arg1)->IsOwnerDrawn();
37754
37755 wxPyEndAllowThreads(__tstate);
37756 if (PyErr_Occurred()) SWIG_fail;
37757 }
37758 {
37759 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37760 }
37761 return resultobj;
37762 fail:
37763 return NULL;
37764 }
37765
37766
37767 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37768 PyObject *resultobj;
37769 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37770 bool arg2 = (bool) true ;
37771 PyObject * obj0 = 0 ;
37772 PyObject * obj1 = 0 ;
37773 char *kwnames[] = {
37774 (char *) "self",(char *) "ownerDrawn", NULL
37775 };
37776
37777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37779 if (SWIG_arg_fail(1)) SWIG_fail;
37780 if (obj1) {
37781 {
37782 arg2 = (bool)(SWIG_As_bool(obj1));
37783 if (SWIG_arg_fail(2)) SWIG_fail;
37784 }
37785 }
37786 {
37787 PyThreadState* __tstate = wxPyBeginAllowThreads();
37788 (arg1)->SetOwnerDrawn(arg2);
37789
37790 wxPyEndAllowThreads(__tstate);
37791 if (PyErr_Occurred()) SWIG_fail;
37792 }
37793 Py_INCREF(Py_None); resultobj = Py_None;
37794 return resultobj;
37795 fail:
37796 return NULL;
37797 }
37798
37799
37800 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37801 PyObject *resultobj;
37802 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37803 PyObject * obj0 = 0 ;
37804 char *kwnames[] = {
37805 (char *) "self", NULL
37806 };
37807
37808 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37809 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37810 if (SWIG_arg_fail(1)) SWIG_fail;
37811 {
37812 PyThreadState* __tstate = wxPyBeginAllowThreads();
37813 (arg1)->ResetOwnerDrawn();
37814
37815 wxPyEndAllowThreads(__tstate);
37816 if (PyErr_Occurred()) SWIG_fail;
37817 }
37818 Py_INCREF(Py_None); resultobj = Py_None;
37819 return resultobj;
37820 fail:
37821 return NULL;
37822 }
37823
37824
37825 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37826 PyObject *resultobj;
37827 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37828 wxBitmap *arg2 = 0 ;
37829 PyObject * obj0 = 0 ;
37830 PyObject * obj1 = 0 ;
37831 char *kwnames[] = {
37832 (char *) "self",(char *) "bitmap", NULL
37833 };
37834
37835 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37836 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37837 if (SWIG_arg_fail(1)) SWIG_fail;
37838 {
37839 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37840 if (SWIG_arg_fail(2)) SWIG_fail;
37841 if (arg2 == NULL) {
37842 SWIG_null_ref("wxBitmap");
37843 }
37844 if (SWIG_arg_fail(2)) SWIG_fail;
37845 }
37846 {
37847 PyThreadState* __tstate = wxPyBeginAllowThreads();
37848 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37849
37850 wxPyEndAllowThreads(__tstate);
37851 if (PyErr_Occurred()) SWIG_fail;
37852 }
37853 Py_INCREF(Py_None); resultobj = Py_None;
37854 return resultobj;
37855 fail:
37856 return NULL;
37857 }
37858
37859
37860 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37861 PyObject *resultobj;
37862 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37863 wxBitmap *result;
37864 PyObject * obj0 = 0 ;
37865 char *kwnames[] = {
37866 (char *) "self", NULL
37867 };
37868
37869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37871 if (SWIG_arg_fail(1)) SWIG_fail;
37872 {
37873 PyThreadState* __tstate = wxPyBeginAllowThreads();
37874 {
37875 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37876 result = (wxBitmap *) &_result_ref;
37877 }
37878
37879 wxPyEndAllowThreads(__tstate);
37880 if (PyErr_Occurred()) SWIG_fail;
37881 }
37882 {
37883 wxBitmap* resultptr = new wxBitmap(*result);
37884 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37885 }
37886 return resultobj;
37887 fail:
37888 return NULL;
37889 }
37890
37891
37892 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37893 PyObject *obj;
37894 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37895 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37896 Py_INCREF(obj);
37897 return Py_BuildValue((char *)"");
37898 }
37899 static int _wrap_ControlNameStr_set(PyObject *) {
37900 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37901 return 1;
37902 }
37903
37904
37905 static PyObject *_wrap_ControlNameStr_get(void) {
37906 PyObject *pyobj;
37907
37908 {
37909 #if wxUSE_UNICODE
37910 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37911 #else
37912 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37913 #endif
37914 }
37915 return pyobj;
37916 }
37917
37918
37919 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37920 PyObject *resultobj;
37921 wxWindow *arg1 = (wxWindow *) 0 ;
37922 int arg2 = (int) -1 ;
37923 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37924 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37925 wxSize const &arg4_defvalue = wxDefaultSize ;
37926 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37927 long arg5 = (long) 0 ;
37928 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37929 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37930 wxString const &arg7_defvalue = wxPyControlNameStr ;
37931 wxString *arg7 = (wxString *) &arg7_defvalue ;
37932 wxControl *result;
37933 wxPoint temp3 ;
37934 wxSize temp4 ;
37935 bool temp7 = false ;
37936 PyObject * obj0 = 0 ;
37937 PyObject * obj1 = 0 ;
37938 PyObject * obj2 = 0 ;
37939 PyObject * obj3 = 0 ;
37940 PyObject * obj4 = 0 ;
37941 PyObject * obj5 = 0 ;
37942 PyObject * obj6 = 0 ;
37943 char *kwnames[] = {
37944 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37945 };
37946
37947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37949 if (SWIG_arg_fail(1)) SWIG_fail;
37950 if (obj1) {
37951 {
37952 arg2 = (int)(SWIG_As_int(obj1));
37953 if (SWIG_arg_fail(2)) SWIG_fail;
37954 }
37955 }
37956 if (obj2) {
37957 {
37958 arg3 = &temp3;
37959 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37960 }
37961 }
37962 if (obj3) {
37963 {
37964 arg4 = &temp4;
37965 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37966 }
37967 }
37968 if (obj4) {
37969 {
37970 arg5 = (long)(SWIG_As_long(obj4));
37971 if (SWIG_arg_fail(5)) SWIG_fail;
37972 }
37973 }
37974 if (obj5) {
37975 {
37976 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37977 if (SWIG_arg_fail(6)) SWIG_fail;
37978 if (arg6 == NULL) {
37979 SWIG_null_ref("wxValidator");
37980 }
37981 if (SWIG_arg_fail(6)) SWIG_fail;
37982 }
37983 }
37984 if (obj6) {
37985 {
37986 arg7 = wxString_in_helper(obj6);
37987 if (arg7 == NULL) SWIG_fail;
37988 temp7 = true;
37989 }
37990 }
37991 {
37992 if (!wxPyCheckForApp()) SWIG_fail;
37993 PyThreadState* __tstate = wxPyBeginAllowThreads();
37994 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37995
37996 wxPyEndAllowThreads(__tstate);
37997 if (PyErr_Occurred()) SWIG_fail;
37998 }
37999 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38000 {
38001 if (temp7)
38002 delete arg7;
38003 }
38004 return resultobj;
38005 fail:
38006 {
38007 if (temp7)
38008 delete arg7;
38009 }
38010 return NULL;
38011 }
38012
38013
38014 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
38015 PyObject *resultobj;
38016 wxControl *result;
38017 char *kwnames[] = {
38018 NULL
38019 };
38020
38021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
38022 {
38023 if (!wxPyCheckForApp()) SWIG_fail;
38024 PyThreadState* __tstate = wxPyBeginAllowThreads();
38025 result = (wxControl *)new wxControl();
38026
38027 wxPyEndAllowThreads(__tstate);
38028 if (PyErr_Occurred()) SWIG_fail;
38029 }
38030 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
38031 return resultobj;
38032 fail:
38033 return NULL;
38034 }
38035
38036
38037 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
38038 PyObject *resultobj;
38039 wxControl *arg1 = (wxControl *) 0 ;
38040 wxWindow *arg2 = (wxWindow *) 0 ;
38041 int arg3 = (int) -1 ;
38042 wxPoint const &arg4_defvalue = wxDefaultPosition ;
38043 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
38044 wxSize const &arg5_defvalue = wxDefaultSize ;
38045 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
38046 long arg6 = (long) 0 ;
38047 wxValidator const &arg7_defvalue = wxDefaultValidator ;
38048 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
38049 wxString const &arg8_defvalue = wxPyControlNameStr ;
38050 wxString *arg8 = (wxString *) &arg8_defvalue ;
38051 bool result;
38052 wxPoint temp4 ;
38053 wxSize temp5 ;
38054 bool temp8 = false ;
38055 PyObject * obj0 = 0 ;
38056 PyObject * obj1 = 0 ;
38057 PyObject * obj2 = 0 ;
38058 PyObject * obj3 = 0 ;
38059 PyObject * obj4 = 0 ;
38060 PyObject * obj5 = 0 ;
38061 PyObject * obj6 = 0 ;
38062 PyObject * obj7 = 0 ;
38063 char *kwnames[] = {
38064 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
38065 };
38066
38067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
38068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38069 if (SWIG_arg_fail(1)) SWIG_fail;
38070 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38071 if (SWIG_arg_fail(2)) SWIG_fail;
38072 if (obj2) {
38073 {
38074 arg3 = (int)(SWIG_As_int(obj2));
38075 if (SWIG_arg_fail(3)) SWIG_fail;
38076 }
38077 }
38078 if (obj3) {
38079 {
38080 arg4 = &temp4;
38081 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
38082 }
38083 }
38084 if (obj4) {
38085 {
38086 arg5 = &temp5;
38087 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
38088 }
38089 }
38090 if (obj5) {
38091 {
38092 arg6 = (long)(SWIG_As_long(obj5));
38093 if (SWIG_arg_fail(6)) SWIG_fail;
38094 }
38095 }
38096 if (obj6) {
38097 {
38098 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
38099 if (SWIG_arg_fail(7)) SWIG_fail;
38100 if (arg7 == NULL) {
38101 SWIG_null_ref("wxValidator");
38102 }
38103 if (SWIG_arg_fail(7)) SWIG_fail;
38104 }
38105 }
38106 if (obj7) {
38107 {
38108 arg8 = wxString_in_helper(obj7);
38109 if (arg8 == NULL) SWIG_fail;
38110 temp8 = true;
38111 }
38112 }
38113 {
38114 PyThreadState* __tstate = wxPyBeginAllowThreads();
38115 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
38116
38117 wxPyEndAllowThreads(__tstate);
38118 if (PyErr_Occurred()) SWIG_fail;
38119 }
38120 {
38121 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38122 }
38123 {
38124 if (temp8)
38125 delete arg8;
38126 }
38127 return resultobj;
38128 fail:
38129 {
38130 if (temp8)
38131 delete arg8;
38132 }
38133 return NULL;
38134 }
38135
38136
38137 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
38138 PyObject *resultobj;
38139 wxControl *arg1 = (wxControl *) 0 ;
38140 wxCommandEvent *arg2 = 0 ;
38141 PyObject * obj0 = 0 ;
38142 PyObject * obj1 = 0 ;
38143 char *kwnames[] = {
38144 (char *) "self",(char *) "event", NULL
38145 };
38146
38147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
38148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38149 if (SWIG_arg_fail(1)) SWIG_fail;
38150 {
38151 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
38152 if (SWIG_arg_fail(2)) SWIG_fail;
38153 if (arg2 == NULL) {
38154 SWIG_null_ref("wxCommandEvent");
38155 }
38156 if (SWIG_arg_fail(2)) SWIG_fail;
38157 }
38158 {
38159 PyThreadState* __tstate = wxPyBeginAllowThreads();
38160 (arg1)->Command(*arg2);
38161
38162 wxPyEndAllowThreads(__tstate);
38163 if (PyErr_Occurred()) SWIG_fail;
38164 }
38165 Py_INCREF(Py_None); resultobj = Py_None;
38166 return resultobj;
38167 fail:
38168 return NULL;
38169 }
38170
38171
38172 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38173 PyObject *resultobj;
38174 wxControl *arg1 = (wxControl *) 0 ;
38175 wxString result;
38176 PyObject * obj0 = 0 ;
38177 char *kwnames[] = {
38178 (char *) "self", NULL
38179 };
38180
38181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
38182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38183 if (SWIG_arg_fail(1)) SWIG_fail;
38184 {
38185 PyThreadState* __tstate = wxPyBeginAllowThreads();
38186 result = (arg1)->GetLabel();
38187
38188 wxPyEndAllowThreads(__tstate);
38189 if (PyErr_Occurred()) SWIG_fail;
38190 }
38191 {
38192 #if wxUSE_UNICODE
38193 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38194 #else
38195 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38196 #endif
38197 }
38198 return resultobj;
38199 fail:
38200 return NULL;
38201 }
38202
38203
38204 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
38205 PyObject *resultobj;
38206 wxControl *arg1 = (wxControl *) 0 ;
38207 wxString *arg2 = 0 ;
38208 bool temp2 = false ;
38209 PyObject * obj0 = 0 ;
38210 PyObject * obj1 = 0 ;
38211 char *kwnames[] = {
38212 (char *) "self",(char *) "label", NULL
38213 };
38214
38215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
38216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
38217 if (SWIG_arg_fail(1)) SWIG_fail;
38218 {
38219 arg2 = wxString_in_helper(obj1);
38220 if (arg2 == NULL) SWIG_fail;
38221 temp2 = true;
38222 }
38223 {
38224 PyThreadState* __tstate = wxPyBeginAllowThreads();
38225 (arg1)->SetLabel((wxString const &)*arg2);
38226
38227 wxPyEndAllowThreads(__tstate);
38228 if (PyErr_Occurred()) SWIG_fail;
38229 }
38230 Py_INCREF(Py_None); resultobj = Py_None;
38231 {
38232 if (temp2)
38233 delete arg2;
38234 }
38235 return resultobj;
38236 fail:
38237 {
38238 if (temp2)
38239 delete arg2;
38240 }
38241 return NULL;
38242 }
38243
38244
38245 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
38246 PyObject *resultobj;
38247 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38248 wxVisualAttributes result;
38249 PyObject * obj0 = 0 ;
38250 char *kwnames[] = {
38251 (char *) "variant", NULL
38252 };
38253
38254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
38255 if (obj0) {
38256 {
38257 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
38258 if (SWIG_arg_fail(1)) SWIG_fail;
38259 }
38260 }
38261 {
38262 if (!wxPyCheckForApp()) SWIG_fail;
38263 PyThreadState* __tstate = wxPyBeginAllowThreads();
38264 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
38265
38266 wxPyEndAllowThreads(__tstate);
38267 if (PyErr_Occurred()) SWIG_fail;
38268 }
38269 {
38270 wxVisualAttributes * resultptr;
38271 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
38272 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
38273 }
38274 return resultobj;
38275 fail:
38276 return NULL;
38277 }
38278
38279
38280 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
38281 PyObject *obj;
38282 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38283 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
38284 Py_INCREF(obj);
38285 return Py_BuildValue((char *)"");
38286 }
38287 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
38288 PyObject *resultobj;
38289 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38290 wxString *arg2 = 0 ;
38291 PyObject *arg3 = (PyObject *) NULL ;
38292 int result;
38293 bool temp2 = false ;
38294 PyObject * obj0 = 0 ;
38295 PyObject * obj1 = 0 ;
38296 PyObject * obj2 = 0 ;
38297 char *kwnames[] = {
38298 (char *) "self",(char *) "item",(char *) "clientData", NULL
38299 };
38300
38301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
38302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38303 if (SWIG_arg_fail(1)) SWIG_fail;
38304 {
38305 arg2 = wxString_in_helper(obj1);
38306 if (arg2 == NULL) SWIG_fail;
38307 temp2 = true;
38308 }
38309 if (obj2) {
38310 arg3 = obj2;
38311 }
38312 {
38313 PyThreadState* __tstate = wxPyBeginAllowThreads();
38314 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
38315
38316 wxPyEndAllowThreads(__tstate);
38317 if (PyErr_Occurred()) SWIG_fail;
38318 }
38319 {
38320 resultobj = SWIG_From_int((int)(result));
38321 }
38322 {
38323 if (temp2)
38324 delete arg2;
38325 }
38326 return resultobj;
38327 fail:
38328 {
38329 if (temp2)
38330 delete arg2;
38331 }
38332 return NULL;
38333 }
38334
38335
38336 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
38337 PyObject *resultobj;
38338 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38339 wxArrayString *arg2 = 0 ;
38340 bool temp2 = false ;
38341 PyObject * obj0 = 0 ;
38342 PyObject * obj1 = 0 ;
38343 char *kwnames[] = {
38344 (char *) "self",(char *) "strings", NULL
38345 };
38346
38347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
38348 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38349 if (SWIG_arg_fail(1)) SWIG_fail;
38350 {
38351 if (! PySequence_Check(obj1)) {
38352 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
38353 SWIG_fail;
38354 }
38355 arg2 = new wxArrayString;
38356 temp2 = true;
38357 int i, len=PySequence_Length(obj1);
38358 for (i=0; i<len; i++) {
38359 PyObject* item = PySequence_GetItem(obj1, i);
38360 wxString* s = wxString_in_helper(item);
38361 if (PyErr_Occurred()) SWIG_fail;
38362 arg2->Add(*s);
38363 delete s;
38364 Py_DECREF(item);
38365 }
38366 }
38367 {
38368 PyThreadState* __tstate = wxPyBeginAllowThreads();
38369 (arg1)->Append((wxArrayString const &)*arg2);
38370
38371 wxPyEndAllowThreads(__tstate);
38372 if (PyErr_Occurred()) SWIG_fail;
38373 }
38374 Py_INCREF(Py_None); resultobj = Py_None;
38375 {
38376 if (temp2) delete arg2;
38377 }
38378 return resultobj;
38379 fail:
38380 {
38381 if (temp2) delete arg2;
38382 }
38383 return NULL;
38384 }
38385
38386
38387 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
38388 PyObject *resultobj;
38389 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38390 wxString *arg2 = 0 ;
38391 int arg3 ;
38392 PyObject *arg4 = (PyObject *) NULL ;
38393 int result;
38394 bool temp2 = false ;
38395 PyObject * obj0 = 0 ;
38396 PyObject * obj1 = 0 ;
38397 PyObject * obj2 = 0 ;
38398 PyObject * obj3 = 0 ;
38399 char *kwnames[] = {
38400 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
38401 };
38402
38403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
38404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38405 if (SWIG_arg_fail(1)) SWIG_fail;
38406 {
38407 arg2 = wxString_in_helper(obj1);
38408 if (arg2 == NULL) SWIG_fail;
38409 temp2 = true;
38410 }
38411 {
38412 arg3 = (int)(SWIG_As_int(obj2));
38413 if (SWIG_arg_fail(3)) SWIG_fail;
38414 }
38415 if (obj3) {
38416 arg4 = obj3;
38417 }
38418 {
38419 PyThreadState* __tstate = wxPyBeginAllowThreads();
38420 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
38421
38422 wxPyEndAllowThreads(__tstate);
38423 if (PyErr_Occurred()) SWIG_fail;
38424 }
38425 {
38426 resultobj = SWIG_From_int((int)(result));
38427 }
38428 {
38429 if (temp2)
38430 delete arg2;
38431 }
38432 return resultobj;
38433 fail:
38434 {
38435 if (temp2)
38436 delete arg2;
38437 }
38438 return NULL;
38439 }
38440
38441
38442 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
38443 PyObject *resultobj;
38444 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38445 PyObject * obj0 = 0 ;
38446 char *kwnames[] = {
38447 (char *) "self", NULL
38448 };
38449
38450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
38451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38452 if (SWIG_arg_fail(1)) SWIG_fail;
38453 {
38454 PyThreadState* __tstate = wxPyBeginAllowThreads();
38455 (arg1)->Clear();
38456
38457 wxPyEndAllowThreads(__tstate);
38458 if (PyErr_Occurred()) SWIG_fail;
38459 }
38460 Py_INCREF(Py_None); resultobj = Py_None;
38461 return resultobj;
38462 fail:
38463 return NULL;
38464 }
38465
38466
38467 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
38468 PyObject *resultobj;
38469 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38470 int arg2 ;
38471 PyObject * obj0 = 0 ;
38472 PyObject * obj1 = 0 ;
38473 char *kwnames[] = {
38474 (char *) "self",(char *) "n", NULL
38475 };
38476
38477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
38478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38479 if (SWIG_arg_fail(1)) SWIG_fail;
38480 {
38481 arg2 = (int)(SWIG_As_int(obj1));
38482 if (SWIG_arg_fail(2)) SWIG_fail;
38483 }
38484 {
38485 PyThreadState* __tstate = wxPyBeginAllowThreads();
38486 (arg1)->Delete(arg2);
38487
38488 wxPyEndAllowThreads(__tstate);
38489 if (PyErr_Occurred()) SWIG_fail;
38490 }
38491 Py_INCREF(Py_None); resultobj = Py_None;
38492 return resultobj;
38493 fail:
38494 return NULL;
38495 }
38496
38497
38498 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38499 PyObject *resultobj;
38500 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38501 int arg2 ;
38502 PyObject *result;
38503 PyObject * obj0 = 0 ;
38504 PyObject * obj1 = 0 ;
38505 char *kwnames[] = {
38506 (char *) "self",(char *) "n", NULL
38507 };
38508
38509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
38510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38511 if (SWIG_arg_fail(1)) SWIG_fail;
38512 {
38513 arg2 = (int)(SWIG_As_int(obj1));
38514 if (SWIG_arg_fail(2)) SWIG_fail;
38515 }
38516 {
38517 PyThreadState* __tstate = wxPyBeginAllowThreads();
38518 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
38519
38520 wxPyEndAllowThreads(__tstate);
38521 if (PyErr_Occurred()) SWIG_fail;
38522 }
38523 resultobj = result;
38524 return resultobj;
38525 fail:
38526 return NULL;
38527 }
38528
38529
38530 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
38531 PyObject *resultobj;
38532 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38533 int arg2 ;
38534 PyObject *arg3 = (PyObject *) 0 ;
38535 PyObject * obj0 = 0 ;
38536 PyObject * obj1 = 0 ;
38537 PyObject * obj2 = 0 ;
38538 char *kwnames[] = {
38539 (char *) "self",(char *) "n",(char *) "clientData", NULL
38540 };
38541
38542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
38543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38544 if (SWIG_arg_fail(1)) SWIG_fail;
38545 {
38546 arg2 = (int)(SWIG_As_int(obj1));
38547 if (SWIG_arg_fail(2)) SWIG_fail;
38548 }
38549 arg3 = obj2;
38550 {
38551 PyThreadState* __tstate = wxPyBeginAllowThreads();
38552 wxItemContainer_SetClientData(arg1,arg2,arg3);
38553
38554 wxPyEndAllowThreads(__tstate);
38555 if (PyErr_Occurred()) SWIG_fail;
38556 }
38557 Py_INCREF(Py_None); resultobj = Py_None;
38558 return resultobj;
38559 fail:
38560 return NULL;
38561 }
38562
38563
38564 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
38565 PyObject *resultobj;
38566 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38567 int result;
38568 PyObject * obj0 = 0 ;
38569 char *kwnames[] = {
38570 (char *) "self", NULL
38571 };
38572
38573 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
38574 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38575 if (SWIG_arg_fail(1)) SWIG_fail;
38576 {
38577 PyThreadState* __tstate = wxPyBeginAllowThreads();
38578 result = (int)((wxItemContainer const *)arg1)->GetCount();
38579
38580 wxPyEndAllowThreads(__tstate);
38581 if (PyErr_Occurred()) SWIG_fail;
38582 }
38583 {
38584 resultobj = SWIG_From_int((int)(result));
38585 }
38586 return resultobj;
38587 fail:
38588 return NULL;
38589 }
38590
38591
38592 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
38593 PyObject *resultobj;
38594 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38595 bool result;
38596 PyObject * obj0 = 0 ;
38597 char *kwnames[] = {
38598 (char *) "self", NULL
38599 };
38600
38601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
38602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38603 if (SWIG_arg_fail(1)) SWIG_fail;
38604 {
38605 PyThreadState* __tstate = wxPyBeginAllowThreads();
38606 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
38607
38608 wxPyEndAllowThreads(__tstate);
38609 if (PyErr_Occurred()) SWIG_fail;
38610 }
38611 {
38612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38613 }
38614 return resultobj;
38615 fail:
38616 return NULL;
38617 }
38618
38619
38620 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38621 PyObject *resultobj;
38622 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38623 int arg2 ;
38624 wxString result;
38625 PyObject * obj0 = 0 ;
38626 PyObject * obj1 = 0 ;
38627 char *kwnames[] = {
38628 (char *) "self",(char *) "n", NULL
38629 };
38630
38631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38633 if (SWIG_arg_fail(1)) SWIG_fail;
38634 {
38635 arg2 = (int)(SWIG_As_int(obj1));
38636 if (SWIG_arg_fail(2)) SWIG_fail;
38637 }
38638 {
38639 PyThreadState* __tstate = wxPyBeginAllowThreads();
38640 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38641
38642 wxPyEndAllowThreads(__tstate);
38643 if (PyErr_Occurred()) SWIG_fail;
38644 }
38645 {
38646 #if wxUSE_UNICODE
38647 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38648 #else
38649 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38650 #endif
38651 }
38652 return resultobj;
38653 fail:
38654 return NULL;
38655 }
38656
38657
38658 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38659 PyObject *resultobj;
38660 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38661 wxArrayString result;
38662 PyObject * obj0 = 0 ;
38663 char *kwnames[] = {
38664 (char *) "self", NULL
38665 };
38666
38667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38669 if (SWIG_arg_fail(1)) SWIG_fail;
38670 {
38671 PyThreadState* __tstate = wxPyBeginAllowThreads();
38672 result = ((wxItemContainer const *)arg1)->GetStrings();
38673
38674 wxPyEndAllowThreads(__tstate);
38675 if (PyErr_Occurred()) SWIG_fail;
38676 }
38677 {
38678 resultobj = wxArrayString2PyList_helper(result);
38679 }
38680 return resultobj;
38681 fail:
38682 return NULL;
38683 }
38684
38685
38686 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38687 PyObject *resultobj;
38688 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38689 int arg2 ;
38690 wxString *arg3 = 0 ;
38691 bool temp3 = false ;
38692 PyObject * obj0 = 0 ;
38693 PyObject * obj1 = 0 ;
38694 PyObject * obj2 = 0 ;
38695 char *kwnames[] = {
38696 (char *) "self",(char *) "n",(char *) "s", NULL
38697 };
38698
38699 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38700 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38701 if (SWIG_arg_fail(1)) SWIG_fail;
38702 {
38703 arg2 = (int)(SWIG_As_int(obj1));
38704 if (SWIG_arg_fail(2)) SWIG_fail;
38705 }
38706 {
38707 arg3 = wxString_in_helper(obj2);
38708 if (arg3 == NULL) SWIG_fail;
38709 temp3 = true;
38710 }
38711 {
38712 PyThreadState* __tstate = wxPyBeginAllowThreads();
38713 (arg1)->SetString(arg2,(wxString const &)*arg3);
38714
38715 wxPyEndAllowThreads(__tstate);
38716 if (PyErr_Occurred()) SWIG_fail;
38717 }
38718 Py_INCREF(Py_None); resultobj = Py_None;
38719 {
38720 if (temp3)
38721 delete arg3;
38722 }
38723 return resultobj;
38724 fail:
38725 {
38726 if (temp3)
38727 delete arg3;
38728 }
38729 return NULL;
38730 }
38731
38732
38733 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38734 PyObject *resultobj;
38735 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38736 wxString *arg2 = 0 ;
38737 int result;
38738 bool temp2 = false ;
38739 PyObject * obj0 = 0 ;
38740 PyObject * obj1 = 0 ;
38741 char *kwnames[] = {
38742 (char *) "self",(char *) "s", NULL
38743 };
38744
38745 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38746 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38747 if (SWIG_arg_fail(1)) SWIG_fail;
38748 {
38749 arg2 = wxString_in_helper(obj1);
38750 if (arg2 == NULL) SWIG_fail;
38751 temp2 = true;
38752 }
38753 {
38754 PyThreadState* __tstate = wxPyBeginAllowThreads();
38755 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38756
38757 wxPyEndAllowThreads(__tstate);
38758 if (PyErr_Occurred()) SWIG_fail;
38759 }
38760 {
38761 resultobj = SWIG_From_int((int)(result));
38762 }
38763 {
38764 if (temp2)
38765 delete arg2;
38766 }
38767 return resultobj;
38768 fail:
38769 {
38770 if (temp2)
38771 delete arg2;
38772 }
38773 return NULL;
38774 }
38775
38776
38777 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38778 PyObject *resultobj;
38779 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38780 int arg2 ;
38781 PyObject * obj0 = 0 ;
38782 PyObject * obj1 = 0 ;
38783 char *kwnames[] = {
38784 (char *) "self",(char *) "n", NULL
38785 };
38786
38787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38789 if (SWIG_arg_fail(1)) SWIG_fail;
38790 {
38791 arg2 = (int)(SWIG_As_int(obj1));
38792 if (SWIG_arg_fail(2)) SWIG_fail;
38793 }
38794 {
38795 PyThreadState* __tstate = wxPyBeginAllowThreads();
38796 (arg1)->SetSelection(arg2);
38797
38798 wxPyEndAllowThreads(__tstate);
38799 if (PyErr_Occurred()) SWIG_fail;
38800 }
38801 Py_INCREF(Py_None); resultobj = Py_None;
38802 return resultobj;
38803 fail:
38804 return NULL;
38805 }
38806
38807
38808 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38809 PyObject *resultobj;
38810 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38811 int result;
38812 PyObject * obj0 = 0 ;
38813 char *kwnames[] = {
38814 (char *) "self", NULL
38815 };
38816
38817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38819 if (SWIG_arg_fail(1)) SWIG_fail;
38820 {
38821 PyThreadState* __tstate = wxPyBeginAllowThreads();
38822 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38823
38824 wxPyEndAllowThreads(__tstate);
38825 if (PyErr_Occurred()) SWIG_fail;
38826 }
38827 {
38828 resultobj = SWIG_From_int((int)(result));
38829 }
38830 return resultobj;
38831 fail:
38832 return NULL;
38833 }
38834
38835
38836 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38837 PyObject *resultobj;
38838 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38839 wxString *arg2 = 0 ;
38840 bool result;
38841 bool temp2 = false ;
38842 PyObject * obj0 = 0 ;
38843 PyObject * obj1 = 0 ;
38844 char *kwnames[] = {
38845 (char *) "self",(char *) "s", NULL
38846 };
38847
38848 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38849 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38850 if (SWIG_arg_fail(1)) SWIG_fail;
38851 {
38852 arg2 = wxString_in_helper(obj1);
38853 if (arg2 == NULL) SWIG_fail;
38854 temp2 = true;
38855 }
38856 {
38857 PyThreadState* __tstate = wxPyBeginAllowThreads();
38858 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38859
38860 wxPyEndAllowThreads(__tstate);
38861 if (PyErr_Occurred()) SWIG_fail;
38862 }
38863 {
38864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38865 }
38866 {
38867 if (temp2)
38868 delete arg2;
38869 }
38870 return resultobj;
38871 fail:
38872 {
38873 if (temp2)
38874 delete arg2;
38875 }
38876 return NULL;
38877 }
38878
38879
38880 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38881 PyObject *resultobj;
38882 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38883 wxString result;
38884 PyObject * obj0 = 0 ;
38885 char *kwnames[] = {
38886 (char *) "self", NULL
38887 };
38888
38889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38891 if (SWIG_arg_fail(1)) SWIG_fail;
38892 {
38893 PyThreadState* __tstate = wxPyBeginAllowThreads();
38894 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38895
38896 wxPyEndAllowThreads(__tstate);
38897 if (PyErr_Occurred()) SWIG_fail;
38898 }
38899 {
38900 #if wxUSE_UNICODE
38901 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38902 #else
38903 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38904 #endif
38905 }
38906 return resultobj;
38907 fail:
38908 return NULL;
38909 }
38910
38911
38912 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38913 PyObject *resultobj;
38914 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38915 int arg2 ;
38916 PyObject * obj0 = 0 ;
38917 PyObject * obj1 = 0 ;
38918 char *kwnames[] = {
38919 (char *) "self",(char *) "n", NULL
38920 };
38921
38922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38924 if (SWIG_arg_fail(1)) SWIG_fail;
38925 {
38926 arg2 = (int)(SWIG_As_int(obj1));
38927 if (SWIG_arg_fail(2)) SWIG_fail;
38928 }
38929 {
38930 PyThreadState* __tstate = wxPyBeginAllowThreads();
38931 (arg1)->Select(arg2);
38932
38933 wxPyEndAllowThreads(__tstate);
38934 if (PyErr_Occurred()) SWIG_fail;
38935 }
38936 Py_INCREF(Py_None); resultobj = Py_None;
38937 return resultobj;
38938 fail:
38939 return NULL;
38940 }
38941
38942
38943 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
38944 PyObject *obj;
38945 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38946 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38947 Py_INCREF(obj);
38948 return Py_BuildValue((char *)"");
38949 }
38950 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
38951 PyObject *obj;
38952 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38953 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38954 Py_INCREF(obj);
38955 return Py_BuildValue((char *)"");
38956 }
38957 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38958 PyObject *resultobj;
38959 wxSizerItem *result;
38960 char *kwnames[] = {
38961 NULL
38962 };
38963
38964 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
38965 {
38966 PyThreadState* __tstate = wxPyBeginAllowThreads();
38967 result = (wxSizerItem *)new wxSizerItem();
38968
38969 wxPyEndAllowThreads(__tstate);
38970 if (PyErr_Occurred()) SWIG_fail;
38971 }
38972 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38973 return resultobj;
38974 fail:
38975 return NULL;
38976 }
38977
38978
38979 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38980 PyObject *resultobj;
38981 wxWindow *arg1 = (wxWindow *) 0 ;
38982 int arg2 ;
38983 int arg3 ;
38984 int arg4 ;
38985 PyObject *arg5 = (PyObject *) NULL ;
38986 wxSizerItem *result;
38987 PyObject * obj0 = 0 ;
38988 PyObject * obj1 = 0 ;
38989 PyObject * obj2 = 0 ;
38990 PyObject * obj3 = 0 ;
38991 PyObject * obj4 = 0 ;
38992 char *kwnames[] = {
38993 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38994 };
38995
38996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38998 if (SWIG_arg_fail(1)) SWIG_fail;
38999 {
39000 arg2 = (int)(SWIG_As_int(obj1));
39001 if (SWIG_arg_fail(2)) SWIG_fail;
39002 }
39003 {
39004 arg3 = (int)(SWIG_As_int(obj2));
39005 if (SWIG_arg_fail(3)) SWIG_fail;
39006 }
39007 {
39008 arg4 = (int)(SWIG_As_int(obj3));
39009 if (SWIG_arg_fail(4)) SWIG_fail;
39010 }
39011 if (obj4) {
39012 arg5 = obj4;
39013 }
39014 {
39015 PyThreadState* __tstate = wxPyBeginAllowThreads();
39016 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39017
39018 wxPyEndAllowThreads(__tstate);
39019 if (PyErr_Occurred()) SWIG_fail;
39020 }
39021 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39022 return resultobj;
39023 fail:
39024 return NULL;
39025 }
39026
39027
39028 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39029 PyObject *resultobj;
39030 int arg1 ;
39031 int arg2 ;
39032 int arg3 ;
39033 int arg4 ;
39034 int arg5 ;
39035 PyObject *arg6 = (PyObject *) NULL ;
39036 wxSizerItem *result;
39037 PyObject * obj0 = 0 ;
39038 PyObject * obj1 = 0 ;
39039 PyObject * obj2 = 0 ;
39040 PyObject * obj3 = 0 ;
39041 PyObject * obj4 = 0 ;
39042 PyObject * obj5 = 0 ;
39043 char *kwnames[] = {
39044 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39045 };
39046
39047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39048 {
39049 arg1 = (int)(SWIG_As_int(obj0));
39050 if (SWIG_arg_fail(1)) SWIG_fail;
39051 }
39052 {
39053 arg2 = (int)(SWIG_As_int(obj1));
39054 if (SWIG_arg_fail(2)) SWIG_fail;
39055 }
39056 {
39057 arg3 = (int)(SWIG_As_int(obj2));
39058 if (SWIG_arg_fail(3)) SWIG_fail;
39059 }
39060 {
39061 arg4 = (int)(SWIG_As_int(obj3));
39062 if (SWIG_arg_fail(4)) SWIG_fail;
39063 }
39064 {
39065 arg5 = (int)(SWIG_As_int(obj4));
39066 if (SWIG_arg_fail(5)) SWIG_fail;
39067 }
39068 if (obj5) {
39069 arg6 = obj5;
39070 }
39071 {
39072 PyThreadState* __tstate = wxPyBeginAllowThreads();
39073 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
39074
39075 wxPyEndAllowThreads(__tstate);
39076 if (PyErr_Occurred()) SWIG_fail;
39077 }
39078 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39079 return resultobj;
39080 fail:
39081 return NULL;
39082 }
39083
39084
39085 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39086 PyObject *resultobj;
39087 wxSizer *arg1 = (wxSizer *) 0 ;
39088 int arg2 ;
39089 int arg3 ;
39090 int arg4 ;
39091 PyObject *arg5 = (PyObject *) NULL ;
39092 wxSizerItem *result;
39093 PyObject * obj0 = 0 ;
39094 PyObject * obj1 = 0 ;
39095 PyObject * obj2 = 0 ;
39096 PyObject * obj3 = 0 ;
39097 PyObject * obj4 = 0 ;
39098 char *kwnames[] = {
39099 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39100 };
39101
39102 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39103 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39104 if (SWIG_arg_fail(1)) SWIG_fail;
39105 {
39106 arg2 = (int)(SWIG_As_int(obj1));
39107 if (SWIG_arg_fail(2)) SWIG_fail;
39108 }
39109 {
39110 arg3 = (int)(SWIG_As_int(obj2));
39111 if (SWIG_arg_fail(3)) SWIG_fail;
39112 }
39113 {
39114 arg4 = (int)(SWIG_As_int(obj3));
39115 if (SWIG_arg_fail(4)) SWIG_fail;
39116 }
39117 if (obj4) {
39118 arg5 = obj4;
39119 }
39120 {
39121 PyThreadState* __tstate = wxPyBeginAllowThreads();
39122 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
39123
39124 wxPyEndAllowThreads(__tstate);
39125 if (PyErr_Occurred()) SWIG_fail;
39126 }
39127 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
39128 return resultobj;
39129 fail:
39130 return NULL;
39131 }
39132
39133
39134 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
39135 PyObject *resultobj;
39136 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39137 PyObject * obj0 = 0 ;
39138 char *kwnames[] = {
39139 (char *) "self", NULL
39140 };
39141
39142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
39143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39144 if (SWIG_arg_fail(1)) SWIG_fail;
39145 {
39146 PyThreadState* __tstate = wxPyBeginAllowThreads();
39147 (arg1)->DeleteWindows();
39148
39149 wxPyEndAllowThreads(__tstate);
39150 if (PyErr_Occurred()) SWIG_fail;
39151 }
39152 Py_INCREF(Py_None); resultobj = Py_None;
39153 return resultobj;
39154 fail:
39155 return NULL;
39156 }
39157
39158
39159 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39160 PyObject *resultobj;
39161 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39162 PyObject * obj0 = 0 ;
39163 char *kwnames[] = {
39164 (char *) "self", NULL
39165 };
39166
39167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
39168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39169 if (SWIG_arg_fail(1)) SWIG_fail;
39170 {
39171 PyThreadState* __tstate = wxPyBeginAllowThreads();
39172 (arg1)->DetachSizer();
39173
39174 wxPyEndAllowThreads(__tstate);
39175 if (PyErr_Occurred()) SWIG_fail;
39176 }
39177 Py_INCREF(Py_None); resultobj = Py_None;
39178 return resultobj;
39179 fail:
39180 return NULL;
39181 }
39182
39183
39184 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
39185 PyObject *resultobj;
39186 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39187 wxSize result;
39188 PyObject * obj0 = 0 ;
39189 char *kwnames[] = {
39190 (char *) "self", NULL
39191 };
39192
39193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
39194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39195 if (SWIG_arg_fail(1)) SWIG_fail;
39196 {
39197 PyThreadState* __tstate = wxPyBeginAllowThreads();
39198 result = (arg1)->GetSize();
39199
39200 wxPyEndAllowThreads(__tstate);
39201 if (PyErr_Occurred()) SWIG_fail;
39202 }
39203 {
39204 wxSize * resultptr;
39205 resultptr = new wxSize((wxSize &)(result));
39206 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39207 }
39208 return resultobj;
39209 fail:
39210 return NULL;
39211 }
39212
39213
39214 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
39215 PyObject *resultobj;
39216 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39217 wxSize result;
39218 PyObject * obj0 = 0 ;
39219 char *kwnames[] = {
39220 (char *) "self", NULL
39221 };
39222
39223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
39224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39225 if (SWIG_arg_fail(1)) SWIG_fail;
39226 {
39227 PyThreadState* __tstate = wxPyBeginAllowThreads();
39228 result = (arg1)->CalcMin();
39229
39230 wxPyEndAllowThreads(__tstate);
39231 if (PyErr_Occurred()) SWIG_fail;
39232 }
39233 {
39234 wxSize * resultptr;
39235 resultptr = new wxSize((wxSize &)(result));
39236 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39237 }
39238 return resultobj;
39239 fail:
39240 return NULL;
39241 }
39242
39243
39244 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39245 PyObject *resultobj;
39246 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39247 wxPoint arg2 ;
39248 wxSize arg3 ;
39249 PyObject * obj0 = 0 ;
39250 PyObject * obj1 = 0 ;
39251 PyObject * obj2 = 0 ;
39252 char *kwnames[] = {
39253 (char *) "self",(char *) "pos",(char *) "size", NULL
39254 };
39255
39256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
39257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39258 if (SWIG_arg_fail(1)) SWIG_fail;
39259 {
39260 wxPoint * argp;
39261 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
39262 if (SWIG_arg_fail(2)) SWIG_fail;
39263 if (argp == NULL) {
39264 SWIG_null_ref("wxPoint");
39265 }
39266 if (SWIG_arg_fail(2)) SWIG_fail;
39267 arg2 = *argp;
39268 }
39269 {
39270 wxSize * argp;
39271 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
39272 if (SWIG_arg_fail(3)) SWIG_fail;
39273 if (argp == NULL) {
39274 SWIG_null_ref("wxSize");
39275 }
39276 if (SWIG_arg_fail(3)) SWIG_fail;
39277 arg3 = *argp;
39278 }
39279 {
39280 PyThreadState* __tstate = wxPyBeginAllowThreads();
39281 (arg1)->SetDimension(arg2,arg3);
39282
39283 wxPyEndAllowThreads(__tstate);
39284 if (PyErr_Occurred()) SWIG_fail;
39285 }
39286 Py_INCREF(Py_None); resultobj = Py_None;
39287 return resultobj;
39288 fail:
39289 return NULL;
39290 }
39291
39292
39293 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39294 PyObject *resultobj;
39295 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39296 wxSize result;
39297 PyObject * obj0 = 0 ;
39298 char *kwnames[] = {
39299 (char *) "self", NULL
39300 };
39301
39302 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
39303 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39304 if (SWIG_arg_fail(1)) SWIG_fail;
39305 {
39306 PyThreadState* __tstate = wxPyBeginAllowThreads();
39307 result = (arg1)->GetMinSize();
39308
39309 wxPyEndAllowThreads(__tstate);
39310 if (PyErr_Occurred()) SWIG_fail;
39311 }
39312 {
39313 wxSize * resultptr;
39314 resultptr = new wxSize((wxSize &)(result));
39315 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39316 }
39317 return resultobj;
39318 fail:
39319 return NULL;
39320 }
39321
39322
39323 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39324 PyObject *resultobj;
39325 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39326 wxSize result;
39327 PyObject * obj0 = 0 ;
39328 char *kwnames[] = {
39329 (char *) "self", NULL
39330 };
39331
39332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
39333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39334 if (SWIG_arg_fail(1)) SWIG_fail;
39335 {
39336 PyThreadState* __tstate = wxPyBeginAllowThreads();
39337 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
39338
39339 wxPyEndAllowThreads(__tstate);
39340 if (PyErr_Occurred()) SWIG_fail;
39341 }
39342 {
39343 wxSize * resultptr;
39344 resultptr = new wxSize((wxSize &)(result));
39345 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
39346 }
39347 return resultobj;
39348 fail:
39349 return NULL;
39350 }
39351
39352
39353 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
39354 PyObject *resultobj;
39355 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39356 int arg2 ;
39357 int arg3 ;
39358 PyObject * obj0 = 0 ;
39359 PyObject * obj1 = 0 ;
39360 PyObject * obj2 = 0 ;
39361 char *kwnames[] = {
39362 (char *) "self",(char *) "x",(char *) "y", NULL
39363 };
39364
39365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39367 if (SWIG_arg_fail(1)) SWIG_fail;
39368 {
39369 arg2 = (int)(SWIG_As_int(obj1));
39370 if (SWIG_arg_fail(2)) SWIG_fail;
39371 }
39372 {
39373 arg3 = (int)(SWIG_As_int(obj2));
39374 if (SWIG_arg_fail(3)) SWIG_fail;
39375 }
39376 {
39377 PyThreadState* __tstate = wxPyBeginAllowThreads();
39378 (arg1)->SetInitSize(arg2,arg3);
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 *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
39391 PyObject *resultobj;
39392 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39393 int arg2 ;
39394 int arg3 ;
39395 PyObject * obj0 = 0 ;
39396 PyObject * obj1 = 0 ;
39397 PyObject * obj2 = 0 ;
39398 char *kwnames[] = {
39399 (char *) "self",(char *) "width",(char *) "height", NULL
39400 };
39401
39402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
39403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39404 if (SWIG_arg_fail(1)) SWIG_fail;
39405 {
39406 arg2 = (int)(SWIG_As_int(obj1));
39407 if (SWIG_arg_fail(2)) SWIG_fail;
39408 }
39409 {
39410 arg3 = (int)(SWIG_As_int(obj2));
39411 if (SWIG_arg_fail(3)) SWIG_fail;
39412 }
39413 {
39414 PyThreadState* __tstate = wxPyBeginAllowThreads();
39415 (arg1)->SetRatio(arg2,arg3);
39416
39417 wxPyEndAllowThreads(__tstate);
39418 if (PyErr_Occurred()) SWIG_fail;
39419 }
39420 Py_INCREF(Py_None); resultobj = Py_None;
39421 return resultobj;
39422 fail:
39423 return NULL;
39424 }
39425
39426
39427 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
39428 PyObject *resultobj;
39429 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39430 wxSize *arg2 = 0 ;
39431 wxSize temp2 ;
39432 PyObject * obj0 = 0 ;
39433 PyObject * obj1 = 0 ;
39434 char *kwnames[] = {
39435 (char *) "self",(char *) "size", NULL
39436 };
39437
39438 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
39439 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39440 if (SWIG_arg_fail(1)) SWIG_fail;
39441 {
39442 arg2 = &temp2;
39443 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39444 }
39445 {
39446 PyThreadState* __tstate = wxPyBeginAllowThreads();
39447 (arg1)->SetRatio((wxSize const &)*arg2);
39448
39449 wxPyEndAllowThreads(__tstate);
39450 if (PyErr_Occurred()) SWIG_fail;
39451 }
39452 Py_INCREF(Py_None); resultobj = Py_None;
39453 return resultobj;
39454 fail:
39455 return NULL;
39456 }
39457
39458
39459 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39460 PyObject *resultobj;
39461 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39462 float arg2 ;
39463 PyObject * obj0 = 0 ;
39464 PyObject * obj1 = 0 ;
39465 char *kwnames[] = {
39466 (char *) "self",(char *) "ratio", NULL
39467 };
39468
39469 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
39470 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39471 if (SWIG_arg_fail(1)) SWIG_fail;
39472 {
39473 arg2 = (float)(SWIG_As_float(obj1));
39474 if (SWIG_arg_fail(2)) SWIG_fail;
39475 }
39476 {
39477 PyThreadState* __tstate = wxPyBeginAllowThreads();
39478 (arg1)->SetRatio(arg2);
39479
39480 wxPyEndAllowThreads(__tstate);
39481 if (PyErr_Occurred()) SWIG_fail;
39482 }
39483 Py_INCREF(Py_None); resultobj = Py_None;
39484 return resultobj;
39485 fail:
39486 return NULL;
39487 }
39488
39489
39490 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
39491 PyObject *resultobj;
39492 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39493 float result;
39494 PyObject * obj0 = 0 ;
39495 char *kwnames[] = {
39496 (char *) "self", NULL
39497 };
39498
39499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
39500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39501 if (SWIG_arg_fail(1)) SWIG_fail;
39502 {
39503 PyThreadState* __tstate = wxPyBeginAllowThreads();
39504 result = (float)(arg1)->GetRatio();
39505
39506 wxPyEndAllowThreads(__tstate);
39507 if (PyErr_Occurred()) SWIG_fail;
39508 }
39509 {
39510 resultobj = SWIG_From_float((float)(result));
39511 }
39512 return resultobj;
39513 fail:
39514 return NULL;
39515 }
39516
39517
39518 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
39519 PyObject *resultobj;
39520 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39521 wxRect result;
39522 PyObject * obj0 = 0 ;
39523 char *kwnames[] = {
39524 (char *) "self", NULL
39525 };
39526
39527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
39528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39529 if (SWIG_arg_fail(1)) SWIG_fail;
39530 {
39531 PyThreadState* __tstate = wxPyBeginAllowThreads();
39532 result = (arg1)->GetRect();
39533
39534 wxPyEndAllowThreads(__tstate);
39535 if (PyErr_Occurred()) SWIG_fail;
39536 }
39537 {
39538 wxRect * resultptr;
39539 resultptr = new wxRect((wxRect &)(result));
39540 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
39541 }
39542 return resultobj;
39543 fail:
39544 return NULL;
39545 }
39546
39547
39548 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39549 PyObject *resultobj;
39550 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39551 bool result;
39552 PyObject * obj0 = 0 ;
39553 char *kwnames[] = {
39554 (char *) "self", NULL
39555 };
39556
39557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
39558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39559 if (SWIG_arg_fail(1)) SWIG_fail;
39560 {
39561 PyThreadState* __tstate = wxPyBeginAllowThreads();
39562 result = (bool)(arg1)->IsWindow();
39563
39564 wxPyEndAllowThreads(__tstate);
39565 if (PyErr_Occurred()) SWIG_fail;
39566 }
39567 {
39568 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39569 }
39570 return resultobj;
39571 fail:
39572 return NULL;
39573 }
39574
39575
39576 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39577 PyObject *resultobj;
39578 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39579 bool result;
39580 PyObject * obj0 = 0 ;
39581 char *kwnames[] = {
39582 (char *) "self", NULL
39583 };
39584
39585 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
39586 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39587 if (SWIG_arg_fail(1)) SWIG_fail;
39588 {
39589 PyThreadState* __tstate = wxPyBeginAllowThreads();
39590 result = (bool)(arg1)->IsSizer();
39591
39592 wxPyEndAllowThreads(__tstate);
39593 if (PyErr_Occurred()) SWIG_fail;
39594 }
39595 {
39596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39597 }
39598 return resultobj;
39599 fail:
39600 return NULL;
39601 }
39602
39603
39604 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39605 PyObject *resultobj;
39606 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39607 bool result;
39608 PyObject * obj0 = 0 ;
39609 char *kwnames[] = {
39610 (char *) "self", NULL
39611 };
39612
39613 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
39614 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39615 if (SWIG_arg_fail(1)) SWIG_fail;
39616 {
39617 PyThreadState* __tstate = wxPyBeginAllowThreads();
39618 result = (bool)(arg1)->IsSpacer();
39619
39620 wxPyEndAllowThreads(__tstate);
39621 if (PyErr_Occurred()) SWIG_fail;
39622 }
39623 {
39624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39625 }
39626 return resultobj;
39627 fail:
39628 return NULL;
39629 }
39630
39631
39632 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39633 PyObject *resultobj;
39634 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39635 int arg2 ;
39636 PyObject * obj0 = 0 ;
39637 PyObject * obj1 = 0 ;
39638 char *kwnames[] = {
39639 (char *) "self",(char *) "proportion", NULL
39640 };
39641
39642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39643 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39644 if (SWIG_arg_fail(1)) SWIG_fail;
39645 {
39646 arg2 = (int)(SWIG_As_int(obj1));
39647 if (SWIG_arg_fail(2)) SWIG_fail;
39648 }
39649 {
39650 PyThreadState* __tstate = wxPyBeginAllowThreads();
39651 (arg1)->SetProportion(arg2);
39652
39653 wxPyEndAllowThreads(__tstate);
39654 if (PyErr_Occurred()) SWIG_fail;
39655 }
39656 Py_INCREF(Py_None); resultobj = Py_None;
39657 return resultobj;
39658 fail:
39659 return NULL;
39660 }
39661
39662
39663 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39664 PyObject *resultobj;
39665 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39666 int result;
39667 PyObject * obj0 = 0 ;
39668 char *kwnames[] = {
39669 (char *) "self", NULL
39670 };
39671
39672 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39673 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39674 if (SWIG_arg_fail(1)) SWIG_fail;
39675 {
39676 PyThreadState* __tstate = wxPyBeginAllowThreads();
39677 result = (int)(arg1)->GetProportion();
39678
39679 wxPyEndAllowThreads(__tstate);
39680 if (PyErr_Occurred()) SWIG_fail;
39681 }
39682 {
39683 resultobj = SWIG_From_int((int)(result));
39684 }
39685 return resultobj;
39686 fail:
39687 return NULL;
39688 }
39689
39690
39691 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39692 PyObject *resultobj;
39693 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39694 int arg2 ;
39695 PyObject * obj0 = 0 ;
39696 PyObject * obj1 = 0 ;
39697 char *kwnames[] = {
39698 (char *) "self",(char *) "flag", NULL
39699 };
39700
39701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39703 if (SWIG_arg_fail(1)) SWIG_fail;
39704 {
39705 arg2 = (int)(SWIG_As_int(obj1));
39706 if (SWIG_arg_fail(2)) SWIG_fail;
39707 }
39708 {
39709 PyThreadState* __tstate = wxPyBeginAllowThreads();
39710 (arg1)->SetFlag(arg2);
39711
39712 wxPyEndAllowThreads(__tstate);
39713 if (PyErr_Occurred()) SWIG_fail;
39714 }
39715 Py_INCREF(Py_None); resultobj = Py_None;
39716 return resultobj;
39717 fail:
39718 return NULL;
39719 }
39720
39721
39722 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39723 PyObject *resultobj;
39724 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39725 int result;
39726 PyObject * obj0 = 0 ;
39727 char *kwnames[] = {
39728 (char *) "self", NULL
39729 };
39730
39731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39733 if (SWIG_arg_fail(1)) SWIG_fail;
39734 {
39735 PyThreadState* __tstate = wxPyBeginAllowThreads();
39736 result = (int)(arg1)->GetFlag();
39737
39738 wxPyEndAllowThreads(__tstate);
39739 if (PyErr_Occurred()) SWIG_fail;
39740 }
39741 {
39742 resultobj = SWIG_From_int((int)(result));
39743 }
39744 return resultobj;
39745 fail:
39746 return NULL;
39747 }
39748
39749
39750 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39751 PyObject *resultobj;
39752 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39753 int arg2 ;
39754 PyObject * obj0 = 0 ;
39755 PyObject * obj1 = 0 ;
39756 char *kwnames[] = {
39757 (char *) "self",(char *) "border", NULL
39758 };
39759
39760 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39761 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39762 if (SWIG_arg_fail(1)) SWIG_fail;
39763 {
39764 arg2 = (int)(SWIG_As_int(obj1));
39765 if (SWIG_arg_fail(2)) SWIG_fail;
39766 }
39767 {
39768 PyThreadState* __tstate = wxPyBeginAllowThreads();
39769 (arg1)->SetBorder(arg2);
39770
39771 wxPyEndAllowThreads(__tstate);
39772 if (PyErr_Occurred()) SWIG_fail;
39773 }
39774 Py_INCREF(Py_None); resultobj = Py_None;
39775 return resultobj;
39776 fail:
39777 return NULL;
39778 }
39779
39780
39781 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39782 PyObject *resultobj;
39783 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39784 int result;
39785 PyObject * obj0 = 0 ;
39786 char *kwnames[] = {
39787 (char *) "self", NULL
39788 };
39789
39790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39791 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39792 if (SWIG_arg_fail(1)) SWIG_fail;
39793 {
39794 PyThreadState* __tstate = wxPyBeginAllowThreads();
39795 result = (int)(arg1)->GetBorder();
39796
39797 wxPyEndAllowThreads(__tstate);
39798 if (PyErr_Occurred()) SWIG_fail;
39799 }
39800 {
39801 resultobj = SWIG_From_int((int)(result));
39802 }
39803 return resultobj;
39804 fail:
39805 return NULL;
39806 }
39807
39808
39809 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39810 PyObject *resultobj;
39811 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39812 wxWindow *result;
39813 PyObject * obj0 = 0 ;
39814 char *kwnames[] = {
39815 (char *) "self", NULL
39816 };
39817
39818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39820 if (SWIG_arg_fail(1)) SWIG_fail;
39821 {
39822 PyThreadState* __tstate = wxPyBeginAllowThreads();
39823 result = (wxWindow *)(arg1)->GetWindow();
39824
39825 wxPyEndAllowThreads(__tstate);
39826 if (PyErr_Occurred()) SWIG_fail;
39827 }
39828 {
39829 resultobj = wxPyMake_wxObject(result, 0);
39830 }
39831 return resultobj;
39832 fail:
39833 return NULL;
39834 }
39835
39836
39837 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39838 PyObject *resultobj;
39839 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39840 wxWindow *arg2 = (wxWindow *) 0 ;
39841 PyObject * obj0 = 0 ;
39842 PyObject * obj1 = 0 ;
39843 char *kwnames[] = {
39844 (char *) "self",(char *) "window", NULL
39845 };
39846
39847 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39848 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39849 if (SWIG_arg_fail(1)) SWIG_fail;
39850 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39851 if (SWIG_arg_fail(2)) SWIG_fail;
39852 {
39853 PyThreadState* __tstate = wxPyBeginAllowThreads();
39854 (arg1)->SetWindow(arg2);
39855
39856 wxPyEndAllowThreads(__tstate);
39857 if (PyErr_Occurred()) SWIG_fail;
39858 }
39859 Py_INCREF(Py_None); resultobj = Py_None;
39860 return resultobj;
39861 fail:
39862 return NULL;
39863 }
39864
39865
39866 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39867 PyObject *resultobj;
39868 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39869 wxSizer *result;
39870 PyObject * obj0 = 0 ;
39871 char *kwnames[] = {
39872 (char *) "self", NULL
39873 };
39874
39875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39877 if (SWIG_arg_fail(1)) SWIG_fail;
39878 {
39879 PyThreadState* __tstate = wxPyBeginAllowThreads();
39880 result = (wxSizer *)(arg1)->GetSizer();
39881
39882 wxPyEndAllowThreads(__tstate);
39883 if (PyErr_Occurred()) SWIG_fail;
39884 }
39885 {
39886 resultobj = wxPyMake_wxObject(result, 0);
39887 }
39888 return resultobj;
39889 fail:
39890 return NULL;
39891 }
39892
39893
39894 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39895 PyObject *resultobj;
39896 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39897 wxSizer *arg2 = (wxSizer *) 0 ;
39898 PyObject * obj0 = 0 ;
39899 PyObject * obj1 = 0 ;
39900 char *kwnames[] = {
39901 (char *) "self",(char *) "sizer", NULL
39902 };
39903
39904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39906 if (SWIG_arg_fail(1)) SWIG_fail;
39907 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39908 if (SWIG_arg_fail(2)) SWIG_fail;
39909 {
39910 PyThreadState* __tstate = wxPyBeginAllowThreads();
39911 (arg1)->SetSizer(arg2);
39912
39913 wxPyEndAllowThreads(__tstate);
39914 if (PyErr_Occurred()) SWIG_fail;
39915 }
39916 Py_INCREF(Py_None); resultobj = Py_None;
39917 return resultobj;
39918 fail:
39919 return NULL;
39920 }
39921
39922
39923 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39924 PyObject *resultobj;
39925 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39926 wxSize *result;
39927 PyObject * obj0 = 0 ;
39928 char *kwnames[] = {
39929 (char *) "self", NULL
39930 };
39931
39932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39934 if (SWIG_arg_fail(1)) SWIG_fail;
39935 {
39936 PyThreadState* __tstate = wxPyBeginAllowThreads();
39937 {
39938 wxSize const &_result_ref = (arg1)->GetSpacer();
39939 result = (wxSize *) &_result_ref;
39940 }
39941
39942 wxPyEndAllowThreads(__tstate);
39943 if (PyErr_Occurred()) SWIG_fail;
39944 }
39945 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39946 return resultobj;
39947 fail:
39948 return NULL;
39949 }
39950
39951
39952 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39953 PyObject *resultobj;
39954 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39955 wxSize *arg2 = 0 ;
39956 wxSize temp2 ;
39957 PyObject * obj0 = 0 ;
39958 PyObject * obj1 = 0 ;
39959 char *kwnames[] = {
39960 (char *) "self",(char *) "size", NULL
39961 };
39962
39963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39965 if (SWIG_arg_fail(1)) SWIG_fail;
39966 {
39967 arg2 = &temp2;
39968 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39969 }
39970 {
39971 PyThreadState* __tstate = wxPyBeginAllowThreads();
39972 (arg1)->SetSpacer((wxSize const &)*arg2);
39973
39974 wxPyEndAllowThreads(__tstate);
39975 if (PyErr_Occurred()) SWIG_fail;
39976 }
39977 Py_INCREF(Py_None); resultobj = Py_None;
39978 return resultobj;
39979 fail:
39980 return NULL;
39981 }
39982
39983
39984 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39985 PyObject *resultobj;
39986 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39987 bool arg2 ;
39988 PyObject * obj0 = 0 ;
39989 PyObject * obj1 = 0 ;
39990 char *kwnames[] = {
39991 (char *) "self",(char *) "show", NULL
39992 };
39993
39994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39996 if (SWIG_arg_fail(1)) SWIG_fail;
39997 {
39998 arg2 = (bool)(SWIG_As_bool(obj1));
39999 if (SWIG_arg_fail(2)) SWIG_fail;
40000 }
40001 {
40002 PyThreadState* __tstate = wxPyBeginAllowThreads();
40003 (arg1)->Show(arg2);
40004
40005 wxPyEndAllowThreads(__tstate);
40006 if (PyErr_Occurred()) SWIG_fail;
40007 }
40008 Py_INCREF(Py_None); resultobj = Py_None;
40009 return resultobj;
40010 fail:
40011 return NULL;
40012 }
40013
40014
40015 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40016 PyObject *resultobj;
40017 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40018 bool result;
40019 PyObject * obj0 = 0 ;
40020 char *kwnames[] = {
40021 (char *) "self", NULL
40022 };
40023
40024 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
40025 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40026 if (SWIG_arg_fail(1)) SWIG_fail;
40027 {
40028 PyThreadState* __tstate = wxPyBeginAllowThreads();
40029 result = (bool)(arg1)->IsShown();
40030
40031 wxPyEndAllowThreads(__tstate);
40032 if (PyErr_Occurred()) SWIG_fail;
40033 }
40034 {
40035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40036 }
40037 return resultobj;
40038 fail:
40039 return NULL;
40040 }
40041
40042
40043 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40044 PyObject *resultobj;
40045 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40046 wxPoint result;
40047 PyObject * obj0 = 0 ;
40048 char *kwnames[] = {
40049 (char *) "self", NULL
40050 };
40051
40052 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
40053 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40054 if (SWIG_arg_fail(1)) SWIG_fail;
40055 {
40056 PyThreadState* __tstate = wxPyBeginAllowThreads();
40057 result = (arg1)->GetPosition();
40058
40059 wxPyEndAllowThreads(__tstate);
40060 if (PyErr_Occurred()) SWIG_fail;
40061 }
40062 {
40063 wxPoint * resultptr;
40064 resultptr = new wxPoint((wxPoint &)(result));
40065 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40066 }
40067 return resultobj;
40068 fail:
40069 return NULL;
40070 }
40071
40072
40073 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
40074 PyObject *resultobj;
40075 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
40076 PyObject *result;
40077 PyObject * obj0 = 0 ;
40078 char *kwnames[] = {
40079 (char *) "self", NULL
40080 };
40081
40082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
40083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40084 if (SWIG_arg_fail(1)) SWIG_fail;
40085 {
40086 PyThreadState* __tstate = wxPyBeginAllowThreads();
40087 result = (PyObject *)wxSizerItem_GetUserData(arg1);
40088
40089 wxPyEndAllowThreads(__tstate);
40090 if (PyErr_Occurred()) SWIG_fail;
40091 }
40092 resultobj = result;
40093 return resultobj;
40094 fail:
40095 return NULL;
40096 }
40097
40098
40099 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
40100 PyObject *obj;
40101 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40102 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
40103 Py_INCREF(obj);
40104 return Py_BuildValue((char *)"");
40105 }
40106 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40107 PyObject *resultobj;
40108 wxSizer *arg1 = (wxSizer *) 0 ;
40109 PyObject *arg2 = (PyObject *) 0 ;
40110 PyObject * obj0 = 0 ;
40111 PyObject * obj1 = 0 ;
40112 char *kwnames[] = {
40113 (char *) "self",(char *) "_self", NULL
40114 };
40115
40116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
40117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40118 if (SWIG_arg_fail(1)) SWIG_fail;
40119 arg2 = obj1;
40120 {
40121 PyThreadState* __tstate = wxPyBeginAllowThreads();
40122 wxSizer__setOORInfo(arg1,arg2);
40123
40124 wxPyEndAllowThreads(__tstate);
40125 if (PyErr_Occurred()) SWIG_fail;
40126 }
40127 Py_INCREF(Py_None); resultobj = Py_None;
40128 return resultobj;
40129 fail:
40130 return NULL;
40131 }
40132
40133
40134 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
40135 PyObject *resultobj;
40136 wxSizer *arg1 = (wxSizer *) 0 ;
40137 PyObject *arg2 = (PyObject *) 0 ;
40138 int arg3 = (int) 0 ;
40139 int arg4 = (int) 0 ;
40140 int arg5 = (int) 0 ;
40141 PyObject *arg6 = (PyObject *) NULL ;
40142 wxSizerItem *result;
40143 PyObject * obj0 = 0 ;
40144 PyObject * obj1 = 0 ;
40145 PyObject * obj2 = 0 ;
40146 PyObject * obj3 = 0 ;
40147 PyObject * obj4 = 0 ;
40148 PyObject * obj5 = 0 ;
40149 char *kwnames[] = {
40150 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40151 };
40152
40153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40155 if (SWIG_arg_fail(1)) SWIG_fail;
40156 arg2 = obj1;
40157 if (obj2) {
40158 {
40159 arg3 = (int)(SWIG_As_int(obj2));
40160 if (SWIG_arg_fail(3)) SWIG_fail;
40161 }
40162 }
40163 if (obj3) {
40164 {
40165 arg4 = (int)(SWIG_As_int(obj3));
40166 if (SWIG_arg_fail(4)) SWIG_fail;
40167 }
40168 }
40169 if (obj4) {
40170 {
40171 arg5 = (int)(SWIG_As_int(obj4));
40172 if (SWIG_arg_fail(5)) SWIG_fail;
40173 }
40174 }
40175 if (obj5) {
40176 arg6 = obj5;
40177 }
40178 {
40179 PyThreadState* __tstate = wxPyBeginAllowThreads();
40180 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
40181
40182 wxPyEndAllowThreads(__tstate);
40183 if (PyErr_Occurred()) SWIG_fail;
40184 }
40185 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40186 return resultobj;
40187 fail:
40188 return NULL;
40189 }
40190
40191
40192 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
40193 PyObject *resultobj;
40194 wxSizer *arg1 = (wxSizer *) 0 ;
40195 int arg2 ;
40196 PyObject *arg3 = (PyObject *) 0 ;
40197 int arg4 = (int) 0 ;
40198 int arg5 = (int) 0 ;
40199 int arg6 = (int) 0 ;
40200 PyObject *arg7 = (PyObject *) NULL ;
40201 wxSizerItem *result;
40202 PyObject * obj0 = 0 ;
40203 PyObject * obj1 = 0 ;
40204 PyObject * obj2 = 0 ;
40205 PyObject * obj3 = 0 ;
40206 PyObject * obj4 = 0 ;
40207 PyObject * obj5 = 0 ;
40208 PyObject * obj6 = 0 ;
40209 char *kwnames[] = {
40210 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40211 };
40212
40213 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
40214 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40215 if (SWIG_arg_fail(1)) SWIG_fail;
40216 {
40217 arg2 = (int)(SWIG_As_int(obj1));
40218 if (SWIG_arg_fail(2)) SWIG_fail;
40219 }
40220 arg3 = obj2;
40221 if (obj3) {
40222 {
40223 arg4 = (int)(SWIG_As_int(obj3));
40224 if (SWIG_arg_fail(4)) SWIG_fail;
40225 }
40226 }
40227 if (obj4) {
40228 {
40229 arg5 = (int)(SWIG_As_int(obj4));
40230 if (SWIG_arg_fail(5)) SWIG_fail;
40231 }
40232 }
40233 if (obj5) {
40234 {
40235 arg6 = (int)(SWIG_As_int(obj5));
40236 if (SWIG_arg_fail(6)) SWIG_fail;
40237 }
40238 }
40239 if (obj6) {
40240 arg7 = obj6;
40241 }
40242 {
40243 PyThreadState* __tstate = wxPyBeginAllowThreads();
40244 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
40245
40246 wxPyEndAllowThreads(__tstate);
40247 if (PyErr_Occurred()) SWIG_fail;
40248 }
40249 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40250 return resultobj;
40251 fail:
40252 return NULL;
40253 }
40254
40255
40256 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
40257 PyObject *resultobj;
40258 wxSizer *arg1 = (wxSizer *) 0 ;
40259 PyObject *arg2 = (PyObject *) 0 ;
40260 int arg3 = (int) 0 ;
40261 int arg4 = (int) 0 ;
40262 int arg5 = (int) 0 ;
40263 PyObject *arg6 = (PyObject *) NULL ;
40264 wxSizerItem *result;
40265 PyObject * obj0 = 0 ;
40266 PyObject * obj1 = 0 ;
40267 PyObject * obj2 = 0 ;
40268 PyObject * obj3 = 0 ;
40269 PyObject * obj4 = 0 ;
40270 PyObject * obj5 = 0 ;
40271 char *kwnames[] = {
40272 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
40273 };
40274
40275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
40276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40277 if (SWIG_arg_fail(1)) SWIG_fail;
40278 arg2 = obj1;
40279 if (obj2) {
40280 {
40281 arg3 = (int)(SWIG_As_int(obj2));
40282 if (SWIG_arg_fail(3)) SWIG_fail;
40283 }
40284 }
40285 if (obj3) {
40286 {
40287 arg4 = (int)(SWIG_As_int(obj3));
40288 if (SWIG_arg_fail(4)) SWIG_fail;
40289 }
40290 }
40291 if (obj4) {
40292 {
40293 arg5 = (int)(SWIG_As_int(obj4));
40294 if (SWIG_arg_fail(5)) SWIG_fail;
40295 }
40296 }
40297 if (obj5) {
40298 arg6 = obj5;
40299 }
40300 {
40301 PyThreadState* __tstate = wxPyBeginAllowThreads();
40302 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
40303
40304 wxPyEndAllowThreads(__tstate);
40305 if (PyErr_Occurred()) SWIG_fail;
40306 }
40307 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40308 return resultobj;
40309 fail:
40310 return NULL;
40311 }
40312
40313
40314 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
40315 PyObject *resultobj;
40316 wxSizer *arg1 = (wxSizer *) 0 ;
40317 PyObject *arg2 = (PyObject *) 0 ;
40318 bool result;
40319 PyObject * obj0 = 0 ;
40320 PyObject * obj1 = 0 ;
40321 char *kwnames[] = {
40322 (char *) "self",(char *) "item", NULL
40323 };
40324
40325 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
40326 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40327 if (SWIG_arg_fail(1)) SWIG_fail;
40328 arg2 = obj1;
40329 {
40330 PyThreadState* __tstate = wxPyBeginAllowThreads();
40331 result = (bool)wxSizer_Remove(arg1,arg2);
40332
40333 wxPyEndAllowThreads(__tstate);
40334 if (PyErr_Occurred()) SWIG_fail;
40335 }
40336 {
40337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40338 }
40339 return resultobj;
40340 fail:
40341 return NULL;
40342 }
40343
40344
40345 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
40346 PyObject *resultobj;
40347 wxSizer *arg1 = (wxSizer *) 0 ;
40348 PyObject *arg2 = (PyObject *) 0 ;
40349 bool result;
40350 PyObject * obj0 = 0 ;
40351 PyObject * obj1 = 0 ;
40352 char *kwnames[] = {
40353 (char *) "self",(char *) "item", NULL
40354 };
40355
40356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
40357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40358 if (SWIG_arg_fail(1)) SWIG_fail;
40359 arg2 = obj1;
40360 {
40361 PyThreadState* __tstate = wxPyBeginAllowThreads();
40362 result = (bool)wxSizer_Detach(arg1,arg2);
40363
40364 wxPyEndAllowThreads(__tstate);
40365 if (PyErr_Occurred()) SWIG_fail;
40366 }
40367 {
40368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40369 }
40370 return resultobj;
40371 fail:
40372 return NULL;
40373 }
40374
40375
40376 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
40377 PyObject *resultobj;
40378 wxSizer *arg1 = (wxSizer *) 0 ;
40379 PyObject *arg2 = (PyObject *) 0 ;
40380 wxSizerItem *result;
40381 PyObject * obj0 = 0 ;
40382 PyObject * obj1 = 0 ;
40383 char *kwnames[] = {
40384 (char *) "self",(char *) "item", NULL
40385 };
40386
40387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
40388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40389 if (SWIG_arg_fail(1)) SWIG_fail;
40390 arg2 = obj1;
40391 {
40392 PyThreadState* __tstate = wxPyBeginAllowThreads();
40393 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
40394
40395 wxPyEndAllowThreads(__tstate);
40396 if (PyErr_Occurred()) SWIG_fail;
40397 }
40398 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40399 return resultobj;
40400 fail:
40401 return NULL;
40402 }
40403
40404
40405 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40406 PyObject *resultobj;
40407 wxSizer *arg1 = (wxSizer *) 0 ;
40408 PyObject *arg2 = (PyObject *) 0 ;
40409 wxSize *arg3 = 0 ;
40410 wxSize temp3 ;
40411 PyObject * obj0 = 0 ;
40412 PyObject * obj1 = 0 ;
40413 PyObject * obj2 = 0 ;
40414 char *kwnames[] = {
40415 (char *) "self",(char *) "item",(char *) "size", NULL
40416 };
40417
40418 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
40419 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40420 if (SWIG_arg_fail(1)) SWIG_fail;
40421 arg2 = obj1;
40422 {
40423 arg3 = &temp3;
40424 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
40425 }
40426 {
40427 PyThreadState* __tstate = wxPyBeginAllowThreads();
40428 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
40429
40430 wxPyEndAllowThreads(__tstate);
40431 if (PyErr_Occurred()) SWIG_fail;
40432 }
40433 Py_INCREF(Py_None); resultobj = Py_None;
40434 return resultobj;
40435 fail:
40436 return NULL;
40437 }
40438
40439
40440 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
40441 PyObject *resultobj;
40442 wxSizer *arg1 = (wxSizer *) 0 ;
40443 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40444 wxSizerItem *result;
40445 PyObject * obj0 = 0 ;
40446 PyObject * obj1 = 0 ;
40447 char *kwnames[] = {
40448 (char *) "self",(char *) "item", NULL
40449 };
40450
40451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
40452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40453 if (SWIG_arg_fail(1)) SWIG_fail;
40454 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40455 if (SWIG_arg_fail(2)) SWIG_fail;
40456 {
40457 PyThreadState* __tstate = wxPyBeginAllowThreads();
40458 result = (wxSizerItem *)(arg1)->Add(arg2);
40459
40460 wxPyEndAllowThreads(__tstate);
40461 if (PyErr_Occurred()) SWIG_fail;
40462 }
40463 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40464 return resultobj;
40465 fail:
40466 return NULL;
40467 }
40468
40469
40470 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
40471 PyObject *resultobj;
40472 wxSizer *arg1 = (wxSizer *) 0 ;
40473 size_t arg2 ;
40474 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
40475 wxSizerItem *result;
40476 PyObject * obj0 = 0 ;
40477 PyObject * obj1 = 0 ;
40478 PyObject * obj2 = 0 ;
40479 char *kwnames[] = {
40480 (char *) "self",(char *) "index",(char *) "item", NULL
40481 };
40482
40483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
40484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40485 if (SWIG_arg_fail(1)) SWIG_fail;
40486 {
40487 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
40488 if (SWIG_arg_fail(2)) SWIG_fail;
40489 }
40490 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40491 if (SWIG_arg_fail(3)) SWIG_fail;
40492 {
40493 PyThreadState* __tstate = wxPyBeginAllowThreads();
40494 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
40495
40496 wxPyEndAllowThreads(__tstate);
40497 if (PyErr_Occurred()) SWIG_fail;
40498 }
40499 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40500 return resultobj;
40501 fail:
40502 return NULL;
40503 }
40504
40505
40506 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
40507 PyObject *resultobj;
40508 wxSizer *arg1 = (wxSizer *) 0 ;
40509 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
40510 wxSizerItem *result;
40511 PyObject * obj0 = 0 ;
40512 PyObject * obj1 = 0 ;
40513 char *kwnames[] = {
40514 (char *) "self",(char *) "item", NULL
40515 };
40516
40517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
40518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40519 if (SWIG_arg_fail(1)) SWIG_fail;
40520 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
40521 if (SWIG_arg_fail(2)) SWIG_fail;
40522 {
40523 PyThreadState* __tstate = wxPyBeginAllowThreads();
40524 result = (wxSizerItem *)(arg1)->Prepend(arg2);
40525
40526 wxPyEndAllowThreads(__tstate);
40527 if (PyErr_Occurred()) SWIG_fail;
40528 }
40529 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
40530 return resultobj;
40531 fail:
40532 return NULL;
40533 }
40534
40535
40536 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
40537 PyObject *resultobj;
40538 wxSizer *arg1 = (wxSizer *) 0 ;
40539 int arg2 ;
40540 int arg3 ;
40541 int arg4 ;
40542 int arg5 ;
40543 PyObject * obj0 = 0 ;
40544 PyObject * obj1 = 0 ;
40545 PyObject * obj2 = 0 ;
40546 PyObject * obj3 = 0 ;
40547 PyObject * obj4 = 0 ;
40548 char *kwnames[] = {
40549 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
40550 };
40551
40552 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
40553 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40554 if (SWIG_arg_fail(1)) SWIG_fail;
40555 {
40556 arg2 = (int)(SWIG_As_int(obj1));
40557 if (SWIG_arg_fail(2)) SWIG_fail;
40558 }
40559 {
40560 arg3 = (int)(SWIG_As_int(obj2));
40561 if (SWIG_arg_fail(3)) SWIG_fail;
40562 }
40563 {
40564 arg4 = (int)(SWIG_As_int(obj3));
40565 if (SWIG_arg_fail(4)) SWIG_fail;
40566 }
40567 {
40568 arg5 = (int)(SWIG_As_int(obj4));
40569 if (SWIG_arg_fail(5)) SWIG_fail;
40570 }
40571 {
40572 PyThreadState* __tstate = wxPyBeginAllowThreads();
40573 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
40574
40575 wxPyEndAllowThreads(__tstate);
40576 if (PyErr_Occurred()) SWIG_fail;
40577 }
40578 Py_INCREF(Py_None); resultobj = Py_None;
40579 return resultobj;
40580 fail:
40581 return NULL;
40582 }
40583
40584
40585 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40586 PyObject *resultobj;
40587 wxSizer *arg1 = (wxSizer *) 0 ;
40588 wxSize *arg2 = 0 ;
40589 wxSize temp2 ;
40590 PyObject * obj0 = 0 ;
40591 PyObject * obj1 = 0 ;
40592 char *kwnames[] = {
40593 (char *) "self",(char *) "size", NULL
40594 };
40595
40596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
40597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40598 if (SWIG_arg_fail(1)) SWIG_fail;
40599 {
40600 arg2 = &temp2;
40601 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
40602 }
40603 {
40604 PyThreadState* __tstate = wxPyBeginAllowThreads();
40605 (arg1)->SetMinSize((wxSize const &)*arg2);
40606
40607 wxPyEndAllowThreads(__tstate);
40608 if (PyErr_Occurred()) SWIG_fail;
40609 }
40610 Py_INCREF(Py_None); resultobj = Py_None;
40611 return resultobj;
40612 fail:
40613 return NULL;
40614 }
40615
40616
40617 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40618 PyObject *resultobj;
40619 wxSizer *arg1 = (wxSizer *) 0 ;
40620 wxSize result;
40621 PyObject * obj0 = 0 ;
40622 char *kwnames[] = {
40623 (char *) "self", NULL
40624 };
40625
40626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40628 if (SWIG_arg_fail(1)) SWIG_fail;
40629 {
40630 PyThreadState* __tstate = wxPyBeginAllowThreads();
40631 result = (arg1)->GetSize();
40632
40633 wxPyEndAllowThreads(__tstate);
40634 if (PyErr_Occurred()) SWIG_fail;
40635 }
40636 {
40637 wxSize * resultptr;
40638 resultptr = new wxSize((wxSize &)(result));
40639 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40640 }
40641 return resultobj;
40642 fail:
40643 return NULL;
40644 }
40645
40646
40647 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40648 PyObject *resultobj;
40649 wxSizer *arg1 = (wxSizer *) 0 ;
40650 wxPoint result;
40651 PyObject * obj0 = 0 ;
40652 char *kwnames[] = {
40653 (char *) "self", NULL
40654 };
40655
40656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40658 if (SWIG_arg_fail(1)) SWIG_fail;
40659 {
40660 PyThreadState* __tstate = wxPyBeginAllowThreads();
40661 result = (arg1)->GetPosition();
40662
40663 wxPyEndAllowThreads(__tstate);
40664 if (PyErr_Occurred()) SWIG_fail;
40665 }
40666 {
40667 wxPoint * resultptr;
40668 resultptr = new wxPoint((wxPoint &)(result));
40669 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40670 }
40671 return resultobj;
40672 fail:
40673 return NULL;
40674 }
40675
40676
40677 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40678 PyObject *resultobj;
40679 wxSizer *arg1 = (wxSizer *) 0 ;
40680 wxSize result;
40681 PyObject * obj0 = 0 ;
40682 char *kwnames[] = {
40683 (char *) "self", NULL
40684 };
40685
40686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40688 if (SWIG_arg_fail(1)) SWIG_fail;
40689 {
40690 PyThreadState* __tstate = wxPyBeginAllowThreads();
40691 result = (arg1)->GetMinSize();
40692
40693 wxPyEndAllowThreads(__tstate);
40694 if (PyErr_Occurred()) SWIG_fail;
40695 }
40696 {
40697 wxSize * resultptr;
40698 resultptr = new wxSize((wxSize &)(result));
40699 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40700 }
40701 return resultobj;
40702 fail:
40703 return NULL;
40704 }
40705
40706
40707 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40708 PyObject *resultobj;
40709 wxSizer *arg1 = (wxSizer *) 0 ;
40710 PyObject * obj0 = 0 ;
40711 char *kwnames[] = {
40712 (char *) "self", NULL
40713 };
40714
40715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40717 if (SWIG_arg_fail(1)) SWIG_fail;
40718 {
40719 PyThreadState* __tstate = wxPyBeginAllowThreads();
40720 (arg1)->RecalcSizes();
40721
40722 wxPyEndAllowThreads(__tstate);
40723 if (PyErr_Occurred()) SWIG_fail;
40724 }
40725 Py_INCREF(Py_None); resultobj = Py_None;
40726 return resultobj;
40727 fail:
40728 return NULL;
40729 }
40730
40731
40732 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40733 PyObject *resultobj;
40734 wxSizer *arg1 = (wxSizer *) 0 ;
40735 wxSize result;
40736 PyObject * obj0 = 0 ;
40737 char *kwnames[] = {
40738 (char *) "self", NULL
40739 };
40740
40741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40743 if (SWIG_arg_fail(1)) SWIG_fail;
40744 {
40745 PyThreadState* __tstate = wxPyBeginAllowThreads();
40746 result = (arg1)->CalcMin();
40747
40748 wxPyEndAllowThreads(__tstate);
40749 if (PyErr_Occurred()) SWIG_fail;
40750 }
40751 {
40752 wxSize * resultptr;
40753 resultptr = new wxSize((wxSize &)(result));
40754 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40755 }
40756 return resultobj;
40757 fail:
40758 return NULL;
40759 }
40760
40761
40762 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40763 PyObject *resultobj;
40764 wxSizer *arg1 = (wxSizer *) 0 ;
40765 PyObject * obj0 = 0 ;
40766 char *kwnames[] = {
40767 (char *) "self", NULL
40768 };
40769
40770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) goto fail;
40771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40772 if (SWIG_arg_fail(1)) SWIG_fail;
40773 {
40774 PyThreadState* __tstate = wxPyBeginAllowThreads();
40775 (arg1)->Layout();
40776
40777 wxPyEndAllowThreads(__tstate);
40778 if (PyErr_Occurred()) SWIG_fail;
40779 }
40780 Py_INCREF(Py_None); resultobj = Py_None;
40781 return resultobj;
40782 fail:
40783 return NULL;
40784 }
40785
40786
40787 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40788 PyObject *resultobj;
40789 wxSizer *arg1 = (wxSizer *) 0 ;
40790 wxWindow *arg2 = (wxWindow *) 0 ;
40791 wxSize result;
40792 PyObject * obj0 = 0 ;
40793 PyObject * obj1 = 0 ;
40794 char *kwnames[] = {
40795 (char *) "self",(char *) "window", NULL
40796 };
40797
40798 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40799 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40800 if (SWIG_arg_fail(1)) SWIG_fail;
40801 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40802 if (SWIG_arg_fail(2)) SWIG_fail;
40803 {
40804 PyThreadState* __tstate = wxPyBeginAllowThreads();
40805 result = (arg1)->Fit(arg2);
40806
40807 wxPyEndAllowThreads(__tstate);
40808 if (PyErr_Occurred()) SWIG_fail;
40809 }
40810 {
40811 wxSize * resultptr;
40812 resultptr = new wxSize((wxSize &)(result));
40813 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40814 }
40815 return resultobj;
40816 fail:
40817 return NULL;
40818 }
40819
40820
40821 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40822 PyObject *resultobj;
40823 wxSizer *arg1 = (wxSizer *) 0 ;
40824 wxWindow *arg2 = (wxWindow *) 0 ;
40825 PyObject * obj0 = 0 ;
40826 PyObject * obj1 = 0 ;
40827 char *kwnames[] = {
40828 (char *) "self",(char *) "window", NULL
40829 };
40830
40831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40833 if (SWIG_arg_fail(1)) SWIG_fail;
40834 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40835 if (SWIG_arg_fail(2)) SWIG_fail;
40836 {
40837 PyThreadState* __tstate = wxPyBeginAllowThreads();
40838 (arg1)->FitInside(arg2);
40839
40840 wxPyEndAllowThreads(__tstate);
40841 if (PyErr_Occurred()) SWIG_fail;
40842 }
40843 Py_INCREF(Py_None); resultobj = Py_None;
40844 return resultobj;
40845 fail:
40846 return NULL;
40847 }
40848
40849
40850 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40851 PyObject *resultobj;
40852 wxSizer *arg1 = (wxSizer *) 0 ;
40853 wxWindow *arg2 = (wxWindow *) 0 ;
40854 PyObject * obj0 = 0 ;
40855 PyObject * obj1 = 0 ;
40856 char *kwnames[] = {
40857 (char *) "self",(char *) "window", NULL
40858 };
40859
40860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40862 if (SWIG_arg_fail(1)) SWIG_fail;
40863 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40864 if (SWIG_arg_fail(2)) SWIG_fail;
40865 {
40866 PyThreadState* __tstate = wxPyBeginAllowThreads();
40867 (arg1)->SetSizeHints(arg2);
40868
40869 wxPyEndAllowThreads(__tstate);
40870 if (PyErr_Occurred()) SWIG_fail;
40871 }
40872 Py_INCREF(Py_None); resultobj = Py_None;
40873 return resultobj;
40874 fail:
40875 return NULL;
40876 }
40877
40878
40879 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40880 PyObject *resultobj;
40881 wxSizer *arg1 = (wxSizer *) 0 ;
40882 wxWindow *arg2 = (wxWindow *) 0 ;
40883 PyObject * obj0 = 0 ;
40884 PyObject * obj1 = 0 ;
40885 char *kwnames[] = {
40886 (char *) "self",(char *) "window", NULL
40887 };
40888
40889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40891 if (SWIG_arg_fail(1)) SWIG_fail;
40892 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40893 if (SWIG_arg_fail(2)) SWIG_fail;
40894 {
40895 PyThreadState* __tstate = wxPyBeginAllowThreads();
40896 (arg1)->SetVirtualSizeHints(arg2);
40897
40898 wxPyEndAllowThreads(__tstate);
40899 if (PyErr_Occurred()) SWIG_fail;
40900 }
40901 Py_INCREF(Py_None); resultobj = Py_None;
40902 return resultobj;
40903 fail:
40904 return NULL;
40905 }
40906
40907
40908 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40909 PyObject *resultobj;
40910 wxSizer *arg1 = (wxSizer *) 0 ;
40911 bool arg2 = (bool) false ;
40912 PyObject * obj0 = 0 ;
40913 PyObject * obj1 = 0 ;
40914 char *kwnames[] = {
40915 (char *) "self",(char *) "deleteWindows", NULL
40916 };
40917
40918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40920 if (SWIG_arg_fail(1)) SWIG_fail;
40921 if (obj1) {
40922 {
40923 arg2 = (bool)(SWIG_As_bool(obj1));
40924 if (SWIG_arg_fail(2)) SWIG_fail;
40925 }
40926 }
40927 {
40928 PyThreadState* __tstate = wxPyBeginAllowThreads();
40929 (arg1)->Clear(arg2);
40930
40931 wxPyEndAllowThreads(__tstate);
40932 if (PyErr_Occurred()) SWIG_fail;
40933 }
40934 Py_INCREF(Py_None); resultobj = Py_None;
40935 return resultobj;
40936 fail:
40937 return NULL;
40938 }
40939
40940
40941 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40942 PyObject *resultobj;
40943 wxSizer *arg1 = (wxSizer *) 0 ;
40944 PyObject * obj0 = 0 ;
40945 char *kwnames[] = {
40946 (char *) "self", NULL
40947 };
40948
40949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
40950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40951 if (SWIG_arg_fail(1)) SWIG_fail;
40952 {
40953 PyThreadState* __tstate = wxPyBeginAllowThreads();
40954 (arg1)->DeleteWindows();
40955
40956 wxPyEndAllowThreads(__tstate);
40957 if (PyErr_Occurred()) SWIG_fail;
40958 }
40959 Py_INCREF(Py_None); resultobj = Py_None;
40960 return resultobj;
40961 fail:
40962 return NULL;
40963 }
40964
40965
40966 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40967 PyObject *resultobj;
40968 wxSizer *arg1 = (wxSizer *) 0 ;
40969 PyObject *result;
40970 PyObject * obj0 = 0 ;
40971 char *kwnames[] = {
40972 (char *) "self", NULL
40973 };
40974
40975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40977 if (SWIG_arg_fail(1)) SWIG_fail;
40978 {
40979 PyThreadState* __tstate = wxPyBeginAllowThreads();
40980 result = (PyObject *)wxSizer_GetChildren(arg1);
40981
40982 wxPyEndAllowThreads(__tstate);
40983 if (PyErr_Occurred()) SWIG_fail;
40984 }
40985 resultobj = result;
40986 return resultobj;
40987 fail:
40988 return NULL;
40989 }
40990
40991
40992 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40993 PyObject *resultobj;
40994 wxSizer *arg1 = (wxSizer *) 0 ;
40995 PyObject *arg2 = (PyObject *) 0 ;
40996 bool arg3 = (bool) true ;
40997 bool arg4 = (bool) false ;
40998 bool result;
40999 PyObject * obj0 = 0 ;
41000 PyObject * obj1 = 0 ;
41001 PyObject * obj2 = 0 ;
41002 PyObject * obj3 = 0 ;
41003 char *kwnames[] = {
41004 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
41005 };
41006
41007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41009 if (SWIG_arg_fail(1)) SWIG_fail;
41010 arg2 = obj1;
41011 if (obj2) {
41012 {
41013 arg3 = (bool)(SWIG_As_bool(obj2));
41014 if (SWIG_arg_fail(3)) SWIG_fail;
41015 }
41016 }
41017 if (obj3) {
41018 {
41019 arg4 = (bool)(SWIG_As_bool(obj3));
41020 if (SWIG_arg_fail(4)) SWIG_fail;
41021 }
41022 }
41023 {
41024 PyThreadState* __tstate = wxPyBeginAllowThreads();
41025 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
41026
41027 wxPyEndAllowThreads(__tstate);
41028 if (PyErr_Occurred()) SWIG_fail;
41029 }
41030 {
41031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41032 }
41033 return resultobj;
41034 fail:
41035 return NULL;
41036 }
41037
41038
41039 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
41040 PyObject *resultobj;
41041 wxSizer *arg1 = (wxSizer *) 0 ;
41042 PyObject *arg2 = (PyObject *) 0 ;
41043 bool result;
41044 PyObject * obj0 = 0 ;
41045 PyObject * obj1 = 0 ;
41046 char *kwnames[] = {
41047 (char *) "self",(char *) "item", NULL
41048 };
41049
41050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
41051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41052 if (SWIG_arg_fail(1)) SWIG_fail;
41053 arg2 = obj1;
41054 {
41055 PyThreadState* __tstate = wxPyBeginAllowThreads();
41056 result = (bool)wxSizer_IsShown(arg1,arg2);
41057
41058 wxPyEndAllowThreads(__tstate);
41059 if (PyErr_Occurred()) SWIG_fail;
41060 }
41061 {
41062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41063 }
41064 return resultobj;
41065 fail:
41066 return NULL;
41067 }
41068
41069
41070 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
41071 PyObject *resultobj;
41072 wxSizer *arg1 = (wxSizer *) 0 ;
41073 bool arg2 ;
41074 PyObject * obj0 = 0 ;
41075 PyObject * obj1 = 0 ;
41076 char *kwnames[] = {
41077 (char *) "self",(char *) "show", NULL
41078 };
41079
41080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
41081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
41082 if (SWIG_arg_fail(1)) SWIG_fail;
41083 {
41084 arg2 = (bool)(SWIG_As_bool(obj1));
41085 if (SWIG_arg_fail(2)) SWIG_fail;
41086 }
41087 {
41088 PyThreadState* __tstate = wxPyBeginAllowThreads();
41089 (arg1)->ShowItems(arg2);
41090
41091 wxPyEndAllowThreads(__tstate);
41092 if (PyErr_Occurred()) SWIG_fail;
41093 }
41094 Py_INCREF(Py_None); resultobj = Py_None;
41095 return resultobj;
41096 fail:
41097 return NULL;
41098 }
41099
41100
41101 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
41102 PyObject *obj;
41103 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41104 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
41105 Py_INCREF(obj);
41106 return Py_BuildValue((char *)"");
41107 }
41108 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
41109 PyObject *resultobj;
41110 wxPySizer *result;
41111 char *kwnames[] = {
41112 NULL
41113 };
41114
41115 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
41116 {
41117 PyThreadState* __tstate = wxPyBeginAllowThreads();
41118 result = (wxPySizer *)new wxPySizer();
41119
41120 wxPyEndAllowThreads(__tstate);
41121 if (PyErr_Occurred()) SWIG_fail;
41122 }
41123 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
41124 return resultobj;
41125 fail:
41126 return NULL;
41127 }
41128
41129
41130 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
41131 PyObject *resultobj;
41132 wxPySizer *arg1 = (wxPySizer *) 0 ;
41133 PyObject *arg2 = (PyObject *) 0 ;
41134 PyObject *arg3 = (PyObject *) 0 ;
41135 PyObject * obj0 = 0 ;
41136 PyObject * obj1 = 0 ;
41137 PyObject * obj2 = 0 ;
41138 char *kwnames[] = {
41139 (char *) "self",(char *) "self",(char *) "_class", NULL
41140 };
41141
41142 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
41143 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
41144 if (SWIG_arg_fail(1)) SWIG_fail;
41145 arg2 = obj1;
41146 arg3 = obj2;
41147 {
41148 PyThreadState* __tstate = wxPyBeginAllowThreads();
41149 (arg1)->_setCallbackInfo(arg2,arg3);
41150
41151 wxPyEndAllowThreads(__tstate);
41152 if (PyErr_Occurred()) SWIG_fail;
41153 }
41154 Py_INCREF(Py_None); resultobj = Py_None;
41155 return resultobj;
41156 fail:
41157 return NULL;
41158 }
41159
41160
41161 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
41162 PyObject *obj;
41163 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41164 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
41165 Py_INCREF(obj);
41166 return Py_BuildValue((char *)"");
41167 }
41168 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41169 PyObject *resultobj;
41170 int arg1 = (int) wxHORIZONTAL ;
41171 wxBoxSizer *result;
41172 PyObject * obj0 = 0 ;
41173 char *kwnames[] = {
41174 (char *) "orient", NULL
41175 };
41176
41177 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
41178 if (obj0) {
41179 {
41180 arg1 = (int)(SWIG_As_int(obj0));
41181 if (SWIG_arg_fail(1)) SWIG_fail;
41182 }
41183 }
41184 {
41185 PyThreadState* __tstate = wxPyBeginAllowThreads();
41186 result = (wxBoxSizer *)new wxBoxSizer(arg1);
41187
41188 wxPyEndAllowThreads(__tstate);
41189 if (PyErr_Occurred()) SWIG_fail;
41190 }
41191 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
41192 return resultobj;
41193 fail:
41194 return NULL;
41195 }
41196
41197
41198 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41199 PyObject *resultobj;
41200 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41201 int result;
41202 PyObject * obj0 = 0 ;
41203 char *kwnames[] = {
41204 (char *) "self", NULL
41205 };
41206
41207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
41208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41209 if (SWIG_arg_fail(1)) SWIG_fail;
41210 {
41211 PyThreadState* __tstate = wxPyBeginAllowThreads();
41212 result = (int)(arg1)->GetOrientation();
41213
41214 wxPyEndAllowThreads(__tstate);
41215 if (PyErr_Occurred()) SWIG_fail;
41216 }
41217 {
41218 resultobj = SWIG_From_int((int)(result));
41219 }
41220 return resultobj;
41221 fail:
41222 return NULL;
41223 }
41224
41225
41226 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
41227 PyObject *resultobj;
41228 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
41229 int arg2 ;
41230 PyObject * obj0 = 0 ;
41231 PyObject * obj1 = 0 ;
41232 char *kwnames[] = {
41233 (char *) "self",(char *) "orient", NULL
41234 };
41235
41236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
41237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41238 if (SWIG_arg_fail(1)) SWIG_fail;
41239 {
41240 arg2 = (int)(SWIG_As_int(obj1));
41241 if (SWIG_arg_fail(2)) SWIG_fail;
41242 }
41243 {
41244 PyThreadState* __tstate = wxPyBeginAllowThreads();
41245 (arg1)->SetOrientation(arg2);
41246
41247 wxPyEndAllowThreads(__tstate);
41248 if (PyErr_Occurred()) SWIG_fail;
41249 }
41250 Py_INCREF(Py_None); resultobj = Py_None;
41251 return resultobj;
41252 fail:
41253 return NULL;
41254 }
41255
41256
41257 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
41258 PyObject *obj;
41259 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41260 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
41261 Py_INCREF(obj);
41262 return Py_BuildValue((char *)"");
41263 }
41264 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41265 PyObject *resultobj;
41266 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
41267 int arg2 = (int) wxHORIZONTAL ;
41268 wxStaticBoxSizer *result;
41269 PyObject * obj0 = 0 ;
41270 PyObject * obj1 = 0 ;
41271 char *kwnames[] = {
41272 (char *) "box",(char *) "orient", NULL
41273 };
41274
41275 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
41276 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
41277 if (SWIG_arg_fail(1)) SWIG_fail;
41278 if (obj1) {
41279 {
41280 arg2 = (int)(SWIG_As_int(obj1));
41281 if (SWIG_arg_fail(2)) SWIG_fail;
41282 }
41283 }
41284 {
41285 PyThreadState* __tstate = wxPyBeginAllowThreads();
41286 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
41287
41288 wxPyEndAllowThreads(__tstate);
41289 if (PyErr_Occurred()) SWIG_fail;
41290 }
41291 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
41292 return resultobj;
41293 fail:
41294 return NULL;
41295 }
41296
41297
41298 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
41299 PyObject *resultobj;
41300 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
41301 wxStaticBox *result;
41302 PyObject * obj0 = 0 ;
41303 char *kwnames[] = {
41304 (char *) "self", NULL
41305 };
41306
41307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
41308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
41309 if (SWIG_arg_fail(1)) SWIG_fail;
41310 {
41311 PyThreadState* __tstate = wxPyBeginAllowThreads();
41312 result = (wxStaticBox *)(arg1)->GetStaticBox();
41313
41314 wxPyEndAllowThreads(__tstate);
41315 if (PyErr_Occurred()) SWIG_fail;
41316 }
41317 {
41318 resultobj = wxPyMake_wxObject(result, 0);
41319 }
41320 return resultobj;
41321 fail:
41322 return NULL;
41323 }
41324
41325
41326 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
41327 PyObject *obj;
41328 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41329 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
41330 Py_INCREF(obj);
41331 return Py_BuildValue((char *)"");
41332 }
41333 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41334 PyObject *resultobj;
41335 int arg1 = (int) 1 ;
41336 int arg2 = (int) 0 ;
41337 int arg3 = (int) 0 ;
41338 int arg4 = (int) 0 ;
41339 wxGridSizer *result;
41340 PyObject * obj0 = 0 ;
41341 PyObject * obj1 = 0 ;
41342 PyObject * obj2 = 0 ;
41343 PyObject * obj3 = 0 ;
41344 char *kwnames[] = {
41345 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41346 };
41347
41348 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41349 if (obj0) {
41350 {
41351 arg1 = (int)(SWIG_As_int(obj0));
41352 if (SWIG_arg_fail(1)) SWIG_fail;
41353 }
41354 }
41355 if (obj1) {
41356 {
41357 arg2 = (int)(SWIG_As_int(obj1));
41358 if (SWIG_arg_fail(2)) SWIG_fail;
41359 }
41360 }
41361 if (obj2) {
41362 {
41363 arg3 = (int)(SWIG_As_int(obj2));
41364 if (SWIG_arg_fail(3)) SWIG_fail;
41365 }
41366 }
41367 if (obj3) {
41368 {
41369 arg4 = (int)(SWIG_As_int(obj3));
41370 if (SWIG_arg_fail(4)) SWIG_fail;
41371 }
41372 }
41373 {
41374 PyThreadState* __tstate = wxPyBeginAllowThreads();
41375 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
41376
41377 wxPyEndAllowThreads(__tstate);
41378 if (PyErr_Occurred()) SWIG_fail;
41379 }
41380 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
41381 return resultobj;
41382 fail:
41383 return NULL;
41384 }
41385
41386
41387 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41388 PyObject *resultobj;
41389 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41390 int arg2 ;
41391 PyObject * obj0 = 0 ;
41392 PyObject * obj1 = 0 ;
41393 char *kwnames[] = {
41394 (char *) "self",(char *) "cols", NULL
41395 };
41396
41397 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
41398 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41399 if (SWIG_arg_fail(1)) SWIG_fail;
41400 {
41401 arg2 = (int)(SWIG_As_int(obj1));
41402 if (SWIG_arg_fail(2)) SWIG_fail;
41403 }
41404 {
41405 PyThreadState* __tstate = wxPyBeginAllowThreads();
41406 (arg1)->SetCols(arg2);
41407
41408 wxPyEndAllowThreads(__tstate);
41409 if (PyErr_Occurred()) SWIG_fail;
41410 }
41411 Py_INCREF(Py_None); resultobj = Py_None;
41412 return resultobj;
41413 fail:
41414 return NULL;
41415 }
41416
41417
41418 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41419 PyObject *resultobj;
41420 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41421 int arg2 ;
41422 PyObject * obj0 = 0 ;
41423 PyObject * obj1 = 0 ;
41424 char *kwnames[] = {
41425 (char *) "self",(char *) "rows", NULL
41426 };
41427
41428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
41429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41430 if (SWIG_arg_fail(1)) SWIG_fail;
41431 {
41432 arg2 = (int)(SWIG_As_int(obj1));
41433 if (SWIG_arg_fail(2)) SWIG_fail;
41434 }
41435 {
41436 PyThreadState* __tstate = wxPyBeginAllowThreads();
41437 (arg1)->SetRows(arg2);
41438
41439 wxPyEndAllowThreads(__tstate);
41440 if (PyErr_Occurred()) SWIG_fail;
41441 }
41442 Py_INCREF(Py_None); resultobj = Py_None;
41443 return resultobj;
41444 fail:
41445 return NULL;
41446 }
41447
41448
41449 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41450 PyObject *resultobj;
41451 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41452 int arg2 ;
41453 PyObject * obj0 = 0 ;
41454 PyObject * obj1 = 0 ;
41455 char *kwnames[] = {
41456 (char *) "self",(char *) "gap", NULL
41457 };
41458
41459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
41460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41461 if (SWIG_arg_fail(1)) SWIG_fail;
41462 {
41463 arg2 = (int)(SWIG_As_int(obj1));
41464 if (SWIG_arg_fail(2)) SWIG_fail;
41465 }
41466 {
41467 PyThreadState* __tstate = wxPyBeginAllowThreads();
41468 (arg1)->SetVGap(arg2);
41469
41470 wxPyEndAllowThreads(__tstate);
41471 if (PyErr_Occurred()) SWIG_fail;
41472 }
41473 Py_INCREF(Py_None); resultobj = Py_None;
41474 return resultobj;
41475 fail:
41476 return NULL;
41477 }
41478
41479
41480 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41481 PyObject *resultobj;
41482 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41483 int arg2 ;
41484 PyObject * obj0 = 0 ;
41485 PyObject * obj1 = 0 ;
41486 char *kwnames[] = {
41487 (char *) "self",(char *) "gap", NULL
41488 };
41489
41490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
41491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41492 if (SWIG_arg_fail(1)) SWIG_fail;
41493 {
41494 arg2 = (int)(SWIG_As_int(obj1));
41495 if (SWIG_arg_fail(2)) SWIG_fail;
41496 }
41497 {
41498 PyThreadState* __tstate = wxPyBeginAllowThreads();
41499 (arg1)->SetHGap(arg2);
41500
41501 wxPyEndAllowThreads(__tstate);
41502 if (PyErr_Occurred()) SWIG_fail;
41503 }
41504 Py_INCREF(Py_None); resultobj = Py_None;
41505 return resultobj;
41506 fail:
41507 return NULL;
41508 }
41509
41510
41511 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
41512 PyObject *resultobj;
41513 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41514 int result;
41515 PyObject * obj0 = 0 ;
41516 char *kwnames[] = {
41517 (char *) "self", NULL
41518 };
41519
41520 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
41521 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41522 if (SWIG_arg_fail(1)) SWIG_fail;
41523 {
41524 PyThreadState* __tstate = wxPyBeginAllowThreads();
41525 result = (int)(arg1)->GetCols();
41526
41527 wxPyEndAllowThreads(__tstate);
41528 if (PyErr_Occurred()) SWIG_fail;
41529 }
41530 {
41531 resultobj = SWIG_From_int((int)(result));
41532 }
41533 return resultobj;
41534 fail:
41535 return NULL;
41536 }
41537
41538
41539 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
41540 PyObject *resultobj;
41541 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41542 int result;
41543 PyObject * obj0 = 0 ;
41544 char *kwnames[] = {
41545 (char *) "self", NULL
41546 };
41547
41548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
41549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41550 if (SWIG_arg_fail(1)) SWIG_fail;
41551 {
41552 PyThreadState* __tstate = wxPyBeginAllowThreads();
41553 result = (int)(arg1)->GetRows();
41554
41555 wxPyEndAllowThreads(__tstate);
41556 if (PyErr_Occurred()) SWIG_fail;
41557 }
41558 {
41559 resultobj = SWIG_From_int((int)(result));
41560 }
41561 return resultobj;
41562 fail:
41563 return NULL;
41564 }
41565
41566
41567 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
41568 PyObject *resultobj;
41569 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41570 int result;
41571 PyObject * obj0 = 0 ;
41572 char *kwnames[] = {
41573 (char *) "self", NULL
41574 };
41575
41576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
41577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41578 if (SWIG_arg_fail(1)) SWIG_fail;
41579 {
41580 PyThreadState* __tstate = wxPyBeginAllowThreads();
41581 result = (int)(arg1)->GetVGap();
41582
41583 wxPyEndAllowThreads(__tstate);
41584 if (PyErr_Occurred()) SWIG_fail;
41585 }
41586 {
41587 resultobj = SWIG_From_int((int)(result));
41588 }
41589 return resultobj;
41590 fail:
41591 return NULL;
41592 }
41593
41594
41595 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
41596 PyObject *resultobj;
41597 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
41598 int result;
41599 PyObject * obj0 = 0 ;
41600 char *kwnames[] = {
41601 (char *) "self", NULL
41602 };
41603
41604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
41605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
41606 if (SWIG_arg_fail(1)) SWIG_fail;
41607 {
41608 PyThreadState* __tstate = wxPyBeginAllowThreads();
41609 result = (int)(arg1)->GetHGap();
41610
41611 wxPyEndAllowThreads(__tstate);
41612 if (PyErr_Occurred()) SWIG_fail;
41613 }
41614 {
41615 resultobj = SWIG_From_int((int)(result));
41616 }
41617 return resultobj;
41618 fail:
41619 return NULL;
41620 }
41621
41622
41623 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41624 PyObject *obj;
41625 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41626 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41627 Py_INCREF(obj);
41628 return Py_BuildValue((char *)"");
41629 }
41630 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41631 PyObject *resultobj;
41632 int arg1 = (int) 1 ;
41633 int arg2 = (int) 0 ;
41634 int arg3 = (int) 0 ;
41635 int arg4 = (int) 0 ;
41636 wxFlexGridSizer *result;
41637 PyObject * obj0 = 0 ;
41638 PyObject * obj1 = 0 ;
41639 PyObject * obj2 = 0 ;
41640 PyObject * obj3 = 0 ;
41641 char *kwnames[] = {
41642 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41643 };
41644
41645 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41646 if (obj0) {
41647 {
41648 arg1 = (int)(SWIG_As_int(obj0));
41649 if (SWIG_arg_fail(1)) SWIG_fail;
41650 }
41651 }
41652 if (obj1) {
41653 {
41654 arg2 = (int)(SWIG_As_int(obj1));
41655 if (SWIG_arg_fail(2)) SWIG_fail;
41656 }
41657 }
41658 if (obj2) {
41659 {
41660 arg3 = (int)(SWIG_As_int(obj2));
41661 if (SWIG_arg_fail(3)) SWIG_fail;
41662 }
41663 }
41664 if (obj3) {
41665 {
41666 arg4 = (int)(SWIG_As_int(obj3));
41667 if (SWIG_arg_fail(4)) SWIG_fail;
41668 }
41669 }
41670 {
41671 PyThreadState* __tstate = wxPyBeginAllowThreads();
41672 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41673
41674 wxPyEndAllowThreads(__tstate);
41675 if (PyErr_Occurred()) SWIG_fail;
41676 }
41677 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41678 return resultobj;
41679 fail:
41680 return NULL;
41681 }
41682
41683
41684 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41685 PyObject *resultobj;
41686 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41687 size_t arg2 ;
41688 int arg3 = (int) 0 ;
41689 PyObject * obj0 = 0 ;
41690 PyObject * obj1 = 0 ;
41691 PyObject * obj2 = 0 ;
41692 char *kwnames[] = {
41693 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41694 };
41695
41696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41698 if (SWIG_arg_fail(1)) SWIG_fail;
41699 {
41700 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41701 if (SWIG_arg_fail(2)) SWIG_fail;
41702 }
41703 if (obj2) {
41704 {
41705 arg3 = (int)(SWIG_As_int(obj2));
41706 if (SWIG_arg_fail(3)) SWIG_fail;
41707 }
41708 }
41709 {
41710 PyThreadState* __tstate = wxPyBeginAllowThreads();
41711 (arg1)->AddGrowableRow(arg2,arg3);
41712
41713 wxPyEndAllowThreads(__tstate);
41714 if (PyErr_Occurred()) SWIG_fail;
41715 }
41716 Py_INCREF(Py_None); resultobj = Py_None;
41717 return resultobj;
41718 fail:
41719 return NULL;
41720 }
41721
41722
41723 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41724 PyObject *resultobj;
41725 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41726 size_t arg2 ;
41727 PyObject * obj0 = 0 ;
41728 PyObject * obj1 = 0 ;
41729 char *kwnames[] = {
41730 (char *) "self",(char *) "idx", NULL
41731 };
41732
41733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41735 if (SWIG_arg_fail(1)) SWIG_fail;
41736 {
41737 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41738 if (SWIG_arg_fail(2)) SWIG_fail;
41739 }
41740 {
41741 PyThreadState* __tstate = wxPyBeginAllowThreads();
41742 (arg1)->RemoveGrowableRow(arg2);
41743
41744 wxPyEndAllowThreads(__tstate);
41745 if (PyErr_Occurred()) SWIG_fail;
41746 }
41747 Py_INCREF(Py_None); resultobj = Py_None;
41748 return resultobj;
41749 fail:
41750 return NULL;
41751 }
41752
41753
41754 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41755 PyObject *resultobj;
41756 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41757 size_t arg2 ;
41758 int arg3 = (int) 0 ;
41759 PyObject * obj0 = 0 ;
41760 PyObject * obj1 = 0 ;
41761 PyObject * obj2 = 0 ;
41762 char *kwnames[] = {
41763 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41764 };
41765
41766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41768 if (SWIG_arg_fail(1)) SWIG_fail;
41769 {
41770 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41771 if (SWIG_arg_fail(2)) SWIG_fail;
41772 }
41773 if (obj2) {
41774 {
41775 arg3 = (int)(SWIG_As_int(obj2));
41776 if (SWIG_arg_fail(3)) SWIG_fail;
41777 }
41778 }
41779 {
41780 PyThreadState* __tstate = wxPyBeginAllowThreads();
41781 (arg1)->AddGrowableCol(arg2,arg3);
41782
41783 wxPyEndAllowThreads(__tstate);
41784 if (PyErr_Occurred()) SWIG_fail;
41785 }
41786 Py_INCREF(Py_None); resultobj = Py_None;
41787 return resultobj;
41788 fail:
41789 return NULL;
41790 }
41791
41792
41793 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41794 PyObject *resultobj;
41795 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41796 size_t arg2 ;
41797 PyObject * obj0 = 0 ;
41798 PyObject * obj1 = 0 ;
41799 char *kwnames[] = {
41800 (char *) "self",(char *) "idx", NULL
41801 };
41802
41803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41805 if (SWIG_arg_fail(1)) SWIG_fail;
41806 {
41807 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41808 if (SWIG_arg_fail(2)) SWIG_fail;
41809 }
41810 {
41811 PyThreadState* __tstate = wxPyBeginAllowThreads();
41812 (arg1)->RemoveGrowableCol(arg2);
41813
41814 wxPyEndAllowThreads(__tstate);
41815 if (PyErr_Occurred()) SWIG_fail;
41816 }
41817 Py_INCREF(Py_None); resultobj = Py_None;
41818 return resultobj;
41819 fail:
41820 return NULL;
41821 }
41822
41823
41824 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41825 PyObject *resultobj;
41826 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41827 int arg2 ;
41828 PyObject * obj0 = 0 ;
41829 PyObject * obj1 = 0 ;
41830 char *kwnames[] = {
41831 (char *) "self",(char *) "direction", NULL
41832 };
41833
41834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41836 if (SWIG_arg_fail(1)) SWIG_fail;
41837 {
41838 arg2 = (int)(SWIG_As_int(obj1));
41839 if (SWIG_arg_fail(2)) SWIG_fail;
41840 }
41841 {
41842 PyThreadState* __tstate = wxPyBeginAllowThreads();
41843 (arg1)->SetFlexibleDirection(arg2);
41844
41845 wxPyEndAllowThreads(__tstate);
41846 if (PyErr_Occurred()) SWIG_fail;
41847 }
41848 Py_INCREF(Py_None); resultobj = Py_None;
41849 return resultobj;
41850 fail:
41851 return NULL;
41852 }
41853
41854
41855 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41856 PyObject *resultobj;
41857 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41858 int result;
41859 PyObject * obj0 = 0 ;
41860 char *kwnames[] = {
41861 (char *) "self", NULL
41862 };
41863
41864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41866 if (SWIG_arg_fail(1)) SWIG_fail;
41867 {
41868 PyThreadState* __tstate = wxPyBeginAllowThreads();
41869 result = (int)(arg1)->GetFlexibleDirection();
41870
41871 wxPyEndAllowThreads(__tstate);
41872 if (PyErr_Occurred()) SWIG_fail;
41873 }
41874 {
41875 resultobj = SWIG_From_int((int)(result));
41876 }
41877 return resultobj;
41878 fail:
41879 return NULL;
41880 }
41881
41882
41883 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41884 PyObject *resultobj;
41885 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41886 wxFlexSizerGrowMode arg2 ;
41887 PyObject * obj0 = 0 ;
41888 PyObject * obj1 = 0 ;
41889 char *kwnames[] = {
41890 (char *) "self",(char *) "mode", NULL
41891 };
41892
41893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41895 if (SWIG_arg_fail(1)) SWIG_fail;
41896 {
41897 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41898 if (SWIG_arg_fail(2)) SWIG_fail;
41899 }
41900 {
41901 PyThreadState* __tstate = wxPyBeginAllowThreads();
41902 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41903
41904 wxPyEndAllowThreads(__tstate);
41905 if (PyErr_Occurred()) SWIG_fail;
41906 }
41907 Py_INCREF(Py_None); resultobj = Py_None;
41908 return resultobj;
41909 fail:
41910 return NULL;
41911 }
41912
41913
41914 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41915 PyObject *resultobj;
41916 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41917 wxFlexSizerGrowMode result;
41918 PyObject * obj0 = 0 ;
41919 char *kwnames[] = {
41920 (char *) "self", NULL
41921 };
41922
41923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41925 if (SWIG_arg_fail(1)) SWIG_fail;
41926 {
41927 PyThreadState* __tstate = wxPyBeginAllowThreads();
41928 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41929
41930 wxPyEndAllowThreads(__tstate);
41931 if (PyErr_Occurred()) SWIG_fail;
41932 }
41933 resultobj = SWIG_From_int((result));
41934 return resultobj;
41935 fail:
41936 return NULL;
41937 }
41938
41939
41940 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41941 PyObject *resultobj;
41942 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41943 wxArrayInt *result;
41944 PyObject * obj0 = 0 ;
41945 char *kwnames[] = {
41946 (char *) "self", NULL
41947 };
41948
41949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41951 if (SWIG_arg_fail(1)) SWIG_fail;
41952 {
41953 PyThreadState* __tstate = wxPyBeginAllowThreads();
41954 {
41955 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41956 result = (wxArrayInt *) &_result_ref;
41957 }
41958
41959 wxPyEndAllowThreads(__tstate);
41960 if (PyErr_Occurred()) SWIG_fail;
41961 }
41962 {
41963 resultobj = PyList_New(0);
41964 size_t idx;
41965 for (idx = 0; idx < result->GetCount(); idx += 1) {
41966 PyObject* val = PyInt_FromLong( result->Item(idx) );
41967 PyList_Append(resultobj, val);
41968 Py_DECREF(val);
41969 }
41970 }
41971 return resultobj;
41972 fail:
41973 return NULL;
41974 }
41975
41976
41977 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41978 PyObject *resultobj;
41979 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41980 wxArrayInt *result;
41981 PyObject * obj0 = 0 ;
41982 char *kwnames[] = {
41983 (char *) "self", NULL
41984 };
41985
41986 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41987 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41988 if (SWIG_arg_fail(1)) SWIG_fail;
41989 {
41990 PyThreadState* __tstate = wxPyBeginAllowThreads();
41991 {
41992 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41993 result = (wxArrayInt *) &_result_ref;
41994 }
41995
41996 wxPyEndAllowThreads(__tstate);
41997 if (PyErr_Occurred()) SWIG_fail;
41998 }
41999 {
42000 resultobj = PyList_New(0);
42001 size_t idx;
42002 for (idx = 0; idx < result->GetCount(); idx += 1) {
42003 PyObject* val = PyInt_FromLong( result->Item(idx) );
42004 PyList_Append(resultobj, val);
42005 Py_DECREF(val);
42006 }
42007 }
42008 return resultobj;
42009 fail:
42010 return NULL;
42011 }
42012
42013
42014 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
42015 PyObject *obj;
42016 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42017 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
42018 Py_INCREF(obj);
42019 return Py_BuildValue((char *)"");
42020 }
42021 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42022 PyObject *resultobj;
42023 wxStdDialogButtonSizer *result;
42024 char *kwnames[] = {
42025 NULL
42026 };
42027
42028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
42029 {
42030 PyThreadState* __tstate = wxPyBeginAllowThreads();
42031 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
42032
42033 wxPyEndAllowThreads(__tstate);
42034 if (PyErr_Occurred()) SWIG_fail;
42035 }
42036 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
42037 return resultobj;
42038 fail:
42039 return NULL;
42040 }
42041
42042
42043 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
42044 PyObject *resultobj;
42045 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42046 wxButton *arg2 = (wxButton *) 0 ;
42047 PyObject * obj0 = 0 ;
42048 PyObject * obj1 = 0 ;
42049 char *kwnames[] = {
42050 (char *) "self",(char *) "button", NULL
42051 };
42052
42053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
42054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42055 if (SWIG_arg_fail(1)) SWIG_fail;
42056 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42057 if (SWIG_arg_fail(2)) SWIG_fail;
42058 {
42059 PyThreadState* __tstate = wxPyBeginAllowThreads();
42060 (arg1)->AddButton(arg2);
42061
42062 wxPyEndAllowThreads(__tstate);
42063 if (PyErr_Occurred()) SWIG_fail;
42064 }
42065 Py_INCREF(Py_None); resultobj = Py_None;
42066 return resultobj;
42067 fail:
42068 return NULL;
42069 }
42070
42071
42072 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
42073 PyObject *resultobj;
42074 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42075 PyObject * obj0 = 0 ;
42076 char *kwnames[] = {
42077 (char *) "self", NULL
42078 };
42079
42080 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
42081 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42082 if (SWIG_arg_fail(1)) SWIG_fail;
42083 {
42084 PyThreadState* __tstate = wxPyBeginAllowThreads();
42085 (arg1)->Realize();
42086
42087 wxPyEndAllowThreads(__tstate);
42088 if (PyErr_Occurred()) SWIG_fail;
42089 }
42090 Py_INCREF(Py_None); resultobj = Py_None;
42091 return resultobj;
42092 fail:
42093 return NULL;
42094 }
42095
42096
42097 static PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42098 PyObject *resultobj;
42099 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42100 wxButton *arg2 = (wxButton *) 0 ;
42101 PyObject * obj0 = 0 ;
42102 PyObject * obj1 = 0 ;
42103 char *kwnames[] = {
42104 (char *) "self",(char *) "button", NULL
42105 };
42106
42107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
42108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42109 if (SWIG_arg_fail(1)) SWIG_fail;
42110 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42111 if (SWIG_arg_fail(2)) SWIG_fail;
42112 {
42113 PyThreadState* __tstate = wxPyBeginAllowThreads();
42114 (arg1)->SetAffirmativeButton(arg2);
42115
42116 wxPyEndAllowThreads(__tstate);
42117 if (PyErr_Occurred()) SWIG_fail;
42118 }
42119 Py_INCREF(Py_None); resultobj = Py_None;
42120 return resultobj;
42121 fail:
42122 return NULL;
42123 }
42124
42125
42126 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42127 PyObject *resultobj;
42128 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42129 wxButton *arg2 = (wxButton *) 0 ;
42130 PyObject * obj0 = 0 ;
42131 PyObject * obj1 = 0 ;
42132 char *kwnames[] = {
42133 (char *) "self",(char *) "button", NULL
42134 };
42135
42136 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
42137 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42138 if (SWIG_arg_fail(1)) SWIG_fail;
42139 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42140 if (SWIG_arg_fail(2)) SWIG_fail;
42141 {
42142 PyThreadState* __tstate = wxPyBeginAllowThreads();
42143 (arg1)->SetNegativeButton(arg2);
42144
42145 wxPyEndAllowThreads(__tstate);
42146 if (PyErr_Occurred()) SWIG_fail;
42147 }
42148 Py_INCREF(Py_None); resultobj = Py_None;
42149 return resultobj;
42150 fail:
42151 return NULL;
42152 }
42153
42154
42155 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42156 PyObject *resultobj;
42157 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42158 wxButton *arg2 = (wxButton *) 0 ;
42159 PyObject * obj0 = 0 ;
42160 PyObject * obj1 = 0 ;
42161 char *kwnames[] = {
42162 (char *) "self",(char *) "button", NULL
42163 };
42164
42165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
42166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42167 if (SWIG_arg_fail(1)) SWIG_fail;
42168 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
42169 if (SWIG_arg_fail(2)) SWIG_fail;
42170 {
42171 PyThreadState* __tstate = wxPyBeginAllowThreads();
42172 (arg1)->SetCancelButton(arg2);
42173
42174 wxPyEndAllowThreads(__tstate);
42175 if (PyErr_Occurred()) SWIG_fail;
42176 }
42177 Py_INCREF(Py_None); resultobj = Py_None;
42178 return resultobj;
42179 fail:
42180 return NULL;
42181 }
42182
42183
42184 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42185 PyObject *resultobj;
42186 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42187 wxButton *result;
42188 PyObject * obj0 = 0 ;
42189 char *kwnames[] = {
42190 (char *) "self", NULL
42191 };
42192
42193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
42194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42195 if (SWIG_arg_fail(1)) SWIG_fail;
42196 {
42197 PyThreadState* __tstate = wxPyBeginAllowThreads();
42198 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
42199
42200 wxPyEndAllowThreads(__tstate);
42201 if (PyErr_Occurred()) SWIG_fail;
42202 }
42203 {
42204 resultobj = wxPyMake_wxObject(result, 0);
42205 }
42206 return resultobj;
42207 fail:
42208 return NULL;
42209 }
42210
42211
42212 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
42213 PyObject *resultobj;
42214 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42215 wxButton *result;
42216 PyObject * obj0 = 0 ;
42217 char *kwnames[] = {
42218 (char *) "self", NULL
42219 };
42220
42221 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
42222 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42223 if (SWIG_arg_fail(1)) SWIG_fail;
42224 {
42225 PyThreadState* __tstate = wxPyBeginAllowThreads();
42226 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
42227
42228 wxPyEndAllowThreads(__tstate);
42229 if (PyErr_Occurred()) SWIG_fail;
42230 }
42231 {
42232 resultobj = wxPyMake_wxObject(result, 0);
42233 }
42234 return resultobj;
42235 fail:
42236 return NULL;
42237 }
42238
42239
42240 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
42241 PyObject *resultobj;
42242 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42243 wxButton *result;
42244 PyObject * obj0 = 0 ;
42245 char *kwnames[] = {
42246 (char *) "self", NULL
42247 };
42248
42249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
42250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42251 if (SWIG_arg_fail(1)) SWIG_fail;
42252 {
42253 PyThreadState* __tstate = wxPyBeginAllowThreads();
42254 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
42255
42256 wxPyEndAllowThreads(__tstate);
42257 if (PyErr_Occurred()) SWIG_fail;
42258 }
42259 {
42260 resultobj = wxPyMake_wxObject(result, 0);
42261 }
42262 return resultobj;
42263 fail:
42264 return NULL;
42265 }
42266
42267
42268 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
42269 PyObject *resultobj;
42270 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42271 wxButton *result;
42272 PyObject * obj0 = 0 ;
42273 char *kwnames[] = {
42274 (char *) "self", NULL
42275 };
42276
42277 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
42278 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42279 if (SWIG_arg_fail(1)) SWIG_fail;
42280 {
42281 PyThreadState* __tstate = wxPyBeginAllowThreads();
42282 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
42283
42284 wxPyEndAllowThreads(__tstate);
42285 if (PyErr_Occurred()) SWIG_fail;
42286 }
42287 {
42288 resultobj = wxPyMake_wxObject(result, 0);
42289 }
42290 return resultobj;
42291 fail:
42292 return NULL;
42293 }
42294
42295
42296 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
42297 PyObject *resultobj;
42298 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
42299 wxButton *result;
42300 PyObject * obj0 = 0 ;
42301 char *kwnames[] = {
42302 (char *) "self", NULL
42303 };
42304
42305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
42306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
42307 if (SWIG_arg_fail(1)) SWIG_fail;
42308 {
42309 PyThreadState* __tstate = wxPyBeginAllowThreads();
42310 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
42311
42312 wxPyEndAllowThreads(__tstate);
42313 if (PyErr_Occurred()) SWIG_fail;
42314 }
42315 {
42316 resultobj = wxPyMake_wxObject(result, 0);
42317 }
42318 return resultobj;
42319 fail:
42320 return NULL;
42321 }
42322
42323
42324 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
42325 PyObject *obj;
42326 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42327 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
42328 Py_INCREF(obj);
42329 return Py_BuildValue((char *)"");
42330 }
42331 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
42332 PyObject *resultobj;
42333 int arg1 = (int) 0 ;
42334 int arg2 = (int) 0 ;
42335 wxGBPosition *result;
42336 PyObject * obj0 = 0 ;
42337 PyObject * obj1 = 0 ;
42338 char *kwnames[] = {
42339 (char *) "row",(char *) "col", NULL
42340 };
42341
42342 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
42343 if (obj0) {
42344 {
42345 arg1 = (int)(SWIG_As_int(obj0));
42346 if (SWIG_arg_fail(1)) SWIG_fail;
42347 }
42348 }
42349 if (obj1) {
42350 {
42351 arg2 = (int)(SWIG_As_int(obj1));
42352 if (SWIG_arg_fail(2)) SWIG_fail;
42353 }
42354 }
42355 {
42356 PyThreadState* __tstate = wxPyBeginAllowThreads();
42357 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
42358
42359 wxPyEndAllowThreads(__tstate);
42360 if (PyErr_Occurred()) SWIG_fail;
42361 }
42362 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
42363 return resultobj;
42364 fail:
42365 return NULL;
42366 }
42367
42368
42369 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42370 PyObject *resultobj;
42371 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42372 int result;
42373 PyObject * obj0 = 0 ;
42374 char *kwnames[] = {
42375 (char *) "self", NULL
42376 };
42377
42378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
42379 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42380 if (SWIG_arg_fail(1)) SWIG_fail;
42381 {
42382 PyThreadState* __tstate = wxPyBeginAllowThreads();
42383 result = (int)((wxGBPosition const *)arg1)->GetRow();
42384
42385 wxPyEndAllowThreads(__tstate);
42386 if (PyErr_Occurred()) SWIG_fail;
42387 }
42388 {
42389 resultobj = SWIG_From_int((int)(result));
42390 }
42391 return resultobj;
42392 fail:
42393 return NULL;
42394 }
42395
42396
42397 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42398 PyObject *resultobj;
42399 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42400 int result;
42401 PyObject * obj0 = 0 ;
42402 char *kwnames[] = {
42403 (char *) "self", NULL
42404 };
42405
42406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
42407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42408 if (SWIG_arg_fail(1)) SWIG_fail;
42409 {
42410 PyThreadState* __tstate = wxPyBeginAllowThreads();
42411 result = (int)((wxGBPosition const *)arg1)->GetCol();
42412
42413 wxPyEndAllowThreads(__tstate);
42414 if (PyErr_Occurred()) SWIG_fail;
42415 }
42416 {
42417 resultobj = SWIG_From_int((int)(result));
42418 }
42419 return resultobj;
42420 fail:
42421 return NULL;
42422 }
42423
42424
42425 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
42426 PyObject *resultobj;
42427 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42428 int arg2 ;
42429 PyObject * obj0 = 0 ;
42430 PyObject * obj1 = 0 ;
42431 char *kwnames[] = {
42432 (char *) "self",(char *) "row", NULL
42433 };
42434
42435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
42436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42437 if (SWIG_arg_fail(1)) SWIG_fail;
42438 {
42439 arg2 = (int)(SWIG_As_int(obj1));
42440 if (SWIG_arg_fail(2)) SWIG_fail;
42441 }
42442 {
42443 PyThreadState* __tstate = wxPyBeginAllowThreads();
42444 (arg1)->SetRow(arg2);
42445
42446 wxPyEndAllowThreads(__tstate);
42447 if (PyErr_Occurred()) SWIG_fail;
42448 }
42449 Py_INCREF(Py_None); resultobj = Py_None;
42450 return resultobj;
42451 fail:
42452 return NULL;
42453 }
42454
42455
42456 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
42457 PyObject *resultobj;
42458 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42459 int arg2 ;
42460 PyObject * obj0 = 0 ;
42461 PyObject * obj1 = 0 ;
42462 char *kwnames[] = {
42463 (char *) "self",(char *) "col", NULL
42464 };
42465
42466 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
42467 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42468 if (SWIG_arg_fail(1)) SWIG_fail;
42469 {
42470 arg2 = (int)(SWIG_As_int(obj1));
42471 if (SWIG_arg_fail(2)) SWIG_fail;
42472 }
42473 {
42474 PyThreadState* __tstate = wxPyBeginAllowThreads();
42475 (arg1)->SetCol(arg2);
42476
42477 wxPyEndAllowThreads(__tstate);
42478 if (PyErr_Occurred()) SWIG_fail;
42479 }
42480 Py_INCREF(Py_None); resultobj = Py_None;
42481 return resultobj;
42482 fail:
42483 return NULL;
42484 }
42485
42486
42487 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42488 PyObject *resultobj;
42489 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42490 wxGBPosition *arg2 = 0 ;
42491 bool result;
42492 wxGBPosition temp2 ;
42493 PyObject * obj0 = 0 ;
42494 PyObject * obj1 = 0 ;
42495 char *kwnames[] = {
42496 (char *) "self",(char *) "other", NULL
42497 };
42498
42499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
42500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42501 if (SWIG_arg_fail(1)) SWIG_fail;
42502 {
42503 arg2 = &temp2;
42504 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42505 }
42506 {
42507 PyThreadState* __tstate = wxPyBeginAllowThreads();
42508 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
42509
42510 wxPyEndAllowThreads(__tstate);
42511 if (PyErr_Occurred()) SWIG_fail;
42512 }
42513 {
42514 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42515 }
42516 return resultobj;
42517 fail:
42518 return NULL;
42519 }
42520
42521
42522 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42523 PyObject *resultobj;
42524 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42525 wxGBPosition *arg2 = 0 ;
42526 bool result;
42527 wxGBPosition temp2 ;
42528 PyObject * obj0 = 0 ;
42529 PyObject * obj1 = 0 ;
42530 char *kwnames[] = {
42531 (char *) "self",(char *) "other", NULL
42532 };
42533
42534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
42535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42536 if (SWIG_arg_fail(1)) SWIG_fail;
42537 {
42538 arg2 = &temp2;
42539 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42540 }
42541 {
42542 PyThreadState* __tstate = wxPyBeginAllowThreads();
42543 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
42544
42545 wxPyEndAllowThreads(__tstate);
42546 if (PyErr_Occurred()) SWIG_fail;
42547 }
42548 {
42549 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42550 }
42551 return resultobj;
42552 fail:
42553 return NULL;
42554 }
42555
42556
42557 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42558 PyObject *resultobj;
42559 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42560 int arg2 = (int) 0 ;
42561 int arg3 = (int) 0 ;
42562 PyObject * obj0 = 0 ;
42563 PyObject * obj1 = 0 ;
42564 PyObject * obj2 = 0 ;
42565 char *kwnames[] = {
42566 (char *) "self",(char *) "row",(char *) "col", NULL
42567 };
42568
42569 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42570 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42571 if (SWIG_arg_fail(1)) SWIG_fail;
42572 if (obj1) {
42573 {
42574 arg2 = (int)(SWIG_As_int(obj1));
42575 if (SWIG_arg_fail(2)) SWIG_fail;
42576 }
42577 }
42578 if (obj2) {
42579 {
42580 arg3 = (int)(SWIG_As_int(obj2));
42581 if (SWIG_arg_fail(3)) SWIG_fail;
42582 }
42583 }
42584 {
42585 PyThreadState* __tstate = wxPyBeginAllowThreads();
42586 wxGBPosition_Set(arg1,arg2,arg3);
42587
42588 wxPyEndAllowThreads(__tstate);
42589 if (PyErr_Occurred()) SWIG_fail;
42590 }
42591 Py_INCREF(Py_None); resultobj = Py_None;
42592 return resultobj;
42593 fail:
42594 return NULL;
42595 }
42596
42597
42598 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42599 PyObject *resultobj;
42600 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
42601 PyObject *result;
42602 PyObject * obj0 = 0 ;
42603 char *kwnames[] = {
42604 (char *) "self", NULL
42605 };
42606
42607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
42608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
42609 if (SWIG_arg_fail(1)) SWIG_fail;
42610 {
42611 PyThreadState* __tstate = wxPyBeginAllowThreads();
42612 result = (PyObject *)wxGBPosition_Get(arg1);
42613
42614 wxPyEndAllowThreads(__tstate);
42615 if (PyErr_Occurred()) SWIG_fail;
42616 }
42617 resultobj = result;
42618 return resultobj;
42619 fail:
42620 return NULL;
42621 }
42622
42623
42624 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42625 PyObject *obj;
42626 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42627 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42628 Py_INCREF(obj);
42629 return Py_BuildValue((char *)"");
42630 }
42631 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42632 PyObject *resultobj;
42633 int arg1 = (int) 1 ;
42634 int arg2 = (int) 1 ;
42635 wxGBSpan *result;
42636 PyObject * obj0 = 0 ;
42637 PyObject * obj1 = 0 ;
42638 char *kwnames[] = {
42639 (char *) "rowspan",(char *) "colspan", NULL
42640 };
42641
42642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42643 if (obj0) {
42644 {
42645 arg1 = (int)(SWIG_As_int(obj0));
42646 if (SWIG_arg_fail(1)) SWIG_fail;
42647 }
42648 }
42649 if (obj1) {
42650 {
42651 arg2 = (int)(SWIG_As_int(obj1));
42652 if (SWIG_arg_fail(2)) SWIG_fail;
42653 }
42654 }
42655 {
42656 PyThreadState* __tstate = wxPyBeginAllowThreads();
42657 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42658
42659 wxPyEndAllowThreads(__tstate);
42660 if (PyErr_Occurred()) SWIG_fail;
42661 }
42662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42663 return resultobj;
42664 fail:
42665 return NULL;
42666 }
42667
42668
42669 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42670 PyObject *resultobj;
42671 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42672 int result;
42673 PyObject * obj0 = 0 ;
42674 char *kwnames[] = {
42675 (char *) "self", NULL
42676 };
42677
42678 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42679 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42680 if (SWIG_arg_fail(1)) SWIG_fail;
42681 {
42682 PyThreadState* __tstate = wxPyBeginAllowThreads();
42683 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42684
42685 wxPyEndAllowThreads(__tstate);
42686 if (PyErr_Occurred()) SWIG_fail;
42687 }
42688 {
42689 resultobj = SWIG_From_int((int)(result));
42690 }
42691 return resultobj;
42692 fail:
42693 return NULL;
42694 }
42695
42696
42697 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42698 PyObject *resultobj;
42699 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42700 int result;
42701 PyObject * obj0 = 0 ;
42702 char *kwnames[] = {
42703 (char *) "self", NULL
42704 };
42705
42706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42708 if (SWIG_arg_fail(1)) SWIG_fail;
42709 {
42710 PyThreadState* __tstate = wxPyBeginAllowThreads();
42711 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42712
42713 wxPyEndAllowThreads(__tstate);
42714 if (PyErr_Occurred()) SWIG_fail;
42715 }
42716 {
42717 resultobj = SWIG_From_int((int)(result));
42718 }
42719 return resultobj;
42720 fail:
42721 return NULL;
42722 }
42723
42724
42725 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42726 PyObject *resultobj;
42727 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42728 int arg2 ;
42729 PyObject * obj0 = 0 ;
42730 PyObject * obj1 = 0 ;
42731 char *kwnames[] = {
42732 (char *) "self",(char *) "rowspan", NULL
42733 };
42734
42735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42736 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42737 if (SWIG_arg_fail(1)) SWIG_fail;
42738 {
42739 arg2 = (int)(SWIG_As_int(obj1));
42740 if (SWIG_arg_fail(2)) SWIG_fail;
42741 }
42742 {
42743 PyThreadState* __tstate = wxPyBeginAllowThreads();
42744 (arg1)->SetRowspan(arg2);
42745
42746 wxPyEndAllowThreads(__tstate);
42747 if (PyErr_Occurred()) SWIG_fail;
42748 }
42749 Py_INCREF(Py_None); resultobj = Py_None;
42750 return resultobj;
42751 fail:
42752 return NULL;
42753 }
42754
42755
42756 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42757 PyObject *resultobj;
42758 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42759 int arg2 ;
42760 PyObject * obj0 = 0 ;
42761 PyObject * obj1 = 0 ;
42762 char *kwnames[] = {
42763 (char *) "self",(char *) "colspan", NULL
42764 };
42765
42766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42768 if (SWIG_arg_fail(1)) SWIG_fail;
42769 {
42770 arg2 = (int)(SWIG_As_int(obj1));
42771 if (SWIG_arg_fail(2)) SWIG_fail;
42772 }
42773 {
42774 PyThreadState* __tstate = wxPyBeginAllowThreads();
42775 (arg1)->SetColspan(arg2);
42776
42777 wxPyEndAllowThreads(__tstate);
42778 if (PyErr_Occurred()) SWIG_fail;
42779 }
42780 Py_INCREF(Py_None); resultobj = Py_None;
42781 return resultobj;
42782 fail:
42783 return NULL;
42784 }
42785
42786
42787 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42788 PyObject *resultobj;
42789 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42790 wxGBSpan *arg2 = 0 ;
42791 bool result;
42792 wxGBSpan temp2 ;
42793 PyObject * obj0 = 0 ;
42794 PyObject * obj1 = 0 ;
42795 char *kwnames[] = {
42796 (char *) "self",(char *) "other", NULL
42797 };
42798
42799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42801 if (SWIG_arg_fail(1)) SWIG_fail;
42802 {
42803 arg2 = &temp2;
42804 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42805 }
42806 {
42807 PyThreadState* __tstate = wxPyBeginAllowThreads();
42808 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42809
42810 wxPyEndAllowThreads(__tstate);
42811 if (PyErr_Occurred()) SWIG_fail;
42812 }
42813 {
42814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42815 }
42816 return resultobj;
42817 fail:
42818 return NULL;
42819 }
42820
42821
42822 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42823 PyObject *resultobj;
42824 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42825 wxGBSpan *arg2 = 0 ;
42826 bool result;
42827 wxGBSpan temp2 ;
42828 PyObject * obj0 = 0 ;
42829 PyObject * obj1 = 0 ;
42830 char *kwnames[] = {
42831 (char *) "self",(char *) "other", NULL
42832 };
42833
42834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42836 if (SWIG_arg_fail(1)) SWIG_fail;
42837 {
42838 arg2 = &temp2;
42839 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42840 }
42841 {
42842 PyThreadState* __tstate = wxPyBeginAllowThreads();
42843 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42844
42845 wxPyEndAllowThreads(__tstate);
42846 if (PyErr_Occurred()) SWIG_fail;
42847 }
42848 {
42849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42850 }
42851 return resultobj;
42852 fail:
42853 return NULL;
42854 }
42855
42856
42857 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42858 PyObject *resultobj;
42859 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42860 int arg2 = (int) 1 ;
42861 int arg3 = (int) 1 ;
42862 PyObject * obj0 = 0 ;
42863 PyObject * obj1 = 0 ;
42864 PyObject * obj2 = 0 ;
42865 char *kwnames[] = {
42866 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42867 };
42868
42869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42871 if (SWIG_arg_fail(1)) SWIG_fail;
42872 if (obj1) {
42873 {
42874 arg2 = (int)(SWIG_As_int(obj1));
42875 if (SWIG_arg_fail(2)) SWIG_fail;
42876 }
42877 }
42878 if (obj2) {
42879 {
42880 arg3 = (int)(SWIG_As_int(obj2));
42881 if (SWIG_arg_fail(3)) SWIG_fail;
42882 }
42883 }
42884 {
42885 PyThreadState* __tstate = wxPyBeginAllowThreads();
42886 wxGBSpan_Set(arg1,arg2,arg3);
42887
42888 wxPyEndAllowThreads(__tstate);
42889 if (PyErr_Occurred()) SWIG_fail;
42890 }
42891 Py_INCREF(Py_None); resultobj = Py_None;
42892 return resultobj;
42893 fail:
42894 return NULL;
42895 }
42896
42897
42898 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42899 PyObject *resultobj;
42900 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42901 PyObject *result;
42902 PyObject * obj0 = 0 ;
42903 char *kwnames[] = {
42904 (char *) "self", NULL
42905 };
42906
42907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42909 if (SWIG_arg_fail(1)) SWIG_fail;
42910 {
42911 PyThreadState* __tstate = wxPyBeginAllowThreads();
42912 result = (PyObject *)wxGBSpan_Get(arg1);
42913
42914 wxPyEndAllowThreads(__tstate);
42915 if (PyErr_Occurred()) SWIG_fail;
42916 }
42917 resultobj = result;
42918 return resultobj;
42919 fail:
42920 return NULL;
42921 }
42922
42923
42924 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42925 PyObject *obj;
42926 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42927 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42928 Py_INCREF(obj);
42929 return Py_BuildValue((char *)"");
42930 }
42931 static int _wrap_DefaultSpan_set(PyObject *) {
42932 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42933 return 1;
42934 }
42935
42936
42937 static PyObject *_wrap_DefaultSpan_get(void) {
42938 PyObject *pyobj;
42939
42940 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42941 return pyobj;
42942 }
42943
42944
42945 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42946 PyObject *resultobj;
42947 wxGBSizerItem *result;
42948 char *kwnames[] = {
42949 NULL
42950 };
42951
42952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42953 {
42954 PyThreadState* __tstate = wxPyBeginAllowThreads();
42955 result = (wxGBSizerItem *)new wxGBSizerItem();
42956
42957 wxPyEndAllowThreads(__tstate);
42958 if (PyErr_Occurred()) SWIG_fail;
42959 }
42960 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42961 return resultobj;
42962 fail:
42963 return NULL;
42964 }
42965
42966
42967 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42968 PyObject *resultobj;
42969 wxWindow *arg1 = (wxWindow *) 0 ;
42970 wxGBPosition *arg2 = 0 ;
42971 wxGBSpan *arg3 = 0 ;
42972 int arg4 ;
42973 int arg5 ;
42974 PyObject *arg6 = (PyObject *) NULL ;
42975 wxGBSizerItem *result;
42976 wxGBPosition temp2 ;
42977 wxGBSpan temp3 ;
42978 PyObject * obj0 = 0 ;
42979 PyObject * obj1 = 0 ;
42980 PyObject * obj2 = 0 ;
42981 PyObject * obj3 = 0 ;
42982 PyObject * obj4 = 0 ;
42983 PyObject * obj5 = 0 ;
42984 char *kwnames[] = {
42985 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42986 };
42987
42988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42990 if (SWIG_arg_fail(1)) SWIG_fail;
42991 {
42992 arg2 = &temp2;
42993 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42994 }
42995 {
42996 arg3 = &temp3;
42997 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42998 }
42999 {
43000 arg4 = (int)(SWIG_As_int(obj3));
43001 if (SWIG_arg_fail(4)) SWIG_fail;
43002 }
43003 {
43004 arg5 = (int)(SWIG_As_int(obj4));
43005 if (SWIG_arg_fail(5)) SWIG_fail;
43006 }
43007 if (obj5) {
43008 arg6 = obj5;
43009 }
43010 {
43011 PyThreadState* __tstate = wxPyBeginAllowThreads();
43012 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43013
43014 wxPyEndAllowThreads(__tstate);
43015 if (PyErr_Occurred()) SWIG_fail;
43016 }
43017 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43018 return resultobj;
43019 fail:
43020 return NULL;
43021 }
43022
43023
43024 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43025 PyObject *resultobj;
43026 wxSizer *arg1 = (wxSizer *) 0 ;
43027 wxGBPosition *arg2 = 0 ;
43028 wxGBSpan *arg3 = 0 ;
43029 int arg4 ;
43030 int arg5 ;
43031 PyObject *arg6 = (PyObject *) NULL ;
43032 wxGBSizerItem *result;
43033 wxGBPosition temp2 ;
43034 wxGBSpan temp3 ;
43035 PyObject * obj0 = 0 ;
43036 PyObject * obj1 = 0 ;
43037 PyObject * obj2 = 0 ;
43038 PyObject * obj3 = 0 ;
43039 PyObject * obj4 = 0 ;
43040 PyObject * obj5 = 0 ;
43041 char *kwnames[] = {
43042 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43043 };
43044
43045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
43046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43047 if (SWIG_arg_fail(1)) SWIG_fail;
43048 {
43049 arg2 = &temp2;
43050 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43051 }
43052 {
43053 arg3 = &temp3;
43054 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43055 }
43056 {
43057 arg4 = (int)(SWIG_As_int(obj3));
43058 if (SWIG_arg_fail(4)) SWIG_fail;
43059 }
43060 {
43061 arg5 = (int)(SWIG_As_int(obj4));
43062 if (SWIG_arg_fail(5)) SWIG_fail;
43063 }
43064 if (obj5) {
43065 arg6 = obj5;
43066 }
43067 {
43068 PyThreadState* __tstate = wxPyBeginAllowThreads();
43069 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
43070
43071 wxPyEndAllowThreads(__tstate);
43072 if (PyErr_Occurred()) SWIG_fail;
43073 }
43074 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43075 return resultobj;
43076 fail:
43077 return NULL;
43078 }
43079
43080
43081 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
43082 PyObject *resultobj;
43083 int arg1 ;
43084 int arg2 ;
43085 wxGBPosition *arg3 = 0 ;
43086 wxGBSpan *arg4 = 0 ;
43087 int arg5 ;
43088 int arg6 ;
43089 PyObject *arg7 = (PyObject *) NULL ;
43090 wxGBSizerItem *result;
43091 wxGBPosition temp3 ;
43092 wxGBSpan temp4 ;
43093 PyObject * obj0 = 0 ;
43094 PyObject * obj1 = 0 ;
43095 PyObject * obj2 = 0 ;
43096 PyObject * obj3 = 0 ;
43097 PyObject * obj4 = 0 ;
43098 PyObject * obj5 = 0 ;
43099 PyObject * obj6 = 0 ;
43100 char *kwnames[] = {
43101 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43102 };
43103
43104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43105 {
43106 arg1 = (int)(SWIG_As_int(obj0));
43107 if (SWIG_arg_fail(1)) SWIG_fail;
43108 }
43109 {
43110 arg2 = (int)(SWIG_As_int(obj1));
43111 if (SWIG_arg_fail(2)) SWIG_fail;
43112 }
43113 {
43114 arg3 = &temp3;
43115 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43116 }
43117 {
43118 arg4 = &temp4;
43119 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43120 }
43121 {
43122 arg5 = (int)(SWIG_As_int(obj4));
43123 if (SWIG_arg_fail(5)) SWIG_fail;
43124 }
43125 {
43126 arg6 = (int)(SWIG_As_int(obj5));
43127 if (SWIG_arg_fail(6)) SWIG_fail;
43128 }
43129 if (obj6) {
43130 arg7 = obj6;
43131 }
43132 {
43133 PyThreadState* __tstate = wxPyBeginAllowThreads();
43134 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43135
43136 wxPyEndAllowThreads(__tstate);
43137 if (PyErr_Occurred()) SWIG_fail;
43138 }
43139 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
43140 return resultobj;
43141 fail:
43142 return NULL;
43143 }
43144
43145
43146 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43147 PyObject *resultobj;
43148 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43149 wxGBPosition result;
43150 PyObject * obj0 = 0 ;
43151 char *kwnames[] = {
43152 (char *) "self", NULL
43153 };
43154
43155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
43156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43157 if (SWIG_arg_fail(1)) SWIG_fail;
43158 {
43159 PyThreadState* __tstate = wxPyBeginAllowThreads();
43160 result = ((wxGBSizerItem const *)arg1)->GetPos();
43161
43162 wxPyEndAllowThreads(__tstate);
43163 if (PyErr_Occurred()) SWIG_fail;
43164 }
43165 {
43166 wxGBPosition * resultptr;
43167 resultptr = new wxGBPosition((wxGBPosition &)(result));
43168 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43169 }
43170 return resultobj;
43171 fail:
43172 return NULL;
43173 }
43174
43175
43176 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43177 PyObject *resultobj;
43178 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43179 wxGBSpan result;
43180 PyObject * obj0 = 0 ;
43181 char *kwnames[] = {
43182 (char *) "self", NULL
43183 };
43184
43185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
43186 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43187 if (SWIG_arg_fail(1)) SWIG_fail;
43188 {
43189 PyThreadState* __tstate = wxPyBeginAllowThreads();
43190 result = ((wxGBSizerItem const *)arg1)->GetSpan();
43191
43192 wxPyEndAllowThreads(__tstate);
43193 if (PyErr_Occurred()) SWIG_fail;
43194 }
43195 {
43196 wxGBSpan * resultptr;
43197 resultptr = new wxGBSpan((wxGBSpan &)(result));
43198 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43199 }
43200 return resultobj;
43201 fail:
43202 return NULL;
43203 }
43204
43205
43206 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
43207 PyObject *resultobj;
43208 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43209 wxGBPosition *arg2 = 0 ;
43210 bool result;
43211 wxGBPosition temp2 ;
43212 PyObject * obj0 = 0 ;
43213 PyObject * obj1 = 0 ;
43214 char *kwnames[] = {
43215 (char *) "self",(char *) "pos", NULL
43216 };
43217
43218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
43219 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43220 if (SWIG_arg_fail(1)) SWIG_fail;
43221 {
43222 arg2 = &temp2;
43223 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43224 }
43225 {
43226 PyThreadState* __tstate = wxPyBeginAllowThreads();
43227 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
43228
43229 wxPyEndAllowThreads(__tstate);
43230 if (PyErr_Occurred()) SWIG_fail;
43231 }
43232 {
43233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43234 }
43235 return resultobj;
43236 fail:
43237 return NULL;
43238 }
43239
43240
43241 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
43242 PyObject *resultobj;
43243 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43244 wxGBSpan *arg2 = 0 ;
43245 bool result;
43246 wxGBSpan temp2 ;
43247 PyObject * obj0 = 0 ;
43248 PyObject * obj1 = 0 ;
43249 char *kwnames[] = {
43250 (char *) "self",(char *) "span", NULL
43251 };
43252
43253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
43254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43255 if (SWIG_arg_fail(1)) SWIG_fail;
43256 {
43257 arg2 = &temp2;
43258 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
43259 }
43260 {
43261 PyThreadState* __tstate = wxPyBeginAllowThreads();
43262 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
43263
43264 wxPyEndAllowThreads(__tstate);
43265 if (PyErr_Occurred()) SWIG_fail;
43266 }
43267 {
43268 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43269 }
43270 return resultobj;
43271 fail:
43272 return NULL;
43273 }
43274
43275
43276 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
43277 PyObject *resultobj;
43278 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43279 wxGBSizerItem *arg2 = 0 ;
43280 bool result;
43281 PyObject * obj0 = 0 ;
43282 PyObject * obj1 = 0 ;
43283 char *kwnames[] = {
43284 (char *) "self",(char *) "other", NULL
43285 };
43286
43287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
43288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43289 if (SWIG_arg_fail(1)) SWIG_fail;
43290 {
43291 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43292 if (SWIG_arg_fail(2)) SWIG_fail;
43293 if (arg2 == NULL) {
43294 SWIG_null_ref("wxGBSizerItem");
43295 }
43296 if (SWIG_arg_fail(2)) SWIG_fail;
43297 }
43298 {
43299 PyThreadState* __tstate = wxPyBeginAllowThreads();
43300 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
43301
43302 wxPyEndAllowThreads(__tstate);
43303 if (PyErr_Occurred()) SWIG_fail;
43304 }
43305 {
43306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43307 }
43308 return resultobj;
43309 fail:
43310 return NULL;
43311 }
43312
43313
43314 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
43315 PyObject *resultobj;
43316 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43317 wxGBPosition *arg2 = 0 ;
43318 wxGBSpan *arg3 = 0 ;
43319 bool result;
43320 wxGBPosition temp2 ;
43321 wxGBSpan temp3 ;
43322 PyObject * obj0 = 0 ;
43323 PyObject * obj1 = 0 ;
43324 PyObject * obj2 = 0 ;
43325 char *kwnames[] = {
43326 (char *) "self",(char *) "pos",(char *) "span", NULL
43327 };
43328
43329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
43330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43331 if (SWIG_arg_fail(1)) SWIG_fail;
43332 {
43333 arg2 = &temp2;
43334 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43335 }
43336 {
43337 arg3 = &temp3;
43338 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43339 }
43340 {
43341 PyThreadState* __tstate = wxPyBeginAllowThreads();
43342 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
43343
43344 wxPyEndAllowThreads(__tstate);
43345 if (PyErr_Occurred()) SWIG_fail;
43346 }
43347 {
43348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43349 }
43350 return resultobj;
43351 fail:
43352 return NULL;
43353 }
43354
43355
43356 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
43357 PyObject *resultobj;
43358 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43359 wxGBPosition result;
43360 PyObject * obj0 = 0 ;
43361 char *kwnames[] = {
43362 (char *) "self", NULL
43363 };
43364
43365 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
43366 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43367 if (SWIG_arg_fail(1)) SWIG_fail;
43368 {
43369 PyThreadState* __tstate = wxPyBeginAllowThreads();
43370 result = wxGBSizerItem_GetEndPos(arg1);
43371
43372 wxPyEndAllowThreads(__tstate);
43373 if (PyErr_Occurred()) SWIG_fail;
43374 }
43375 {
43376 wxGBPosition * resultptr;
43377 resultptr = new wxGBPosition((wxGBPosition &)(result));
43378 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43379 }
43380 return resultobj;
43381 fail:
43382 return NULL;
43383 }
43384
43385
43386 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43387 PyObject *resultobj;
43388 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43389 wxGridBagSizer *result;
43390 PyObject * obj0 = 0 ;
43391 char *kwnames[] = {
43392 (char *) "self", NULL
43393 };
43394
43395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
43396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43397 if (SWIG_arg_fail(1)) SWIG_fail;
43398 {
43399 PyThreadState* __tstate = wxPyBeginAllowThreads();
43400 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
43401
43402 wxPyEndAllowThreads(__tstate);
43403 if (PyErr_Occurred()) SWIG_fail;
43404 }
43405 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
43406 return resultobj;
43407 fail:
43408 return NULL;
43409 }
43410
43411
43412 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43413 PyObject *resultobj;
43414 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
43415 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
43416 PyObject * obj0 = 0 ;
43417 PyObject * obj1 = 0 ;
43418 char *kwnames[] = {
43419 (char *) "self",(char *) "sizer", NULL
43420 };
43421
43422 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
43423 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43424 if (SWIG_arg_fail(1)) SWIG_fail;
43425 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43426 if (SWIG_arg_fail(2)) SWIG_fail;
43427 {
43428 PyThreadState* __tstate = wxPyBeginAllowThreads();
43429 (arg1)->SetGBSizer(arg2);
43430
43431 wxPyEndAllowThreads(__tstate);
43432 if (PyErr_Occurred()) SWIG_fail;
43433 }
43434 Py_INCREF(Py_None); resultobj = Py_None;
43435 return resultobj;
43436 fail:
43437 return NULL;
43438 }
43439
43440
43441 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
43442 PyObject *obj;
43443 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
43444 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
43445 Py_INCREF(obj);
43446 return Py_BuildValue((char *)"");
43447 }
43448 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
43449 PyObject *resultobj;
43450 int arg1 = (int) 0 ;
43451 int arg2 = (int) 0 ;
43452 wxGridBagSizer *result;
43453 PyObject * obj0 = 0 ;
43454 PyObject * obj1 = 0 ;
43455 char *kwnames[] = {
43456 (char *) "vgap",(char *) "hgap", NULL
43457 };
43458
43459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
43460 if (obj0) {
43461 {
43462 arg1 = (int)(SWIG_As_int(obj0));
43463 if (SWIG_arg_fail(1)) SWIG_fail;
43464 }
43465 }
43466 if (obj1) {
43467 {
43468 arg2 = (int)(SWIG_As_int(obj1));
43469 if (SWIG_arg_fail(2)) SWIG_fail;
43470 }
43471 }
43472 {
43473 PyThreadState* __tstate = wxPyBeginAllowThreads();
43474 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
43475
43476 wxPyEndAllowThreads(__tstate);
43477 if (PyErr_Occurred()) SWIG_fail;
43478 }
43479 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
43480 return resultobj;
43481 fail:
43482 return NULL;
43483 }
43484
43485
43486 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
43487 PyObject *resultobj;
43488 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43489 PyObject *arg2 = (PyObject *) 0 ;
43490 wxGBPosition *arg3 = 0 ;
43491 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
43492 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
43493 int arg5 = (int) 0 ;
43494 int arg6 = (int) 0 ;
43495 PyObject *arg7 = (PyObject *) NULL ;
43496 wxGBSizerItem *result;
43497 wxGBPosition temp3 ;
43498 wxGBSpan temp4 ;
43499 PyObject * obj0 = 0 ;
43500 PyObject * obj1 = 0 ;
43501 PyObject * obj2 = 0 ;
43502 PyObject * obj3 = 0 ;
43503 PyObject * obj4 = 0 ;
43504 PyObject * obj5 = 0 ;
43505 PyObject * obj6 = 0 ;
43506 char *kwnames[] = {
43507 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
43508 };
43509
43510 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
43511 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43512 if (SWIG_arg_fail(1)) SWIG_fail;
43513 arg2 = obj1;
43514 {
43515 arg3 = &temp3;
43516 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43517 }
43518 if (obj3) {
43519 {
43520 arg4 = &temp4;
43521 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
43522 }
43523 }
43524 if (obj4) {
43525 {
43526 arg5 = (int)(SWIG_As_int(obj4));
43527 if (SWIG_arg_fail(5)) SWIG_fail;
43528 }
43529 }
43530 if (obj5) {
43531 {
43532 arg6 = (int)(SWIG_As_int(obj5));
43533 if (SWIG_arg_fail(6)) SWIG_fail;
43534 }
43535 }
43536 if (obj6) {
43537 arg7 = obj6;
43538 }
43539 {
43540 PyThreadState* __tstate = wxPyBeginAllowThreads();
43541 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
43542
43543 wxPyEndAllowThreads(__tstate);
43544 if (PyErr_Occurred()) SWIG_fail;
43545 }
43546 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43547 return resultobj;
43548 fail:
43549 return NULL;
43550 }
43551
43552
43553 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
43554 PyObject *resultobj;
43555 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43556 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
43557 wxGBSizerItem *result;
43558 PyObject * obj0 = 0 ;
43559 PyObject * obj1 = 0 ;
43560 char *kwnames[] = {
43561 (char *) "self",(char *) "item", NULL
43562 };
43563
43564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
43565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43566 if (SWIG_arg_fail(1)) SWIG_fail;
43567 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
43568 if (SWIG_arg_fail(2)) SWIG_fail;
43569 {
43570 PyThreadState* __tstate = wxPyBeginAllowThreads();
43571 result = (wxGBSizerItem *)(arg1)->Add(arg2);
43572
43573 wxPyEndAllowThreads(__tstate);
43574 if (PyErr_Occurred()) SWIG_fail;
43575 }
43576 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43577 return resultobj;
43578 fail:
43579 return NULL;
43580 }
43581
43582
43583 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43584 PyObject *resultobj;
43585 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43586 int arg2 ;
43587 int arg3 ;
43588 wxSize result;
43589 PyObject * obj0 = 0 ;
43590 PyObject * obj1 = 0 ;
43591 PyObject * obj2 = 0 ;
43592 char *kwnames[] = {
43593 (char *) "self",(char *) "row",(char *) "col", NULL
43594 };
43595
43596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
43597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43598 if (SWIG_arg_fail(1)) SWIG_fail;
43599 {
43600 arg2 = (int)(SWIG_As_int(obj1));
43601 if (SWIG_arg_fail(2)) SWIG_fail;
43602 }
43603 {
43604 arg3 = (int)(SWIG_As_int(obj2));
43605 if (SWIG_arg_fail(3)) SWIG_fail;
43606 }
43607 {
43608 PyThreadState* __tstate = wxPyBeginAllowThreads();
43609 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
43610
43611 wxPyEndAllowThreads(__tstate);
43612 if (PyErr_Occurred()) SWIG_fail;
43613 }
43614 {
43615 wxSize * resultptr;
43616 resultptr = new wxSize((wxSize &)(result));
43617 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43618 }
43619 return resultobj;
43620 fail:
43621 return NULL;
43622 }
43623
43624
43625 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43626 PyObject *resultobj;
43627 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43628 wxSize result;
43629 PyObject * obj0 = 0 ;
43630 char *kwnames[] = {
43631 (char *) "self", NULL
43632 };
43633
43634 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43635 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43636 if (SWIG_arg_fail(1)) SWIG_fail;
43637 {
43638 PyThreadState* __tstate = wxPyBeginAllowThreads();
43639 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43640
43641 wxPyEndAllowThreads(__tstate);
43642 if (PyErr_Occurred()) SWIG_fail;
43643 }
43644 {
43645 wxSize * resultptr;
43646 resultptr = new wxSize((wxSize &)(result));
43647 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43648 }
43649 return resultobj;
43650 fail:
43651 return NULL;
43652 }
43653
43654
43655 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43656 PyObject *resultobj;
43657 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43658 wxSize *arg2 = 0 ;
43659 wxSize temp2 ;
43660 PyObject * obj0 = 0 ;
43661 PyObject * obj1 = 0 ;
43662 char *kwnames[] = {
43663 (char *) "self",(char *) "sz", NULL
43664 };
43665
43666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43667 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43668 if (SWIG_arg_fail(1)) SWIG_fail;
43669 {
43670 arg2 = &temp2;
43671 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43672 }
43673 {
43674 PyThreadState* __tstate = wxPyBeginAllowThreads();
43675 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43676
43677 wxPyEndAllowThreads(__tstate);
43678 if (PyErr_Occurred()) SWIG_fail;
43679 }
43680 Py_INCREF(Py_None); resultobj = Py_None;
43681 return resultobj;
43682 fail:
43683 return NULL;
43684 }
43685
43686
43687 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43688 PyObject *resultobj;
43689 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43690 wxWindow *arg2 = (wxWindow *) 0 ;
43691 wxGBPosition result;
43692 PyObject * obj0 = 0 ;
43693 PyObject * obj1 = 0 ;
43694
43695 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43697 if (SWIG_arg_fail(1)) SWIG_fail;
43698 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43699 if (SWIG_arg_fail(2)) SWIG_fail;
43700 {
43701 PyThreadState* __tstate = wxPyBeginAllowThreads();
43702 result = (arg1)->GetItemPosition(arg2);
43703
43704 wxPyEndAllowThreads(__tstate);
43705 if (PyErr_Occurred()) SWIG_fail;
43706 }
43707 {
43708 wxGBPosition * resultptr;
43709 resultptr = new wxGBPosition((wxGBPosition &)(result));
43710 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43711 }
43712 return resultobj;
43713 fail:
43714 return NULL;
43715 }
43716
43717
43718 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43719 PyObject *resultobj;
43720 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43721 wxSizer *arg2 = (wxSizer *) 0 ;
43722 wxGBPosition result;
43723 PyObject * obj0 = 0 ;
43724 PyObject * obj1 = 0 ;
43725
43726 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43728 if (SWIG_arg_fail(1)) SWIG_fail;
43729 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43730 if (SWIG_arg_fail(2)) SWIG_fail;
43731 {
43732 PyThreadState* __tstate = wxPyBeginAllowThreads();
43733 result = (arg1)->GetItemPosition(arg2);
43734
43735 wxPyEndAllowThreads(__tstate);
43736 if (PyErr_Occurred()) SWIG_fail;
43737 }
43738 {
43739 wxGBPosition * resultptr;
43740 resultptr = new wxGBPosition((wxGBPosition &)(result));
43741 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43742 }
43743 return resultobj;
43744 fail:
43745 return NULL;
43746 }
43747
43748
43749 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43750 PyObject *resultobj;
43751 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43752 size_t arg2 ;
43753 wxGBPosition result;
43754 PyObject * obj0 = 0 ;
43755 PyObject * obj1 = 0 ;
43756
43757 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43759 if (SWIG_arg_fail(1)) SWIG_fail;
43760 {
43761 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43762 if (SWIG_arg_fail(2)) SWIG_fail;
43763 }
43764 {
43765 PyThreadState* __tstate = wxPyBeginAllowThreads();
43766 result = (arg1)->GetItemPosition(arg2);
43767
43768 wxPyEndAllowThreads(__tstate);
43769 if (PyErr_Occurred()) SWIG_fail;
43770 }
43771 {
43772 wxGBPosition * resultptr;
43773 resultptr = new wxGBPosition((wxGBPosition &)(result));
43774 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43775 }
43776 return resultobj;
43777 fail:
43778 return NULL;
43779 }
43780
43781
43782 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43783 int argc;
43784 PyObject *argv[3];
43785 int ii;
43786
43787 argc = PyObject_Length(args);
43788 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43789 argv[ii] = PyTuple_GetItem(args,ii);
43790 }
43791 if (argc == 2) {
43792 int _v;
43793 {
43794 void *ptr;
43795 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43796 _v = 0;
43797 PyErr_Clear();
43798 } else {
43799 _v = 1;
43800 }
43801 }
43802 if (_v) {
43803 {
43804 void *ptr;
43805 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43806 _v = 0;
43807 PyErr_Clear();
43808 } else {
43809 _v = 1;
43810 }
43811 }
43812 if (_v) {
43813 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43814 }
43815 }
43816 }
43817 if (argc == 2) {
43818 int _v;
43819 {
43820 void *ptr;
43821 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43822 _v = 0;
43823 PyErr_Clear();
43824 } else {
43825 _v = 1;
43826 }
43827 }
43828 if (_v) {
43829 {
43830 void *ptr;
43831 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43832 _v = 0;
43833 PyErr_Clear();
43834 } else {
43835 _v = 1;
43836 }
43837 }
43838 if (_v) {
43839 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43840 }
43841 }
43842 }
43843 if (argc == 2) {
43844 int _v;
43845 {
43846 void *ptr;
43847 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43848 _v = 0;
43849 PyErr_Clear();
43850 } else {
43851 _v = 1;
43852 }
43853 }
43854 if (_v) {
43855 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43856 if (_v) {
43857 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43858 }
43859 }
43860 }
43861
43862 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43863 return NULL;
43864 }
43865
43866
43867 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43868 PyObject *resultobj;
43869 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43870 wxWindow *arg2 = (wxWindow *) 0 ;
43871 wxGBPosition *arg3 = 0 ;
43872 bool result;
43873 wxGBPosition temp3 ;
43874 PyObject * obj0 = 0 ;
43875 PyObject * obj1 = 0 ;
43876 PyObject * obj2 = 0 ;
43877
43878 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43880 if (SWIG_arg_fail(1)) SWIG_fail;
43881 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43882 if (SWIG_arg_fail(2)) SWIG_fail;
43883 {
43884 arg3 = &temp3;
43885 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43886 }
43887 {
43888 PyThreadState* __tstate = wxPyBeginAllowThreads();
43889 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43890
43891 wxPyEndAllowThreads(__tstate);
43892 if (PyErr_Occurred()) SWIG_fail;
43893 }
43894 {
43895 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43896 }
43897 return resultobj;
43898 fail:
43899 return NULL;
43900 }
43901
43902
43903 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43904 PyObject *resultobj;
43905 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43906 wxSizer *arg2 = (wxSizer *) 0 ;
43907 wxGBPosition *arg3 = 0 ;
43908 bool result;
43909 wxGBPosition temp3 ;
43910 PyObject * obj0 = 0 ;
43911 PyObject * obj1 = 0 ;
43912 PyObject * obj2 = 0 ;
43913
43914 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43916 if (SWIG_arg_fail(1)) SWIG_fail;
43917 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43918 if (SWIG_arg_fail(2)) SWIG_fail;
43919 {
43920 arg3 = &temp3;
43921 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43922 }
43923 {
43924 PyThreadState* __tstate = wxPyBeginAllowThreads();
43925 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43926
43927 wxPyEndAllowThreads(__tstate);
43928 if (PyErr_Occurred()) SWIG_fail;
43929 }
43930 {
43931 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43932 }
43933 return resultobj;
43934 fail:
43935 return NULL;
43936 }
43937
43938
43939 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43940 PyObject *resultobj;
43941 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43942 size_t arg2 ;
43943 wxGBPosition *arg3 = 0 ;
43944 bool result;
43945 wxGBPosition temp3 ;
43946 PyObject * obj0 = 0 ;
43947 PyObject * obj1 = 0 ;
43948 PyObject * obj2 = 0 ;
43949
43950 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43952 if (SWIG_arg_fail(1)) SWIG_fail;
43953 {
43954 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43955 if (SWIG_arg_fail(2)) SWIG_fail;
43956 }
43957 {
43958 arg3 = &temp3;
43959 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43960 }
43961 {
43962 PyThreadState* __tstate = wxPyBeginAllowThreads();
43963 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43964
43965 wxPyEndAllowThreads(__tstate);
43966 if (PyErr_Occurred()) SWIG_fail;
43967 }
43968 {
43969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43970 }
43971 return resultobj;
43972 fail:
43973 return NULL;
43974 }
43975
43976
43977 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43978 int argc;
43979 PyObject *argv[4];
43980 int ii;
43981
43982 argc = PyObject_Length(args);
43983 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43984 argv[ii] = PyTuple_GetItem(args,ii);
43985 }
43986 if (argc == 3) {
43987 int _v;
43988 {
43989 void *ptr;
43990 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43991 _v = 0;
43992 PyErr_Clear();
43993 } else {
43994 _v = 1;
43995 }
43996 }
43997 if (_v) {
43998 {
43999 void *ptr;
44000 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44001 _v = 0;
44002 PyErr_Clear();
44003 } else {
44004 _v = 1;
44005 }
44006 }
44007 if (_v) {
44008 {
44009 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44010 }
44011 if (_v) {
44012 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
44013 }
44014 }
44015 }
44016 }
44017 if (argc == 3) {
44018 int _v;
44019 {
44020 void *ptr;
44021 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44022 _v = 0;
44023 PyErr_Clear();
44024 } else {
44025 _v = 1;
44026 }
44027 }
44028 if (_v) {
44029 {
44030 void *ptr;
44031 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44032 _v = 0;
44033 PyErr_Clear();
44034 } else {
44035 _v = 1;
44036 }
44037 }
44038 if (_v) {
44039 {
44040 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44041 }
44042 if (_v) {
44043 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
44044 }
44045 }
44046 }
44047 }
44048 if (argc == 3) {
44049 int _v;
44050 {
44051 void *ptr;
44052 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44053 _v = 0;
44054 PyErr_Clear();
44055 } else {
44056 _v = 1;
44057 }
44058 }
44059 if (_v) {
44060 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44061 if (_v) {
44062 {
44063 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
44064 }
44065 if (_v) {
44066 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
44067 }
44068 }
44069 }
44070 }
44071
44072 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
44073 return NULL;
44074 }
44075
44076
44077 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44078 PyObject *resultobj;
44079 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44080 wxWindow *arg2 = (wxWindow *) 0 ;
44081 wxGBSpan result;
44082 PyObject * obj0 = 0 ;
44083 PyObject * obj1 = 0 ;
44084
44085 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44087 if (SWIG_arg_fail(1)) SWIG_fail;
44088 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44089 if (SWIG_arg_fail(2)) SWIG_fail;
44090 {
44091 PyThreadState* __tstate = wxPyBeginAllowThreads();
44092 result = (arg1)->GetItemSpan(arg2);
44093
44094 wxPyEndAllowThreads(__tstate);
44095 if (PyErr_Occurred()) SWIG_fail;
44096 }
44097 {
44098 wxGBSpan * resultptr;
44099 resultptr = new wxGBSpan((wxGBSpan &)(result));
44100 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44101 }
44102 return resultobj;
44103 fail:
44104 return NULL;
44105 }
44106
44107
44108 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44109 PyObject *resultobj;
44110 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44111 wxSizer *arg2 = (wxSizer *) 0 ;
44112 wxGBSpan result;
44113 PyObject * obj0 = 0 ;
44114 PyObject * obj1 = 0 ;
44115
44116 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44118 if (SWIG_arg_fail(1)) SWIG_fail;
44119 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44120 if (SWIG_arg_fail(2)) SWIG_fail;
44121 {
44122 PyThreadState* __tstate = wxPyBeginAllowThreads();
44123 result = (arg1)->GetItemSpan(arg2);
44124
44125 wxPyEndAllowThreads(__tstate);
44126 if (PyErr_Occurred()) SWIG_fail;
44127 }
44128 {
44129 wxGBSpan * resultptr;
44130 resultptr = new wxGBSpan((wxGBSpan &)(result));
44131 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44132 }
44133 return resultobj;
44134 fail:
44135 return NULL;
44136 }
44137
44138
44139 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44140 PyObject *resultobj;
44141 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44142 size_t arg2 ;
44143 wxGBSpan result;
44144 PyObject * obj0 = 0 ;
44145 PyObject * obj1 = 0 ;
44146
44147 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
44148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44149 if (SWIG_arg_fail(1)) SWIG_fail;
44150 {
44151 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
44152 if (SWIG_arg_fail(2)) SWIG_fail;
44153 }
44154 {
44155 PyThreadState* __tstate = wxPyBeginAllowThreads();
44156 result = (arg1)->GetItemSpan(arg2);
44157
44158 wxPyEndAllowThreads(__tstate);
44159 if (PyErr_Occurred()) SWIG_fail;
44160 }
44161 {
44162 wxGBSpan * resultptr;
44163 resultptr = new wxGBSpan((wxGBSpan &)(result));
44164 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
44165 }
44166 return resultobj;
44167 fail:
44168 return NULL;
44169 }
44170
44171
44172 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
44173 int argc;
44174 PyObject *argv[3];
44175 int ii;
44176
44177 argc = PyObject_Length(args);
44178 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44179 argv[ii] = PyTuple_GetItem(args,ii);
44180 }
44181 if (argc == 2) {
44182 int _v;
44183 {
44184 void *ptr;
44185 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44186 _v = 0;
44187 PyErr_Clear();
44188 } else {
44189 _v = 1;
44190 }
44191 }
44192 if (_v) {
44193 {
44194 void *ptr;
44195 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44196 _v = 0;
44197 PyErr_Clear();
44198 } else {
44199 _v = 1;
44200 }
44201 }
44202 if (_v) {
44203 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
44204 }
44205 }
44206 }
44207 if (argc == 2) {
44208 int _v;
44209 {
44210 void *ptr;
44211 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44212 _v = 0;
44213 PyErr_Clear();
44214 } else {
44215 _v = 1;
44216 }
44217 }
44218 if (_v) {
44219 {
44220 void *ptr;
44221 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44222 _v = 0;
44223 PyErr_Clear();
44224 } else {
44225 _v = 1;
44226 }
44227 }
44228 if (_v) {
44229 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
44230 }
44231 }
44232 }
44233 if (argc == 2) {
44234 int _v;
44235 {
44236 void *ptr;
44237 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44238 _v = 0;
44239 PyErr_Clear();
44240 } else {
44241 _v = 1;
44242 }
44243 }
44244 if (_v) {
44245 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44246 if (_v) {
44247 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
44248 }
44249 }
44250 }
44251
44252 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
44253 return NULL;
44254 }
44255
44256
44257 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
44258 PyObject *resultobj;
44259 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44260 wxWindow *arg2 = (wxWindow *) 0 ;
44261 wxGBSpan *arg3 = 0 ;
44262 bool result;
44263 wxGBSpan temp3 ;
44264 PyObject * obj0 = 0 ;
44265 PyObject * obj1 = 0 ;
44266 PyObject * obj2 = 0 ;
44267
44268 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44269 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44270 if (SWIG_arg_fail(1)) SWIG_fail;
44271 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44272 if (SWIG_arg_fail(2)) SWIG_fail;
44273 {
44274 arg3 = &temp3;
44275 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44276 }
44277 {
44278 PyThreadState* __tstate = wxPyBeginAllowThreads();
44279 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44280
44281 wxPyEndAllowThreads(__tstate);
44282 if (PyErr_Occurred()) SWIG_fail;
44283 }
44284 {
44285 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44286 }
44287 return resultobj;
44288 fail:
44289 return NULL;
44290 }
44291
44292
44293 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
44294 PyObject *resultobj;
44295 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44296 wxSizer *arg2 = (wxSizer *) 0 ;
44297 wxGBSpan *arg3 = 0 ;
44298 bool result;
44299 wxGBSpan temp3 ;
44300 PyObject * obj0 = 0 ;
44301 PyObject * obj1 = 0 ;
44302 PyObject * obj2 = 0 ;
44303
44304 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44305 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44306 if (SWIG_arg_fail(1)) SWIG_fail;
44307 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44308 if (SWIG_arg_fail(2)) SWIG_fail;
44309 {
44310 arg3 = &temp3;
44311 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44312 }
44313 {
44314 PyThreadState* __tstate = wxPyBeginAllowThreads();
44315 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44316
44317 wxPyEndAllowThreads(__tstate);
44318 if (PyErr_Occurred()) SWIG_fail;
44319 }
44320 {
44321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44322 }
44323 return resultobj;
44324 fail:
44325 return NULL;
44326 }
44327
44328
44329 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
44330 PyObject *resultobj;
44331 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44332 size_t arg2 ;
44333 wxGBSpan *arg3 = 0 ;
44334 bool result;
44335 wxGBSpan temp3 ;
44336 PyObject * obj0 = 0 ;
44337 PyObject * obj1 = 0 ;
44338 PyObject * obj2 = 0 ;
44339
44340 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
44341 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44342 if (SWIG_arg_fail(1)) SWIG_fail;
44343 {
44344 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
44345 if (SWIG_arg_fail(2)) SWIG_fail;
44346 }
44347 {
44348 arg3 = &temp3;
44349 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44350 }
44351 {
44352 PyThreadState* __tstate = wxPyBeginAllowThreads();
44353 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
44354
44355 wxPyEndAllowThreads(__tstate);
44356 if (PyErr_Occurred()) SWIG_fail;
44357 }
44358 {
44359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44360 }
44361 return resultobj;
44362 fail:
44363 return NULL;
44364 }
44365
44366
44367 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
44368 int argc;
44369 PyObject *argv[4];
44370 int ii;
44371
44372 argc = PyObject_Length(args);
44373 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
44374 argv[ii] = PyTuple_GetItem(args,ii);
44375 }
44376 if (argc == 3) {
44377 int _v;
44378 {
44379 void *ptr;
44380 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44381 _v = 0;
44382 PyErr_Clear();
44383 } else {
44384 _v = 1;
44385 }
44386 }
44387 if (_v) {
44388 {
44389 void *ptr;
44390 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44391 _v = 0;
44392 PyErr_Clear();
44393 } else {
44394 _v = 1;
44395 }
44396 }
44397 if (_v) {
44398 {
44399 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44400 }
44401 if (_v) {
44402 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
44403 }
44404 }
44405 }
44406 }
44407 if (argc == 3) {
44408 int _v;
44409 {
44410 void *ptr;
44411 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44412 _v = 0;
44413 PyErr_Clear();
44414 } else {
44415 _v = 1;
44416 }
44417 }
44418 if (_v) {
44419 {
44420 void *ptr;
44421 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44422 _v = 0;
44423 PyErr_Clear();
44424 } else {
44425 _v = 1;
44426 }
44427 }
44428 if (_v) {
44429 {
44430 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44431 }
44432 if (_v) {
44433 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
44434 }
44435 }
44436 }
44437 }
44438 if (argc == 3) {
44439 int _v;
44440 {
44441 void *ptr;
44442 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44443 _v = 0;
44444 PyErr_Clear();
44445 } else {
44446 _v = 1;
44447 }
44448 }
44449 if (_v) {
44450 _v = SWIG_Check_unsigned_SS_long(argv[1]);
44451 if (_v) {
44452 {
44453 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
44454 }
44455 if (_v) {
44456 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
44457 }
44458 }
44459 }
44460 }
44461
44462 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
44463 return NULL;
44464 }
44465
44466
44467 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
44468 PyObject *resultobj;
44469 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44470 wxWindow *arg2 = (wxWindow *) 0 ;
44471 wxGBSizerItem *result;
44472 PyObject * obj0 = 0 ;
44473 PyObject * obj1 = 0 ;
44474
44475 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44477 if (SWIG_arg_fail(1)) SWIG_fail;
44478 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44479 if (SWIG_arg_fail(2)) SWIG_fail;
44480 {
44481 PyThreadState* __tstate = wxPyBeginAllowThreads();
44482 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44483
44484 wxPyEndAllowThreads(__tstate);
44485 if (PyErr_Occurred()) SWIG_fail;
44486 }
44487 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44488 return resultobj;
44489 fail:
44490 return NULL;
44491 }
44492
44493
44494 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
44495 PyObject *resultobj;
44496 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44497 wxSizer *arg2 = (wxSizer *) 0 ;
44498 wxGBSizerItem *result;
44499 PyObject * obj0 = 0 ;
44500 PyObject * obj1 = 0 ;
44501
44502 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
44503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44504 if (SWIG_arg_fail(1)) SWIG_fail;
44505 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
44506 if (SWIG_arg_fail(2)) SWIG_fail;
44507 {
44508 PyThreadState* __tstate = wxPyBeginAllowThreads();
44509 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
44510
44511 wxPyEndAllowThreads(__tstate);
44512 if (PyErr_Occurred()) SWIG_fail;
44513 }
44514 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44515 return resultobj;
44516 fail:
44517 return NULL;
44518 }
44519
44520
44521 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
44522 int argc;
44523 PyObject *argv[3];
44524 int ii;
44525
44526 argc = PyObject_Length(args);
44527 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
44528 argv[ii] = PyTuple_GetItem(args,ii);
44529 }
44530 if (argc == 2) {
44531 int _v;
44532 {
44533 void *ptr;
44534 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44535 _v = 0;
44536 PyErr_Clear();
44537 } else {
44538 _v = 1;
44539 }
44540 }
44541 if (_v) {
44542 {
44543 void *ptr;
44544 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
44545 _v = 0;
44546 PyErr_Clear();
44547 } else {
44548 _v = 1;
44549 }
44550 }
44551 if (_v) {
44552 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
44553 }
44554 }
44555 }
44556 if (argc == 2) {
44557 int _v;
44558 {
44559 void *ptr;
44560 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
44561 _v = 0;
44562 PyErr_Clear();
44563 } else {
44564 _v = 1;
44565 }
44566 }
44567 if (_v) {
44568 {
44569 void *ptr;
44570 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
44571 _v = 0;
44572 PyErr_Clear();
44573 } else {
44574 _v = 1;
44575 }
44576 }
44577 if (_v) {
44578 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
44579 }
44580 }
44581 }
44582
44583 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
44584 return NULL;
44585 }
44586
44587
44588 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
44589 PyObject *resultobj;
44590 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44591 wxGBPosition *arg2 = 0 ;
44592 wxGBSizerItem *result;
44593 wxGBPosition temp2 ;
44594 PyObject * obj0 = 0 ;
44595 PyObject * obj1 = 0 ;
44596 char *kwnames[] = {
44597 (char *) "self",(char *) "pos", NULL
44598 };
44599
44600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
44601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44602 if (SWIG_arg_fail(1)) SWIG_fail;
44603 {
44604 arg2 = &temp2;
44605 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44606 }
44607 {
44608 PyThreadState* __tstate = wxPyBeginAllowThreads();
44609 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
44610
44611 wxPyEndAllowThreads(__tstate);
44612 if (PyErr_Occurred()) SWIG_fail;
44613 }
44614 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44615 return resultobj;
44616 fail:
44617 return NULL;
44618 }
44619
44620
44621 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44622 PyObject *resultobj;
44623 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44624 wxPoint *arg2 = 0 ;
44625 wxGBSizerItem *result;
44626 wxPoint temp2 ;
44627 PyObject * obj0 = 0 ;
44628 PyObject * obj1 = 0 ;
44629 char *kwnames[] = {
44630 (char *) "self",(char *) "pt", NULL
44631 };
44632
44633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44635 if (SWIG_arg_fail(1)) SWIG_fail;
44636 {
44637 arg2 = &temp2;
44638 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44639 }
44640 {
44641 PyThreadState* __tstate = wxPyBeginAllowThreads();
44642 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44643
44644 wxPyEndAllowThreads(__tstate);
44645 if (PyErr_Occurred()) SWIG_fail;
44646 }
44647 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44648 return resultobj;
44649 fail:
44650 return NULL;
44651 }
44652
44653
44654 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44655 PyObject *resultobj;
44656 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44657 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44658 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44659 bool result;
44660 PyObject * obj0 = 0 ;
44661 PyObject * obj1 = 0 ;
44662 PyObject * obj2 = 0 ;
44663 char *kwnames[] = {
44664 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44665 };
44666
44667 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44668 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44669 if (SWIG_arg_fail(1)) SWIG_fail;
44670 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44671 if (SWIG_arg_fail(2)) SWIG_fail;
44672 if (obj2) {
44673 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44674 if (SWIG_arg_fail(3)) SWIG_fail;
44675 }
44676 {
44677 PyThreadState* __tstate = wxPyBeginAllowThreads();
44678 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44679
44680 wxPyEndAllowThreads(__tstate);
44681 if (PyErr_Occurred()) SWIG_fail;
44682 }
44683 {
44684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44685 }
44686 return resultobj;
44687 fail:
44688 return NULL;
44689 }
44690
44691
44692 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44693 PyObject *resultobj;
44694 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44695 wxGBPosition *arg2 = 0 ;
44696 wxGBSpan *arg3 = 0 ;
44697 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44698 bool result;
44699 wxGBPosition temp2 ;
44700 wxGBSpan temp3 ;
44701 PyObject * obj0 = 0 ;
44702 PyObject * obj1 = 0 ;
44703 PyObject * obj2 = 0 ;
44704 PyObject * obj3 = 0 ;
44705 char *kwnames[] = {
44706 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44707 };
44708
44709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44711 if (SWIG_arg_fail(1)) SWIG_fail;
44712 {
44713 arg2 = &temp2;
44714 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44715 }
44716 {
44717 arg3 = &temp3;
44718 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44719 }
44720 if (obj3) {
44721 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44722 if (SWIG_arg_fail(4)) SWIG_fail;
44723 }
44724 {
44725 PyThreadState* __tstate = wxPyBeginAllowThreads();
44726 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44727
44728 wxPyEndAllowThreads(__tstate);
44729 if (PyErr_Occurred()) SWIG_fail;
44730 }
44731 {
44732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44733 }
44734 return resultobj;
44735 fail:
44736 return NULL;
44737 }
44738
44739
44740 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44741 PyObject *obj;
44742 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44743 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44744 Py_INCREF(obj);
44745 return Py_BuildValue((char *)"");
44746 }
44747 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44748 PyObject *resultobj;
44749 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44750 wxRelationship arg2 ;
44751 wxWindow *arg3 = (wxWindow *) 0 ;
44752 wxEdge arg4 ;
44753 int arg5 = (int) 0 ;
44754 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44755 PyObject * obj0 = 0 ;
44756 PyObject * obj1 = 0 ;
44757 PyObject * obj2 = 0 ;
44758 PyObject * obj3 = 0 ;
44759 PyObject * obj4 = 0 ;
44760 PyObject * obj5 = 0 ;
44761 char *kwnames[] = {
44762 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44763 };
44764
44765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44767 if (SWIG_arg_fail(1)) SWIG_fail;
44768 {
44769 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44770 if (SWIG_arg_fail(2)) SWIG_fail;
44771 }
44772 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44773 if (SWIG_arg_fail(3)) SWIG_fail;
44774 {
44775 arg4 = (wxEdge)(SWIG_As_int(obj3));
44776 if (SWIG_arg_fail(4)) SWIG_fail;
44777 }
44778 if (obj4) {
44779 {
44780 arg5 = (int)(SWIG_As_int(obj4));
44781 if (SWIG_arg_fail(5)) SWIG_fail;
44782 }
44783 }
44784 if (obj5) {
44785 {
44786 arg6 = (int)(SWIG_As_int(obj5));
44787 if (SWIG_arg_fail(6)) SWIG_fail;
44788 }
44789 }
44790 {
44791 PyThreadState* __tstate = wxPyBeginAllowThreads();
44792 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44793
44794 wxPyEndAllowThreads(__tstate);
44795 if (PyErr_Occurred()) SWIG_fail;
44796 }
44797 Py_INCREF(Py_None); resultobj = Py_None;
44798 return resultobj;
44799 fail:
44800 return NULL;
44801 }
44802
44803
44804 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44805 PyObject *resultobj;
44806 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44807 wxWindow *arg2 = (wxWindow *) 0 ;
44808 int arg3 = (int) 0 ;
44809 PyObject * obj0 = 0 ;
44810 PyObject * obj1 = 0 ;
44811 PyObject * obj2 = 0 ;
44812 char *kwnames[] = {
44813 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44814 };
44815
44816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44818 if (SWIG_arg_fail(1)) SWIG_fail;
44819 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44820 if (SWIG_arg_fail(2)) SWIG_fail;
44821 if (obj2) {
44822 {
44823 arg3 = (int)(SWIG_As_int(obj2));
44824 if (SWIG_arg_fail(3)) SWIG_fail;
44825 }
44826 }
44827 {
44828 PyThreadState* __tstate = wxPyBeginAllowThreads();
44829 (arg1)->LeftOf(arg2,arg3);
44830
44831 wxPyEndAllowThreads(__tstate);
44832 if (PyErr_Occurred()) SWIG_fail;
44833 }
44834 Py_INCREF(Py_None); resultobj = Py_None;
44835 return resultobj;
44836 fail:
44837 return NULL;
44838 }
44839
44840
44841 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44842 PyObject *resultobj;
44843 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44844 wxWindow *arg2 = (wxWindow *) 0 ;
44845 int arg3 = (int) 0 ;
44846 PyObject * obj0 = 0 ;
44847 PyObject * obj1 = 0 ;
44848 PyObject * obj2 = 0 ;
44849 char *kwnames[] = {
44850 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44851 };
44852
44853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44855 if (SWIG_arg_fail(1)) SWIG_fail;
44856 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44857 if (SWIG_arg_fail(2)) SWIG_fail;
44858 if (obj2) {
44859 {
44860 arg3 = (int)(SWIG_As_int(obj2));
44861 if (SWIG_arg_fail(3)) SWIG_fail;
44862 }
44863 }
44864 {
44865 PyThreadState* __tstate = wxPyBeginAllowThreads();
44866 (arg1)->RightOf(arg2,arg3);
44867
44868 wxPyEndAllowThreads(__tstate);
44869 if (PyErr_Occurred()) SWIG_fail;
44870 }
44871 Py_INCREF(Py_None); resultobj = Py_None;
44872 return resultobj;
44873 fail:
44874 return NULL;
44875 }
44876
44877
44878 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44879 PyObject *resultobj;
44880 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44881 wxWindow *arg2 = (wxWindow *) 0 ;
44882 int arg3 = (int) 0 ;
44883 PyObject * obj0 = 0 ;
44884 PyObject * obj1 = 0 ;
44885 PyObject * obj2 = 0 ;
44886 char *kwnames[] = {
44887 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44888 };
44889
44890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44892 if (SWIG_arg_fail(1)) SWIG_fail;
44893 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44894 if (SWIG_arg_fail(2)) SWIG_fail;
44895 if (obj2) {
44896 {
44897 arg3 = (int)(SWIG_As_int(obj2));
44898 if (SWIG_arg_fail(3)) SWIG_fail;
44899 }
44900 }
44901 {
44902 PyThreadState* __tstate = wxPyBeginAllowThreads();
44903 (arg1)->Above(arg2,arg3);
44904
44905 wxPyEndAllowThreads(__tstate);
44906 if (PyErr_Occurred()) SWIG_fail;
44907 }
44908 Py_INCREF(Py_None); resultobj = Py_None;
44909 return resultobj;
44910 fail:
44911 return NULL;
44912 }
44913
44914
44915 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44916 PyObject *resultobj;
44917 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44918 wxWindow *arg2 = (wxWindow *) 0 ;
44919 int arg3 = (int) 0 ;
44920 PyObject * obj0 = 0 ;
44921 PyObject * obj1 = 0 ;
44922 PyObject * obj2 = 0 ;
44923 char *kwnames[] = {
44924 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44925 };
44926
44927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44929 if (SWIG_arg_fail(1)) SWIG_fail;
44930 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44931 if (SWIG_arg_fail(2)) SWIG_fail;
44932 if (obj2) {
44933 {
44934 arg3 = (int)(SWIG_As_int(obj2));
44935 if (SWIG_arg_fail(3)) SWIG_fail;
44936 }
44937 }
44938 {
44939 PyThreadState* __tstate = wxPyBeginAllowThreads();
44940 (arg1)->Below(arg2,arg3);
44941
44942 wxPyEndAllowThreads(__tstate);
44943 if (PyErr_Occurred()) SWIG_fail;
44944 }
44945 Py_INCREF(Py_None); resultobj = Py_None;
44946 return resultobj;
44947 fail:
44948 return NULL;
44949 }
44950
44951
44952 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44953 PyObject *resultobj;
44954 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44955 wxWindow *arg2 = (wxWindow *) 0 ;
44956 wxEdge arg3 ;
44957 int arg4 = (int) 0 ;
44958 PyObject * obj0 = 0 ;
44959 PyObject * obj1 = 0 ;
44960 PyObject * obj2 = 0 ;
44961 PyObject * obj3 = 0 ;
44962 char *kwnames[] = {
44963 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44964 };
44965
44966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44968 if (SWIG_arg_fail(1)) SWIG_fail;
44969 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44970 if (SWIG_arg_fail(2)) SWIG_fail;
44971 {
44972 arg3 = (wxEdge)(SWIG_As_int(obj2));
44973 if (SWIG_arg_fail(3)) SWIG_fail;
44974 }
44975 if (obj3) {
44976 {
44977 arg4 = (int)(SWIG_As_int(obj3));
44978 if (SWIG_arg_fail(4)) SWIG_fail;
44979 }
44980 }
44981 {
44982 PyThreadState* __tstate = wxPyBeginAllowThreads();
44983 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44984
44985 wxPyEndAllowThreads(__tstate);
44986 if (PyErr_Occurred()) SWIG_fail;
44987 }
44988 Py_INCREF(Py_None); resultobj = Py_None;
44989 return resultobj;
44990 fail:
44991 return NULL;
44992 }
44993
44994
44995 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44996 PyObject *resultobj;
44997 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44998 wxWindow *arg2 = (wxWindow *) 0 ;
44999 wxEdge arg3 ;
45000 int arg4 ;
45001 PyObject * obj0 = 0 ;
45002 PyObject * obj1 = 0 ;
45003 PyObject * obj2 = 0 ;
45004 PyObject * obj3 = 0 ;
45005 char *kwnames[] = {
45006 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
45007 };
45008
45009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45011 if (SWIG_arg_fail(1)) SWIG_fail;
45012 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45013 if (SWIG_arg_fail(2)) SWIG_fail;
45014 {
45015 arg3 = (wxEdge)(SWIG_As_int(obj2));
45016 if (SWIG_arg_fail(3)) SWIG_fail;
45017 }
45018 {
45019 arg4 = (int)(SWIG_As_int(obj3));
45020 if (SWIG_arg_fail(4)) SWIG_fail;
45021 }
45022 {
45023 PyThreadState* __tstate = wxPyBeginAllowThreads();
45024 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
45025
45026 wxPyEndAllowThreads(__tstate);
45027 if (PyErr_Occurred()) SWIG_fail;
45028 }
45029 Py_INCREF(Py_None); resultobj = Py_None;
45030 return resultobj;
45031 fail:
45032 return NULL;
45033 }
45034
45035
45036 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
45037 PyObject *resultobj;
45038 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45039 int arg2 ;
45040 PyObject * obj0 = 0 ;
45041 PyObject * obj1 = 0 ;
45042 char *kwnames[] = {
45043 (char *) "self",(char *) "val", NULL
45044 };
45045
45046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
45047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45048 if (SWIG_arg_fail(1)) SWIG_fail;
45049 {
45050 arg2 = (int)(SWIG_As_int(obj1));
45051 if (SWIG_arg_fail(2)) SWIG_fail;
45052 }
45053 {
45054 PyThreadState* __tstate = wxPyBeginAllowThreads();
45055 (arg1)->Absolute(arg2);
45056
45057 wxPyEndAllowThreads(__tstate);
45058 if (PyErr_Occurred()) SWIG_fail;
45059 }
45060 Py_INCREF(Py_None); resultobj = Py_None;
45061 return resultobj;
45062 fail:
45063 return NULL;
45064 }
45065
45066
45067 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
45068 PyObject *resultobj;
45069 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45070 PyObject * obj0 = 0 ;
45071 char *kwnames[] = {
45072 (char *) "self", NULL
45073 };
45074
45075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
45076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45077 if (SWIG_arg_fail(1)) SWIG_fail;
45078 {
45079 PyThreadState* __tstate = wxPyBeginAllowThreads();
45080 (arg1)->Unconstrained();
45081
45082 wxPyEndAllowThreads(__tstate);
45083 if (PyErr_Occurred()) SWIG_fail;
45084 }
45085 Py_INCREF(Py_None); resultobj = Py_None;
45086 return resultobj;
45087 fail:
45088 return NULL;
45089 }
45090
45091
45092 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
45093 PyObject *resultobj;
45094 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45095 PyObject * obj0 = 0 ;
45096 char *kwnames[] = {
45097 (char *) "self", NULL
45098 };
45099
45100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
45101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45102 if (SWIG_arg_fail(1)) SWIG_fail;
45103 {
45104 PyThreadState* __tstate = wxPyBeginAllowThreads();
45105 (arg1)->AsIs();
45106
45107 wxPyEndAllowThreads(__tstate);
45108 if (PyErr_Occurred()) SWIG_fail;
45109 }
45110 Py_INCREF(Py_None); resultobj = Py_None;
45111 return resultobj;
45112 fail:
45113 return NULL;
45114 }
45115
45116
45117 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
45118 PyObject *resultobj;
45119 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45120 wxWindow *result;
45121 PyObject * obj0 = 0 ;
45122 char *kwnames[] = {
45123 (char *) "self", NULL
45124 };
45125
45126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
45127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45128 if (SWIG_arg_fail(1)) SWIG_fail;
45129 {
45130 PyThreadState* __tstate = wxPyBeginAllowThreads();
45131 result = (wxWindow *)(arg1)->GetOtherWindow();
45132
45133 wxPyEndAllowThreads(__tstate);
45134 if (PyErr_Occurred()) SWIG_fail;
45135 }
45136 {
45137 resultobj = wxPyMake_wxObject(result, 0);
45138 }
45139 return resultobj;
45140 fail:
45141 return NULL;
45142 }
45143
45144
45145 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45146 PyObject *resultobj;
45147 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45148 wxEdge result;
45149 PyObject * obj0 = 0 ;
45150 char *kwnames[] = {
45151 (char *) "self", NULL
45152 };
45153
45154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
45155 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45156 if (SWIG_arg_fail(1)) SWIG_fail;
45157 {
45158 PyThreadState* __tstate = wxPyBeginAllowThreads();
45159 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
45160
45161 wxPyEndAllowThreads(__tstate);
45162 if (PyErr_Occurred()) SWIG_fail;
45163 }
45164 resultobj = SWIG_From_int((result));
45165 return resultobj;
45166 fail:
45167 return NULL;
45168 }
45169
45170
45171 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45172 PyObject *resultobj;
45173 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45174 wxEdge arg2 ;
45175 PyObject * obj0 = 0 ;
45176 PyObject * obj1 = 0 ;
45177 char *kwnames[] = {
45178 (char *) "self",(char *) "which", NULL
45179 };
45180
45181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
45182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45183 if (SWIG_arg_fail(1)) SWIG_fail;
45184 {
45185 arg2 = (wxEdge)(SWIG_As_int(obj1));
45186 if (SWIG_arg_fail(2)) SWIG_fail;
45187 }
45188 {
45189 PyThreadState* __tstate = wxPyBeginAllowThreads();
45190 (arg1)->SetEdge((wxEdge )arg2);
45191
45192 wxPyEndAllowThreads(__tstate);
45193 if (PyErr_Occurred()) SWIG_fail;
45194 }
45195 Py_INCREF(Py_None); resultobj = Py_None;
45196 return resultobj;
45197 fail:
45198 return NULL;
45199 }
45200
45201
45202 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45203 PyObject *resultobj;
45204 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45205 int arg2 ;
45206 PyObject * obj0 = 0 ;
45207 PyObject * obj1 = 0 ;
45208 char *kwnames[] = {
45209 (char *) "self",(char *) "v", NULL
45210 };
45211
45212 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
45213 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45214 if (SWIG_arg_fail(1)) SWIG_fail;
45215 {
45216 arg2 = (int)(SWIG_As_int(obj1));
45217 if (SWIG_arg_fail(2)) SWIG_fail;
45218 }
45219 {
45220 PyThreadState* __tstate = wxPyBeginAllowThreads();
45221 (arg1)->SetValue(arg2);
45222
45223 wxPyEndAllowThreads(__tstate);
45224 if (PyErr_Occurred()) SWIG_fail;
45225 }
45226 Py_INCREF(Py_None); resultobj = Py_None;
45227 return resultobj;
45228 fail:
45229 return NULL;
45230 }
45231
45232
45233 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45234 PyObject *resultobj;
45235 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45236 int result;
45237 PyObject * obj0 = 0 ;
45238 char *kwnames[] = {
45239 (char *) "self", NULL
45240 };
45241
45242 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
45243 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45244 if (SWIG_arg_fail(1)) SWIG_fail;
45245 {
45246 PyThreadState* __tstate = wxPyBeginAllowThreads();
45247 result = (int)(arg1)->GetMargin();
45248
45249 wxPyEndAllowThreads(__tstate);
45250 if (PyErr_Occurred()) SWIG_fail;
45251 }
45252 {
45253 resultobj = SWIG_From_int((int)(result));
45254 }
45255 return resultobj;
45256 fail:
45257 return NULL;
45258 }
45259
45260
45261 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
45262 PyObject *resultobj;
45263 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45264 int arg2 ;
45265 PyObject * obj0 = 0 ;
45266 PyObject * obj1 = 0 ;
45267 char *kwnames[] = {
45268 (char *) "self",(char *) "m", NULL
45269 };
45270
45271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
45272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45273 if (SWIG_arg_fail(1)) SWIG_fail;
45274 {
45275 arg2 = (int)(SWIG_As_int(obj1));
45276 if (SWIG_arg_fail(2)) SWIG_fail;
45277 }
45278 {
45279 PyThreadState* __tstate = wxPyBeginAllowThreads();
45280 (arg1)->SetMargin(arg2);
45281
45282 wxPyEndAllowThreads(__tstate);
45283 if (PyErr_Occurred()) SWIG_fail;
45284 }
45285 Py_INCREF(Py_None); resultobj = Py_None;
45286 return resultobj;
45287 fail:
45288 return NULL;
45289 }
45290
45291
45292 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
45293 PyObject *resultobj;
45294 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45295 int result;
45296 PyObject * obj0 = 0 ;
45297 char *kwnames[] = {
45298 (char *) "self", NULL
45299 };
45300
45301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
45302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45303 if (SWIG_arg_fail(1)) SWIG_fail;
45304 {
45305 PyThreadState* __tstate = wxPyBeginAllowThreads();
45306 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
45307
45308 wxPyEndAllowThreads(__tstate);
45309 if (PyErr_Occurred()) SWIG_fail;
45310 }
45311 {
45312 resultobj = SWIG_From_int((int)(result));
45313 }
45314 return resultobj;
45315 fail:
45316 return NULL;
45317 }
45318
45319
45320 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
45321 PyObject *resultobj;
45322 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45323 int result;
45324 PyObject * obj0 = 0 ;
45325 char *kwnames[] = {
45326 (char *) "self", NULL
45327 };
45328
45329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
45330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45331 if (SWIG_arg_fail(1)) SWIG_fail;
45332 {
45333 PyThreadState* __tstate = wxPyBeginAllowThreads();
45334 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
45335
45336 wxPyEndAllowThreads(__tstate);
45337 if (PyErr_Occurred()) SWIG_fail;
45338 }
45339 {
45340 resultobj = SWIG_From_int((int)(result));
45341 }
45342 return resultobj;
45343 fail:
45344 return NULL;
45345 }
45346
45347
45348 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45349 PyObject *resultobj;
45350 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45351 int result;
45352 PyObject * obj0 = 0 ;
45353 char *kwnames[] = {
45354 (char *) "self", NULL
45355 };
45356
45357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
45358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45359 if (SWIG_arg_fail(1)) SWIG_fail;
45360 {
45361 PyThreadState* __tstate = wxPyBeginAllowThreads();
45362 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
45363
45364 wxPyEndAllowThreads(__tstate);
45365 if (PyErr_Occurred()) SWIG_fail;
45366 }
45367 {
45368 resultobj = SWIG_From_int((int)(result));
45369 }
45370 return resultobj;
45371 fail:
45372 return NULL;
45373 }
45374
45375
45376 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45377 PyObject *resultobj;
45378 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45379 bool result;
45380 PyObject * obj0 = 0 ;
45381 char *kwnames[] = {
45382 (char *) "self", NULL
45383 };
45384
45385 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
45386 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45387 if (SWIG_arg_fail(1)) SWIG_fail;
45388 {
45389 PyThreadState* __tstate = wxPyBeginAllowThreads();
45390 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
45391
45392 wxPyEndAllowThreads(__tstate);
45393 if (PyErr_Occurred()) SWIG_fail;
45394 }
45395 {
45396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45397 }
45398 return resultobj;
45399 fail:
45400 return NULL;
45401 }
45402
45403
45404 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
45405 PyObject *resultobj;
45406 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45407 bool arg2 ;
45408 PyObject * obj0 = 0 ;
45409 PyObject * obj1 = 0 ;
45410 char *kwnames[] = {
45411 (char *) "self",(char *) "d", NULL
45412 };
45413
45414 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
45415 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45416 if (SWIG_arg_fail(1)) SWIG_fail;
45417 {
45418 arg2 = (bool)(SWIG_As_bool(obj1));
45419 if (SWIG_arg_fail(2)) SWIG_fail;
45420 }
45421 {
45422 PyThreadState* __tstate = wxPyBeginAllowThreads();
45423 (arg1)->SetDone(arg2);
45424
45425 wxPyEndAllowThreads(__tstate);
45426 if (PyErr_Occurred()) SWIG_fail;
45427 }
45428 Py_INCREF(Py_None); resultobj = Py_None;
45429 return resultobj;
45430 fail:
45431 return NULL;
45432 }
45433
45434
45435 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45436 PyObject *resultobj;
45437 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45438 wxRelationship result;
45439 PyObject * obj0 = 0 ;
45440 char *kwnames[] = {
45441 (char *) "self", NULL
45442 };
45443
45444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
45445 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45446 if (SWIG_arg_fail(1)) SWIG_fail;
45447 {
45448 PyThreadState* __tstate = wxPyBeginAllowThreads();
45449 result = (wxRelationship)(arg1)->GetRelationship();
45450
45451 wxPyEndAllowThreads(__tstate);
45452 if (PyErr_Occurred()) SWIG_fail;
45453 }
45454 resultobj = SWIG_From_int((result));
45455 return resultobj;
45456 fail:
45457 return NULL;
45458 }
45459
45460
45461 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
45462 PyObject *resultobj;
45463 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45464 wxRelationship arg2 ;
45465 PyObject * obj0 = 0 ;
45466 PyObject * obj1 = 0 ;
45467 char *kwnames[] = {
45468 (char *) "self",(char *) "r", NULL
45469 };
45470
45471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
45472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45473 if (SWIG_arg_fail(1)) SWIG_fail;
45474 {
45475 arg2 = (wxRelationship)(SWIG_As_int(obj1));
45476 if (SWIG_arg_fail(2)) SWIG_fail;
45477 }
45478 {
45479 PyThreadState* __tstate = wxPyBeginAllowThreads();
45480 (arg1)->SetRelationship((wxRelationship )arg2);
45481
45482 wxPyEndAllowThreads(__tstate);
45483 if (PyErr_Occurred()) SWIG_fail;
45484 }
45485 Py_INCREF(Py_None); resultobj = Py_None;
45486 return resultobj;
45487 fail:
45488 return NULL;
45489 }
45490
45491
45492 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
45493 PyObject *resultobj;
45494 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45495 wxWindow *arg2 = (wxWindow *) 0 ;
45496 bool result;
45497 PyObject * obj0 = 0 ;
45498 PyObject * obj1 = 0 ;
45499 char *kwnames[] = {
45500 (char *) "self",(char *) "otherW", NULL
45501 };
45502
45503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
45504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45505 if (SWIG_arg_fail(1)) SWIG_fail;
45506 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45507 if (SWIG_arg_fail(2)) SWIG_fail;
45508 {
45509 PyThreadState* __tstate = wxPyBeginAllowThreads();
45510 result = (bool)(arg1)->ResetIfWin(arg2);
45511
45512 wxPyEndAllowThreads(__tstate);
45513 if (PyErr_Occurred()) SWIG_fail;
45514 }
45515 {
45516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45517 }
45518 return resultobj;
45519 fail:
45520 return NULL;
45521 }
45522
45523
45524 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
45525 PyObject *resultobj;
45526 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45527 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
45528 wxWindow *arg3 = (wxWindow *) 0 ;
45529 bool result;
45530 PyObject * obj0 = 0 ;
45531 PyObject * obj1 = 0 ;
45532 PyObject * obj2 = 0 ;
45533 char *kwnames[] = {
45534 (char *) "self",(char *) "constraints",(char *) "win", NULL
45535 };
45536
45537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
45538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45539 if (SWIG_arg_fail(1)) SWIG_fail;
45540 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45541 if (SWIG_arg_fail(2)) SWIG_fail;
45542 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45543 if (SWIG_arg_fail(3)) SWIG_fail;
45544 {
45545 PyThreadState* __tstate = wxPyBeginAllowThreads();
45546 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
45547
45548 wxPyEndAllowThreads(__tstate);
45549 if (PyErr_Occurred()) SWIG_fail;
45550 }
45551 {
45552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45553 }
45554 return resultobj;
45555 fail:
45556 return NULL;
45557 }
45558
45559
45560 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
45561 PyObject *resultobj;
45562 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
45563 wxEdge arg2 ;
45564 wxWindow *arg3 = (wxWindow *) 0 ;
45565 wxWindow *arg4 = (wxWindow *) 0 ;
45566 int result;
45567 PyObject * obj0 = 0 ;
45568 PyObject * obj1 = 0 ;
45569 PyObject * obj2 = 0 ;
45570 PyObject * obj3 = 0 ;
45571 char *kwnames[] = {
45572 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
45573 };
45574
45575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
45576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
45577 if (SWIG_arg_fail(1)) SWIG_fail;
45578 {
45579 arg2 = (wxEdge)(SWIG_As_int(obj1));
45580 if (SWIG_arg_fail(2)) SWIG_fail;
45581 }
45582 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45583 if (SWIG_arg_fail(3)) SWIG_fail;
45584 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45585 if (SWIG_arg_fail(4)) SWIG_fail;
45586 {
45587 PyThreadState* __tstate = wxPyBeginAllowThreads();
45588 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
45589
45590 wxPyEndAllowThreads(__tstate);
45591 if (PyErr_Occurred()) SWIG_fail;
45592 }
45593 {
45594 resultobj = SWIG_From_int((int)(result));
45595 }
45596 return resultobj;
45597 fail:
45598 return NULL;
45599 }
45600
45601
45602 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
45603 PyObject *obj;
45604 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45605 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
45606 Py_INCREF(obj);
45607 return Py_BuildValue((char *)"");
45608 }
45609 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
45610 PyObject *resultobj;
45611 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45612 wxIndividualLayoutConstraint *result;
45613 PyObject * obj0 = 0 ;
45614 char *kwnames[] = {
45615 (char *) "self", NULL
45616 };
45617
45618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45620 if (SWIG_arg_fail(1)) SWIG_fail;
45621 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45622
45623 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45624 return resultobj;
45625 fail:
45626 return NULL;
45627 }
45628
45629
45630 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45631 PyObject *resultobj;
45632 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45633 wxIndividualLayoutConstraint *result;
45634 PyObject * obj0 = 0 ;
45635 char *kwnames[] = {
45636 (char *) "self", NULL
45637 };
45638
45639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45641 if (SWIG_arg_fail(1)) SWIG_fail;
45642 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45643
45644 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45645 return resultobj;
45646 fail:
45647 return NULL;
45648 }
45649
45650
45651 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45652 PyObject *resultobj;
45653 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45654 wxIndividualLayoutConstraint *result;
45655 PyObject * obj0 = 0 ;
45656 char *kwnames[] = {
45657 (char *) "self", NULL
45658 };
45659
45660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45662 if (SWIG_arg_fail(1)) SWIG_fail;
45663 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45664
45665 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45666 return resultobj;
45667 fail:
45668 return NULL;
45669 }
45670
45671
45672 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45673 PyObject *resultobj;
45674 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45675 wxIndividualLayoutConstraint *result;
45676 PyObject * obj0 = 0 ;
45677 char *kwnames[] = {
45678 (char *) "self", NULL
45679 };
45680
45681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45683 if (SWIG_arg_fail(1)) SWIG_fail;
45684 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45685
45686 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45687 return resultobj;
45688 fail:
45689 return NULL;
45690 }
45691
45692
45693 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45694 PyObject *resultobj;
45695 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45696 wxIndividualLayoutConstraint *result;
45697 PyObject * obj0 = 0 ;
45698 char *kwnames[] = {
45699 (char *) "self", NULL
45700 };
45701
45702 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45703 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45704 if (SWIG_arg_fail(1)) SWIG_fail;
45705 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45706
45707 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45708 return resultobj;
45709 fail:
45710 return NULL;
45711 }
45712
45713
45714 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45715 PyObject *resultobj;
45716 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45717 wxIndividualLayoutConstraint *result;
45718 PyObject * obj0 = 0 ;
45719 char *kwnames[] = {
45720 (char *) "self", NULL
45721 };
45722
45723 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45725 if (SWIG_arg_fail(1)) SWIG_fail;
45726 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45727
45728 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45729 return resultobj;
45730 fail:
45731 return NULL;
45732 }
45733
45734
45735 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45736 PyObject *resultobj;
45737 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45738 wxIndividualLayoutConstraint *result;
45739 PyObject * obj0 = 0 ;
45740 char *kwnames[] = {
45741 (char *) "self", NULL
45742 };
45743
45744 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45745 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45746 if (SWIG_arg_fail(1)) SWIG_fail;
45747 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45748
45749 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45750 return resultobj;
45751 fail:
45752 return NULL;
45753 }
45754
45755
45756 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45757 PyObject *resultobj;
45758 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45759 wxIndividualLayoutConstraint *result;
45760 PyObject * obj0 = 0 ;
45761 char *kwnames[] = {
45762 (char *) "self", NULL
45763 };
45764
45765 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45766 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45767 if (SWIG_arg_fail(1)) SWIG_fail;
45768 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45769
45770 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45771 return resultobj;
45772 fail:
45773 return NULL;
45774 }
45775
45776
45777 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45778 PyObject *resultobj;
45779 wxLayoutConstraints *result;
45780 char *kwnames[] = {
45781 NULL
45782 };
45783
45784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45785 {
45786 PyThreadState* __tstate = wxPyBeginAllowThreads();
45787 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45788
45789 wxPyEndAllowThreads(__tstate);
45790 if (PyErr_Occurred()) SWIG_fail;
45791 }
45792 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45793 return resultobj;
45794 fail:
45795 return NULL;
45796 }
45797
45798
45799 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45800 PyObject *resultobj;
45801 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45802 wxWindow *arg2 = (wxWindow *) 0 ;
45803 int *arg3 = (int *) 0 ;
45804 bool result;
45805 int temp3 ;
45806 int res3 = 0 ;
45807 PyObject * obj0 = 0 ;
45808 PyObject * obj1 = 0 ;
45809 char *kwnames[] = {
45810 (char *) "self",(char *) "win", NULL
45811 };
45812
45813 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45816 if (SWIG_arg_fail(1)) SWIG_fail;
45817 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45818 if (SWIG_arg_fail(2)) SWIG_fail;
45819 {
45820 PyThreadState* __tstate = wxPyBeginAllowThreads();
45821 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45822
45823 wxPyEndAllowThreads(__tstate);
45824 if (PyErr_Occurred()) SWIG_fail;
45825 }
45826 {
45827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45828 }
45829 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45830 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45831 return resultobj;
45832 fail:
45833 return NULL;
45834 }
45835
45836
45837 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45838 PyObject *resultobj;
45839 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45840 bool result;
45841 PyObject * obj0 = 0 ;
45842 char *kwnames[] = {
45843 (char *) "self", NULL
45844 };
45845
45846 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45847 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45848 if (SWIG_arg_fail(1)) SWIG_fail;
45849 {
45850 PyThreadState* __tstate = wxPyBeginAllowThreads();
45851 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45852
45853 wxPyEndAllowThreads(__tstate);
45854 if (PyErr_Occurred()) SWIG_fail;
45855 }
45856 {
45857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45858 }
45859 return resultobj;
45860 fail:
45861 return NULL;
45862 }
45863
45864
45865 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45866 PyObject *obj;
45867 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45868 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45869 Py_INCREF(obj);
45870 return Py_BuildValue((char *)"");
45871 }
45872 static PyMethodDef SwigMethods[] = {
45873 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45874 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45875 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45878 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45881 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45886 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45891 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45895 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45899 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45912 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45927 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45940 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45960 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45967 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45971 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45981 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
46009 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
46028 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
46030 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
46038 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
46039 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
46051 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
46063 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
46067 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
46073 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
46083 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
46093 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
46100 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"Image_RGBValue_red_set", (PyCFunction) _wrap_Image_RGBValue_red_set, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"Image_RGBValue_red_get", (PyCFunction) _wrap_Image_RGBValue_red_get, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"Image_RGBValue_green_set", (PyCFunction) _wrap_Image_RGBValue_green_set, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"Image_RGBValue_green_get", (PyCFunction) _wrap_Image_RGBValue_green_get, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"Image_RGBValue_blue_set", (PyCFunction) _wrap_Image_RGBValue_blue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"Image_RGBValue_blue_get", (PyCFunction) _wrap_Image_RGBValue_blue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
46108 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"Image_HSVValue_hue_set", (PyCFunction) _wrap_Image_HSVValue_hue_set, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"Image_HSVValue_hue_get", (PyCFunction) _wrap_Image_HSVValue_hue_get, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"Image_HSVValue_saturation_set", (PyCFunction) _wrap_Image_HSVValue_saturation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"Image_HSVValue_saturation_get", (PyCFunction) _wrap_Image_HSVValue_saturation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"Image_HSVValue_value_set", (PyCFunction) _wrap_Image_HSVValue_value_set, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"Image_HSVValue_value_get", (PyCFunction) _wrap_Image_HSVValue_value_get, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
46116 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
46153 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
46193 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
46199 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
46201 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
46203 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
46205 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
46207 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
46209 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46210 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
46211 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
46213 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
46215 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
46217 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
46219 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
46221 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
46223 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
46237 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
46255 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
46258 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
46261 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46265 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
46273 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
46278 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
46284 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
46290 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
46292 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46336 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46344 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
46353 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
46360 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
46363 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
46364 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
46396 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46401 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
46406 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
46412 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
46414 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
46416 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
46419 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
46423 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
46426 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
46429 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
46431 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
46434 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
46436 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46438 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46441 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
46444 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
46448 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
46451 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
46453 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
46457 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46463 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
46474 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46475 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
46476 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
46479 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
46481 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
46485 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
46489 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46495 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
46500 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
46503 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
46506 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46509 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
46510 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
46516 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
46517 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46518 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46519 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46520 { (char *)"PyEvent__GetSelf", (PyCFunction) _wrap_PyEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
46522 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46525 { (char *)"PyCommandEvent__GetSelf", (PyCFunction) _wrap_PyCommandEvent__GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
46527 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
46531 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
46552 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46564 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46565 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46566 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46567 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46568 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
46569 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46570 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46571 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
46572 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
46573 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
46574 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
46575 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
46576 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46577 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
46578 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
46579 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
46580 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
46581 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
46582 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
46583 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
46584 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46585 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
46586 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46587 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
46588 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
46589 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
46590 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
46591 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
46592 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
46593 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46594 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
46595 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
46596 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46597 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
46598 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46599 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
46600 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
46601 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
46602 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
46603 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46604 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46605 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
46606 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
46607 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
46608 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46609 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46610 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
46611 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
46612 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46613 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46614 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
46615 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
46616 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
46617 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
46618 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46619 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46620 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
46621 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46622 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46623 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
46624 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46625 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46626 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
46627 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
46628 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46629 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
46630 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46631 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46632 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46633 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46634 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46635 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46636 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46637 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46638 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46639 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46640 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46641 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46642 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46643 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46644 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46645 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46646 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46647 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46648 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46649 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46650 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46651 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46652 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46653 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46654 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46655 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46656 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46657 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46658 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46659 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46660 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46661 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46662 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46663 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46664 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46665 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46666 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46667 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46668 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46669 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46670 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46671 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46672 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46673 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46674 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46675 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46676 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46677 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46678 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46679 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46680 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46681 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46682 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46683 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46684 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46685 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46686 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46687 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46688 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46689 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46690 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46691 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46692 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46693 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46694 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46695 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46696 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46697 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46698 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46699 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46700 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46701 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46702 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46703 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46704 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46705 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46706 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46707 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46708 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46709 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46710 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46711 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46712 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46713 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46714 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46715 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46716 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46717 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46718 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46719 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46720 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46721 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46722 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46723 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46724 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46725 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46726 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46727 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46728 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46729 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46730 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46731 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46732 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46733 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46734 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46735 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46736 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46737 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46738 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46739 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46740 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46741 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46742 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46743 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46744 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46745 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46746 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46747 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46748 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46749 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46750 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46751 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46752 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46753 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46754 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46755 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46756 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46757 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46758 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46759 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46760 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46761 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46762 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46763 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46764 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46765 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46766 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46767 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46768 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46769 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46770 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46771 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46772 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46773 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46774 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46775 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46776 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46777 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46778 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46779 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46780 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46781 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46782 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46783 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46784 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46785 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46786 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46787 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46788 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46789 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46790 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46791 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46792 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46793 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46794 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
46795 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46796 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46797 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46798 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46799 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46800 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46801 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46802 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46803 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46804 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46805 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46806 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46807 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46808 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46809 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46810 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46811 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46812 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46813 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46814 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46815 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46816 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
46817 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46818 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46819 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46820 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46821 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46822 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46823 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46824 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46825 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46826 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46827 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46828 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46829 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46830 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46831 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46832 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46833 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46834 { (char *)"GetTopLevelWindows", (PyCFunction) _wrap_GetTopLevelWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46835 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46836 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46837 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46838 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46839 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46840 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46841 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46842 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46843 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46844 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46845 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46846 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46847 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46848 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46849 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46850 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46851 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46852 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46853 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46854 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46855 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46856 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46857 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46858 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46859 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46860 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46861 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46862 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46863 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46864 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46865 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46866 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46867 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46868 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46869 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46870 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46871 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46872 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46873 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46874 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46875 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46876 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46877 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46878 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46879 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46880 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46881 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46882 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46883 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46884 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46885 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46886 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46887 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46888 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46889 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46890 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46891 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46892 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46893 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46894 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46895 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46896 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46897 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46898 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46899 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46900 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46901 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46902 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46903 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46904 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46905 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46906 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46907 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46908 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46909 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46910 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46911 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46912 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46913 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46914 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46915 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46916 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46917 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46918 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46919 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46920 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46921 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46922 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46923 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46924 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46925 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46926 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46927 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46928 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46929 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46930 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_GetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46931 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46932 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46933 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46934 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46935 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46936 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46937 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46938 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46939 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46940 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46941 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46942 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46943 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46944 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46945 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46946 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46947 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46948 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46949 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46950 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46951 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46952 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46953 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46954 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46955 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46956 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46957 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46958 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46959 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46960 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46961 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46962 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46963 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46964 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46965 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46966 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46967 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46968 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46969 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46970 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46971 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46972 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46973 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46974 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46975 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46976 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46977 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46978 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46979 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46980 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46981 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46982 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46983 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46984 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46985 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46986 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46987 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46988 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46989 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46990 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46991 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46992 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46993 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46994 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46995 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46996 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46997 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46998 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46999 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47000 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
47001 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
47002 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
47003 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
47004 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47005 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47006 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47007 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47008 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47009 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47010 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47011 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47012 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47013 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47014 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47015 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
47016 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
47017 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
47018 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47019 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
47020 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
47021 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47022 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47023 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47024 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47025 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
47026 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47027 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
47028 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47029 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
47030 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47031 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47032 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47033 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47034 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47035 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47036 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47037 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47038 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47039 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
47040 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
47041 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47042 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47043 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
47044 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
47045 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
47046 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
47047 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
47048 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47049 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47050 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
47051 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
47052 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
47053 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47054 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
47055 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47056 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
47057 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
47058 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
47059 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
47060 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
47061 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
47062 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47063 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
47064 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
47065 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
47066 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
47067 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
47068 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
47069 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
47070 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
47071 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
47072 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
47073 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
47074 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47075 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47076 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
47077 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
47078 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47079 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
47080 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
47081 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47082 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47083 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47084 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47085 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47086 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
47087 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
47088 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
47089 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
47090 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
47091 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47092 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47093 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
47094 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47095 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
47096 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47097 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
47098 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47099 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
47100 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
47101 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
47102 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
47103 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47104 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
47105 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
47106 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47107 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47108 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47109 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47110 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
47111 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
47112 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
47113 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
47114 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
47115 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47116 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47117 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47118 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
47119 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
47120 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47121 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47122 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47123 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47124 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
47125 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47126 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47127 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47128 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
47129 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
47130 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
47131 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
47132 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47133 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
47134 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
47135 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
47136 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47137 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47138 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
47139 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47140 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47141 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
47142 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
47143 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
47144 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
47145 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
47146 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47147 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47148 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
47149 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
47150 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
47151 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
47152 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47153 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47154 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
47155 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
47156 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
47157 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
47158 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
47159 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
47160 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
47161 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
47162 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
47163 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
47164 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
47165 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
47166 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
47167 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
47168 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
47169 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
47170 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
47171 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
47172 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
47173 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
47174 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
47175 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
47176 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47177 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47178 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47179 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47180 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
47181 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
47182 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
47183 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47184 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47185 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
47186 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47187 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
47188 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
47189 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
47190 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
47191 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
47192 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
47193 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
47194 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
47195 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
47196 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
47197 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
47198 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
47199 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
47200 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47201 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
47202 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
47203 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
47204 { NULL, NULL, 0, NULL }
47205 };
47206
47207
47208 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
47209
47210 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
47211 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
47212 }
47213 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
47214 return (void *)((wxSizer *) ((wxBoxSizer *) x));
47215 }
47216 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
47217 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
47218 }
47219 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
47220 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47221 }
47222 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
47223 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47224 }
47225 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
47226 return (void *)((wxSizer *) ((wxGridSizer *) x));
47227 }
47228 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
47229 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
47230 }
47231 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
47232 return (void *)((wxSizer *) ((wxPySizer *) x));
47233 }
47234 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
47235 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
47236 }
47237 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
47238 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47239 }
47240 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
47241 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
47242 }
47243 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
47244 return (void *)((wxEvent *) ((wxMenuEvent *) x));
47245 }
47246 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
47247 return (void *)((wxEvent *) ((wxCloseEvent *) x));
47248 }
47249 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
47250 return (void *)((wxEvent *) ((wxMouseEvent *) x));
47251 }
47252 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
47253 return (void *)((wxEvent *) ((wxEraseEvent *) x));
47254 }
47255 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
47256 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
47257 }
47258 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
47259 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
47260 }
47261 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
47262 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
47263 }
47264 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
47265 return (void *)((wxEvent *) ((wxPyEvent *) x));
47266 }
47267 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
47268 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
47269 }
47270 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
47271 return (void *)((wxEvent *) ((wxIdleEvent *) x));
47272 }
47273 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
47274 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
47275 }
47276 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
47277 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
47278 }
47279 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
47280 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
47281 }
47282 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
47283 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
47284 }
47285 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
47286 return (void *)((wxEvent *) ((wxActivateEvent *) x));
47287 }
47288 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
47289 return (void *)((wxEvent *) ((wxSizeEvent *) x));
47290 }
47291 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
47292 return (void *)((wxEvent *) ((wxMoveEvent *) x));
47293 }
47294 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
47295 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
47296 }
47297 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
47298 return (void *)((wxEvent *) ((wxPaintEvent *) x));
47299 }
47300 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
47301 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
47302 }
47303 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
47304 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
47305 }
47306 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
47307 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
47308 }
47309 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
47310 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
47311 }
47312 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
47313 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47314 }
47315 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
47316 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
47317 }
47318 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
47319 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
47320 }
47321 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
47322 return (void *)((wxEvent *) ((wxFocusEvent *) x));
47323 }
47324 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
47325 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
47326 }
47327 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
47328 return (void *)((wxEvent *) ((wxShowEvent *) x));
47329 }
47330 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
47331 return (void *)((wxEvent *) ((wxCommandEvent *) x));
47332 }
47333 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
47334 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
47335 }
47336 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
47337 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47338 }
47339 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
47340 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
47341 }
47342 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
47343 return (void *)((wxEvent *) ((wxKeyEvent *) x));
47344 }
47345 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
47346 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
47347 }
47348 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
47349 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
47350 }
47351 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
47352 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
47353 }
47354 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
47355 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
47356 }
47357 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
47358 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
47359 }
47360 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
47361 return (void *)((wxControl *) ((wxControlWithItems *) x));
47362 }
47363 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
47364 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
47365 }
47366 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
47367 return (void *)((wxEvtHandler *) ((wxWindow *) x));
47368 }
47369 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
47370 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47371 }
47372 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
47373 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
47374 }
47375 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
47376 return (void *)((wxEvtHandler *) ((wxValidator *) x));
47377 }
47378 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
47379 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
47380 }
47381 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
47382 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
47383 }
47384 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
47385 return (void *)((wxEvtHandler *) ((wxMenu *) x));
47386 }
47387 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
47388 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
47389 }
47390 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
47391 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
47392 }
47393 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
47394 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
47395 }
47396 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
47397 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
47398 }
47399 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
47400 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
47401 }
47402 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
47403 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47404 }
47405 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
47406 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
47407 }
47408 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
47409 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
47410 }
47411 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
47412 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47413 }
47414 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
47415 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47416 }
47417 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
47418 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
47419 }
47420 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
47421 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
47422 }
47423 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
47424 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
47425 }
47426 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
47427 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
47428 }
47429 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
47430 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
47431 }
47432 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
47433 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
47434 }
47435 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
47436 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
47437 }
47438 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
47439 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
47440 }
47441 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
47442 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
47443 }
47444 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
47445 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
47446 }
47447 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
47448 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
47449 }
47450 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
47451 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
47452 }
47453 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
47454 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
47455 }
47456 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
47457 return (void *)((wxObject *) ((wxSizerItem *) x));
47458 }
47459 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
47460 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
47461 }
47462 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
47463 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
47464 }
47465 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
47466 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
47467 }
47468 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
47469 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
47470 }
47471 static void *_p_wxSizerTo_p_wxObject(void *x) {
47472 return (void *)((wxObject *) ((wxSizer *) x));
47473 }
47474 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
47475 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
47476 }
47477 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
47478 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
47479 }
47480 static void *_p_wxEventTo_p_wxObject(void *x) {
47481 return (void *)((wxObject *) ((wxEvent *) x));
47482 }
47483 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
47484 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
47485 }
47486 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
47487 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
47488 }
47489 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
47490 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
47491 }
47492 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
47493 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
47494 }
47495 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
47496 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
47497 }
47498 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
47499 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
47500 }
47501 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
47502 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
47503 }
47504 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
47505 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
47506 }
47507 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
47508 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
47509 }
47510 static void *_p_wxControlTo_p_wxObject(void *x) {
47511 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
47512 }
47513 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
47514 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
47515 }
47516 static void *_p_wxFSFileTo_p_wxObject(void *x) {
47517 return (void *)((wxObject *) ((wxFSFile *) x));
47518 }
47519 static void *_p_wxPySizerTo_p_wxObject(void *x) {
47520 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
47521 }
47522 static void *_p_wxPyEventTo_p_wxObject(void *x) {
47523 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
47524 }
47525 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
47526 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
47527 }
47528 static void *_p_wxShowEventTo_p_wxObject(void *x) {
47529 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
47530 }
47531 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
47532 return (void *)((wxObject *) ((wxMenuItem *) x));
47533 }
47534 static void *_p_wxDateEventTo_p_wxObject(void *x) {
47535 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
47536 }
47537 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
47538 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
47539 }
47540 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
47541 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
47542 }
47543 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
47544 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
47545 }
47546 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
47547 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
47548 }
47549 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
47550 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
47551 }
47552 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
47553 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
47554 }
47555 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
47556 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
47557 }
47558 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
47559 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
47560 }
47561 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
47562 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
47563 }
47564 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
47565 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
47566 }
47567 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
47568 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
47569 }
47570 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
47571 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
47572 }
47573 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
47574 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
47575 }
47576 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
47577 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
47578 }
47579 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
47580 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
47581 }
47582 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
47583 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
47584 }
47585 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
47586 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
47587 }
47588 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
47589 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
47590 }
47591 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
47592 return (void *)((wxObject *) ((wxImageHandler *) x));
47593 }
47594 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
47595 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
47596 }
47597 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
47598 return (void *)((wxObject *) ((wxEvtHandler *) x));
47599 }
47600 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
47601 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
47602 }
47603 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
47604 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
47605 }
47606 static void *_p_wxImageTo_p_wxObject(void *x) {
47607 return (void *)((wxObject *) ((wxImage *) x));
47608 }
47609 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
47610 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
47611 }
47612 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
47613 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47614 }
47615 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
47616 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
47617 }
47618 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
47619 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
47620 }
47621 static void *_p_wxWindowTo_p_wxObject(void *x) {
47622 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
47623 }
47624 static void *_p_wxMenuTo_p_wxObject(void *x) {
47625 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
47626 }
47627 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
47628 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
47629 }
47630 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
47631 return (void *)((wxObject *) ((wxFileSystem *) x));
47632 }
47633 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
47634 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
47635 }
47636 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
47637 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
47638 }
47639 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47640 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47641 }
47642 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47643 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47644 }
47645 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47646 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47647 }
47648 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47649 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47650 }
47651 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47652 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47653 }
47654 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47655 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47656 }
47657 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47658 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47659 }
47660 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47661 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47662 }
47663 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47664 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47665 }
47666 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47667 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47668 }
47669 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47670 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47671 }
47672 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47673 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47674 }
47675 static void *_p_wxControlTo_p_wxWindow(void *x) {
47676 return (void *)((wxWindow *) ((wxControl *) x));
47677 }
47678 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47679 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47680 }
47681 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47682 return (void *)((wxWindow *) ((wxMenuBar *) x));
47683 }
47684 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
47685 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
47686 }
47687 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
47688 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47689 }
47690 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47691 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47692 }
47693 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47694 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47695 }
47696 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47697 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47698 }
47699 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47700 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47701 }
47702 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47703 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47704 }
47705 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47706 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47707 }
47708 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47709 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47710 }
47711 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47712 return (void *)((wxValidator *) ((wxPyValidator *) x));
47713 }
47714 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}};
47715 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}};
47716 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}};
47717 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}};
47718 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}};
47719 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}};
47720 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}};
47721 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}};
47722 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}};
47723 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}};
47724 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}};
47725 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}};
47726 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}};
47727 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}};
47728 static swig_type_info _swigt__p_buffer[] = {{"_p_buffer", 0, "buffer *", 0, 0, 0, 0},{"_p_buffer", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47729 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}};
47730 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}};
47731 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}};
47732 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}};
47733 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}};
47734 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}};
47735 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}};
47736 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}};
47737 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}};
47738 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}};
47739 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}};
47740 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}};
47741 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}};
47742 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}};
47743 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}};
47744 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}};
47745 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}};
47746 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}};
47747 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}};
47748 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}};
47749 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}};
47750 static swig_type_info _swigt__p_wxImage_HSVValue[] = {{"_p_wxImage_HSVValue", 0, "wxImage_HSVValue *", 0, 0, 0, 0},{"_p_wxImage_HSVValue", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47751 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}};
47752 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}};
47753 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}};
47754 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}};
47755 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}};
47756 static swig_type_info _swigt__p_wxImage_RGBValue[] = {{"_p_wxImage_RGBValue", 0, "wxImage_RGBValue *", 0, 0, 0, 0},{"_p_wxImage_RGBValue", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47757 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}};
47758 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}};
47759 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}};
47760 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}};
47761 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}};
47762 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}};
47763 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}};
47764 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}};
47765 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}};
47766 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}};
47767 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}};
47768 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}};
47769 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}};
47770 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}};
47771 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}};
47772 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}};
47773 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}};
47774 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}};
47775 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}};
47776 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}};
47777 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}};
47778 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}};
47779 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}};
47780 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}};
47781 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}};
47782 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}};
47783 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}};
47784 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}};
47785 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}};
47786 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}};
47787 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}};
47788 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}};
47789 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}};
47790 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}};
47791 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}};
47792 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}};
47793 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}};
47794 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}};
47795 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}};
47796 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}};
47797 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}};
47798 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}};
47799 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}};
47800 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}};
47801 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}};
47802 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}};
47803 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}};
47804 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}};
47805 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}};
47806 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}};
47807 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}};
47808 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}};
47809 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}};
47810 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}};
47811 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}};
47812 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}};
47813 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}};
47814 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}};
47815 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}};
47816 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}};
47817 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}};
47818 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}};
47819 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}};
47820 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}};
47821 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}};
47822 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}};
47823 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}};
47824 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}};
47825 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}};
47826 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}};
47827 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}};
47828 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}};
47829 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}};
47830 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}};
47831 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}};
47832 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}};
47833 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}};
47834 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}};
47835 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}};
47836 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}};
47837 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}};
47838 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}};
47839 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}};
47840 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}};
47841 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}};
47842 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}};
47843 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}};
47844
47845 static swig_type_info *swig_types_initial[] = {
47846 _swigt__p_wxLayoutConstraints,
47847 _swigt__p_wxRealPoint,
47848 _swigt__p_wxSizerItem,
47849 _swigt__p_wxGBSizerItem,
47850 _swigt__p_wxScrollEvent,
47851 _swigt__p_wxEventLoop,
47852 _swigt__p_wxIndividualLayoutConstraint,
47853 _swigt__p_wxSizer,
47854 _swigt__p_wxBoxSizer,
47855 _swigt__p_wxStaticBoxSizer,
47856 _swigt__p_wxGridBagSizer,
47857 _swigt__p_wxAcceleratorEntry,
47858 _swigt__p_wxUpdateUIEvent,
47859 _swigt__p_wxEvent,
47860 _swigt__p_buffer,
47861 _swigt__p_wxMenu,
47862 _swigt__p_wxGridSizer,
47863 _swigt__p_wxFlexGridSizer,
47864 _swigt__p_wxInitDialogEvent,
47865 _swigt__p_wxItemContainer,
47866 _swigt__p_wxNcPaintEvent,
47867 _swigt__p_wxPaintEvent,
47868 _swigt__p_wxSysColourChangedEvent,
47869 _swigt__p_wxMouseCaptureChangedEvent,
47870 _swigt__p_wxDisplayChangedEvent,
47871 _swigt__p_wxPaletteChangedEvent,
47872 _swigt__p_wxControl,
47873 _swigt__p_wxFont,
47874 _swigt__p_wxMenuBarBase,
47875 _swigt__p_wxSetCursorEvent,
47876 _swigt__p_wxFSFile,
47877 _swigt__p_wxCaret,
47878 _swigt__ptrdiff_t,
47879 _swigt__std__ptrdiff_t,
47880 _swigt__p_wxRegion,
47881 _swigt__p_wxPoint2D,
47882 _swigt__p_wxImage_HSVValue,
47883 _swigt__p_int,
47884 _swigt__p_wxSize,
47885 _swigt__p_wxDC,
47886 _swigt__p_wxPySizer,
47887 _swigt__p_wxVisualAttributes,
47888 _swigt__p_wxImage_RGBValue,
47889 _swigt__p_wxNotifyEvent,
47890 _swigt__p_wxPyEvent,
47891 _swigt__p_wxPropagationDisabler,
47892 _swigt__p_form_ops_t,
47893 _swigt__p_wxAppTraits,
47894 _swigt__p_wxArrayString,
47895 _swigt__p_wxShowEvent,
47896 _swigt__p_wxToolTip,
47897 _swigt__p_wxMoveEvent,
47898 _swigt__p_wxSizeEvent,
47899 _swigt__p_wxActivateEvent,
47900 _swigt__p_wxIconizeEvent,
47901 _swigt__p_wxMaximizeEvent,
47902 _swigt__p_wxQueryNewPaletteEvent,
47903 _swigt__p_wxWindowCreateEvent,
47904 _swigt__p_wxIdleEvent,
47905 _swigt__p_wxDateEvent,
47906 _swigt__p_wxMenuItem,
47907 _swigt__p_wxStaticBox,
47908 _swigt__p_long,
47909 _swigt__p_wxDuplexMode,
47910 _swigt__p_wxTIFFHandler,
47911 _swigt__p_wxXPMHandler,
47912 _swigt__p_wxPNMHandler,
47913 _swigt__p_wxJPEGHandler,
47914 _swigt__p_wxPCXHandler,
47915 _swigt__p_wxGIFHandler,
47916 _swigt__p_wxPNGHandler,
47917 _swigt__p_wxANIHandler,
47918 _swigt__p_wxMemoryFSHandler,
47919 _swigt__p_wxZipFSHandler,
47920 _swigt__p_wxInternetFSHandler,
47921 _swigt__p_wxPyFileSystemHandler,
47922 _swigt__p_wxEvtHandler,
47923 _swigt__p_wxCURHandler,
47924 _swigt__p_wxICOHandler,
47925 _swigt__p_wxBMPHandler,
47926 _swigt__p_wxImageHandler,
47927 _swigt__p_wxFileSystemHandler,
47928 _swigt__p_wxRect,
47929 _swigt__p_wxButton,
47930 _swigt__p_wxGBSpan,
47931 _swigt__p_wxPropagateOnce,
47932 _swigt__p_wxAcceleratorTable,
47933 _swigt__p_wxStdDialogButtonSizer,
47934 _swigt__p_char,
47935 _swigt__p_wxGBPosition,
47936 _swigt__p_wxImage,
47937 _swigt__p_wxFrame,
47938 _swigt__p_wxScrollWinEvent,
47939 _swigt__p_wxPaperSize,
47940 _swigt__p_wxImageHistogram,
47941 _swigt__p_wxPoint,
47942 _swigt__p_wxCursor,
47943 _swigt__p_wxObject,
47944 _swigt__p_wxInputStream,
47945 _swigt__p_wxOutputStream,
47946 _swigt__p_wxPyInputStream,
47947 _swigt__p_wxDateTime,
47948 _swigt__p_wxKeyEvent,
47949 _swigt__p_wxNavigationKeyEvent,
47950 _swigt__p_wxWindowDestroyEvent,
47951 _swigt__p_unsigned_long,
47952 _swigt__p_wxWindow,
47953 _swigt__p_wxMenuBar,
47954 _swigt__p_wxFileSystem,
47955 _swigt__p_wxBitmap,
47956 _swigt__unsigned_int,
47957 _swigt__p_unsigned_int,
47958 _swigt__p_wxMenuEvent,
47959 _swigt__p_wxContextMenuEvent,
47960 _swigt__p_unsigned_char,
47961 _swigt__p_wxMouseEvent,
47962 _swigt__p_wxEraseEvent,
47963 _swigt__p_wxCloseEvent,
47964 _swigt__p_wxPyApp,
47965 _swigt__p_wxCommandEvent,
47966 _swigt__p_wxPyCommandEvent,
47967 _swigt__p_wxPyDropTarget,
47968 _swigt__p_wxQuantize,
47969 _swigt__p_wxFocusEvent,
47970 _swigt__p_wxChildFocusEvent,
47971 _swigt__p_wxDropFilesEvent,
47972 _swigt__p_wxControlWithItems,
47973 _swigt__p_wxColour,
47974 _swigt__p_wxValidator,
47975 _swigt__p_wxPyValidator,
47976 0
47977 };
47978
47979
47980 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47981
47982 static swig_const_info swig_const_table[] = {
47983 {0, 0, 0, 0.0, 0, 0}};
47984
47985 #ifdef __cplusplus
47986 }
47987 #endif
47988
47989
47990 #ifdef __cplusplus
47991 extern "C" {
47992 #endif
47993
47994 /* Python-specific SWIG API */
47995 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47996 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47997 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47998
47999 /* -----------------------------------------------------------------------------
48000 * global variable support code.
48001 * ----------------------------------------------------------------------------- */
48002
48003 typedef struct swig_globalvar {
48004 char *name; /* Name of global variable */
48005 PyObject *(*get_attr)(); /* Return the current value */
48006 int (*set_attr)(PyObject *); /* Set the value */
48007 struct swig_globalvar *next;
48008 } swig_globalvar;
48009
48010 typedef struct swig_varlinkobject {
48011 PyObject_HEAD
48012 swig_globalvar *vars;
48013 } swig_varlinkobject;
48014
48015 static PyObject *
48016 swig_varlink_repr(swig_varlinkobject *v) {
48017 v = v;
48018 return PyString_FromString("<Swig global variables>");
48019 }
48020
48021 static int
48022 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
48023 swig_globalvar *var;
48024 flags = flags;
48025 fprintf(fp,"Swig global variables { ");
48026 for (var = v->vars; var; var=var->next) {
48027 fprintf(fp,"%s", var->name);
48028 if (var->next) fprintf(fp,", ");
48029 }
48030 fprintf(fp," }\n");
48031 return 0;
48032 }
48033
48034 static PyObject *
48035 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
48036 swig_globalvar *var = v->vars;
48037 while (var) {
48038 if (strcmp(var->name,n) == 0) {
48039 return (*var->get_attr)();
48040 }
48041 var = var->next;
48042 }
48043 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
48044 return NULL;
48045 }
48046
48047 static int
48048 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
48049 swig_globalvar *var = v->vars;
48050 while (var) {
48051 if (strcmp(var->name,n) == 0) {
48052 return (*var->set_attr)(p);
48053 }
48054 var = var->next;
48055 }
48056 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
48057 return 1;
48058 }
48059
48060 static PyTypeObject varlinktype = {
48061 PyObject_HEAD_INIT(0)
48062 0, /* Number of items in variable part (ob_size) */
48063 (char *)"swigvarlink", /* Type name (tp_name) */
48064 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
48065 0, /* Itemsize (tp_itemsize) */
48066 0, /* Deallocator (tp_dealloc) */
48067 (printfunc) swig_varlink_print, /* Print (tp_print) */
48068 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
48069 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
48070 0, /* tp_compare */
48071 (reprfunc) swig_varlink_repr, /* tp_repr */
48072 0, /* tp_as_number */
48073 0, /* tp_as_sequence */
48074 0, /* tp_as_mapping */
48075 0, /* tp_hash */
48076 0, /* tp_call */
48077 0, /* tp_str */
48078 0, /* tp_getattro */
48079 0, /* tp_setattro */
48080 0, /* tp_as_buffer */
48081 0, /* tp_flags */
48082 0, /* tp_doc */
48083 #if PY_VERSION_HEX >= 0x02000000
48084 0, /* tp_traverse */
48085 0, /* tp_clear */
48086 #endif
48087 #if PY_VERSION_HEX >= 0x02010000
48088 0, /* tp_richcompare */
48089 0, /* tp_weaklistoffset */
48090 #endif
48091 #if PY_VERSION_HEX >= 0x02020000
48092 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
48093 #endif
48094 #if PY_VERSION_HEX >= 0x02030000
48095 0, /* tp_del */
48096 #endif
48097 #ifdef COUNT_ALLOCS
48098 0,0,0,0 /* tp_alloc -> tp_next */
48099 #endif
48100 };
48101
48102 /* Create a variable linking object for use later */
48103 static PyObject *
48104 SWIG_Python_newvarlink(void) {
48105 swig_varlinkobject *result = 0;
48106 result = PyMem_NEW(swig_varlinkobject,1);
48107 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
48108 result->ob_type = &varlinktype;
48109 result->vars = 0;
48110 result->ob_refcnt = 0;
48111 Py_XINCREF((PyObject *) result);
48112 return ((PyObject*) result);
48113 }
48114
48115 static void
48116 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
48117 swig_varlinkobject *v;
48118 swig_globalvar *gv;
48119 v= (swig_varlinkobject *) p;
48120 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
48121 gv->name = (char *) malloc(strlen(name)+1);
48122 strcpy(gv->name,name);
48123 gv->get_attr = get_attr;
48124 gv->set_attr = set_attr;
48125 gv->next = v->vars;
48126 v->vars = gv;
48127 }
48128
48129 /* -----------------------------------------------------------------------------
48130 * constants/methods manipulation
48131 * ----------------------------------------------------------------------------- */
48132
48133 /* Install Constants */
48134 static void
48135 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
48136 PyObject *obj = 0;
48137 size_t i;
48138 for (i = 0; constants[i].type; i++) {
48139 switch(constants[i].type) {
48140 case SWIG_PY_INT:
48141 obj = PyInt_FromLong(constants[i].lvalue);
48142 break;
48143 case SWIG_PY_FLOAT:
48144 obj = PyFloat_FromDouble(constants[i].dvalue);
48145 break;
48146 case SWIG_PY_STRING:
48147 if (constants[i].pvalue) {
48148 obj = PyString_FromString((char *) constants[i].pvalue);
48149 } else {
48150 Py_INCREF(Py_None);
48151 obj = Py_None;
48152 }
48153 break;
48154 case SWIG_PY_POINTER:
48155 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
48156 break;
48157 case SWIG_PY_BINARY:
48158 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
48159 break;
48160 default:
48161 obj = 0;
48162 break;
48163 }
48164 if (obj) {
48165 PyDict_SetItemString(d,constants[i].name,obj);
48166 Py_DECREF(obj);
48167 }
48168 }
48169 }
48170
48171 /* -----------------------------------------------------------------------------*/
48172 /* Fix SwigMethods to carry the callback ptrs when needed */
48173 /* -----------------------------------------------------------------------------*/
48174
48175 static void
48176 SWIG_Python_FixMethods(PyMethodDef *methods,
48177 swig_const_info *const_table,
48178 swig_type_info **types,
48179 swig_type_info **types_initial) {
48180 size_t i;
48181 for (i = 0; methods[i].ml_name; ++i) {
48182 char *c = methods[i].ml_doc;
48183 if (c && (c = strstr(c, "swig_ptr: "))) {
48184 int j;
48185 swig_const_info *ci = 0;
48186 char *name = c + 10;
48187 for (j = 0; const_table[j].type; j++) {
48188 if (strncmp(const_table[j].name, name,
48189 strlen(const_table[j].name)) == 0) {
48190 ci = &(const_table[j]);
48191 break;
48192 }
48193 }
48194 if (ci) {
48195 size_t shift = (ci->ptype) - types;
48196 swig_type_info *ty = types_initial[shift];
48197 size_t ldoc = (c - methods[i].ml_doc);
48198 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
48199 char *ndoc = (char*)malloc(ldoc + lptr + 10);
48200 char *buff = ndoc;
48201 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
48202 strncpy(buff, methods[i].ml_doc, ldoc);
48203 buff += ldoc;
48204 strncpy(buff, "swig_ptr: ", 10);
48205 buff += 10;
48206 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
48207 methods[i].ml_doc = ndoc;
48208 }
48209 }
48210 }
48211 }
48212
48213 /* -----------------------------------------------------------------------------*
48214 * Initialize type list
48215 * -----------------------------------------------------------------------------*/
48216
48217 #if PY_MAJOR_VERSION < 2
48218 /* PyModule_AddObject function was introduced in Python 2.0. The following function
48219 is copied out of Python/modsupport.c in python version 2.3.4 */
48220 static int
48221 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
48222 {
48223 PyObject *dict;
48224 if (!PyModule_Check(m)) {
48225 PyErr_SetString(PyExc_TypeError,
48226 "PyModule_AddObject() needs module as first arg");
48227 return -1;
48228 }
48229 if (!o) {
48230 PyErr_SetString(PyExc_TypeError,
48231 "PyModule_AddObject() needs non-NULL value");
48232 return -1;
48233 }
48234
48235 dict = PyModule_GetDict(m);
48236 if (dict == NULL) {
48237 /* Internal error -- modules must have a dict! */
48238 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
48239 PyModule_GetName(m));
48240 return -1;
48241 }
48242 if (PyDict_SetItemString(dict, name, o))
48243 return -1;
48244 Py_DECREF(o);
48245 return 0;
48246 }
48247 #endif
48248
48249 static swig_type_info **
48250 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
48251 static PyMethodDef swig_empty_runtime_method_table[] = {
48252 {
48253 NULL, NULL, 0, NULL
48254 }
48255 };/* Sentinel */
48256
48257 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
48258 swig_empty_runtime_method_table);
48259 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
48260 if (pointer && module) {
48261 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
48262 }
48263 return type_list_handle;
48264 }
48265
48266 static swig_type_info **
48267 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
48268 swig_type_info **type_pointer;
48269
48270 /* first check if module already created */
48271 type_pointer = SWIG_Python_GetTypeListHandle();
48272 if (type_pointer) {
48273 return type_pointer;
48274 } else {
48275 /* create a new module and variable */
48276 return SWIG_Python_SetTypeListHandle(type_list_handle);
48277 }
48278 }
48279
48280 #ifdef __cplusplus
48281 }
48282 #endif
48283
48284 /* -----------------------------------------------------------------------------*
48285 * Partial Init method
48286 * -----------------------------------------------------------------------------*/
48287
48288 #ifdef SWIG_LINK_RUNTIME
48289 #ifdef __cplusplus
48290 extern "C"
48291 #endif
48292 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
48293 #endif
48294
48295 #ifdef __cplusplus
48296 extern "C"
48297 #endif
48298 SWIGEXPORT(void) SWIG_init(void) {
48299 static PyObject *SWIG_globals = 0;
48300 static int typeinit = 0;
48301 PyObject *m, *d;
48302 int i;
48303 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
48304
48305 /* Fix SwigMethods to carry the callback ptrs when needed */
48306 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
48307
48308 m = Py_InitModule((char *) SWIG_name, SwigMethods);
48309 d = PyModule_GetDict(m);
48310
48311 if (!typeinit) {
48312 #ifdef SWIG_LINK_RUNTIME
48313 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
48314 #else
48315 # ifndef SWIG_STATIC_RUNTIME
48316 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
48317 # endif
48318 #endif
48319 for (i = 0; swig_types_initial[i]; i++) {
48320 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
48321 }
48322 typeinit = 1;
48323 }
48324 SWIG_InstallConstants(d,swig_const_table);
48325
48326
48327 #ifndef wxPyUSE_EXPORT
48328 // Make our API structure a CObject so other modules can import it
48329 // from this module.
48330 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
48331 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
48332 Py_XDECREF(cobj);
48333 #endif
48334
48335 {
48336 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
48337 }
48338 {
48339 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
48340 }
48341 {
48342 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
48343 }
48344 {
48345 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
48346 }
48347 {
48348 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
48349 }
48350 {
48351 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
48352 }
48353 {
48354 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
48355 }
48356 {
48357 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
48358 }
48359 {
48360 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
48361 }
48362 {
48363 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
48364 }
48365 {
48366 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
48367 }
48368 {
48369 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
48370 }
48371 {
48372 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int((int)(wxDEFAULT_CONTROL_BORDER)));
48373 }
48374 {
48375 PyDict_SetItemString(d,"DEFAULT_STATUSBAR_STYLE", SWIG_From_int((int)(wxDEFAULT_STATUSBAR_STYLE)));
48376 }
48377 {
48378 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
48379 }
48380 {
48381 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
48382 }
48383 {
48384 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
48385 }
48386 {
48387 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
48388 }
48389 {
48390 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
48391 }
48392 {
48393 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
48394 }
48395 {
48396 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
48397 }
48398 {
48399 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
48400 }
48401 {
48402 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
48403 }
48404 {
48405 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
48406 }
48407 {
48408 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
48409 }
48410 {
48411 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
48412 }
48413 {
48414 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
48415 }
48416 {
48417 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
48418 }
48419 {
48420 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
48421 }
48422 {
48423 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
48424 }
48425 {
48426 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
48427 }
48428 {
48429 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
48430 }
48431 {
48432 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
48433 }
48434 {
48435 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
48436 }
48437 {
48438 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
48439 }
48440 {
48441 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
48442 }
48443 {
48444 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
48445 }
48446 {
48447 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
48448 }
48449 {
48450 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
48451 }
48452 {
48453 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
48454 }
48455 {
48456 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
48457 }
48458 {
48459 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
48460 }
48461 {
48462 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
48463 }
48464 {
48465 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
48466 }
48467 {
48468 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
48469 }
48470 {
48471 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
48472 }
48473 {
48474 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
48475 }
48476 {
48477 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
48478 }
48479 {
48480 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
48481 }
48482 {
48483 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
48484 }
48485 {
48486 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
48487 }
48488 {
48489 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
48490 }
48491 {
48492 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
48493 }
48494 {
48495 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
48496 }
48497 {
48498 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
48499 }
48500 {
48501 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
48502 }
48503 {
48504 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
48505 }
48506 {
48507 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
48508 }
48509 {
48510 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
48511 }
48512 {
48513 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
48514 }
48515 {
48516 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
48517 }
48518 {
48519 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
48520 }
48521 {
48522 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
48523 }
48524 {
48525 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
48526 }
48527 {
48528 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
48529 }
48530 {
48531 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
48532 }
48533 {
48534 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
48535 }
48536 {
48537 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
48538 }
48539 {
48540 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
48541 }
48542 {
48543 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
48544 }
48545 {
48546 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
48547 }
48548 {
48549 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
48550 }
48551 {
48552 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
48553 }
48554 {
48555 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
48556 }
48557 {
48558 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
48559 }
48560 {
48561 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
48562 }
48563 {
48564 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
48565 }
48566 {
48567 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
48568 }
48569 {
48570 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
48571 }
48572 {
48573 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
48574 }
48575 {
48576 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
48577 }
48578 {
48579 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
48580 }
48581 {
48582 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
48583 }
48584 {
48585 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
48586 }
48587 {
48588 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
48589 }
48590 {
48591 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
48592 }
48593 {
48594 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
48595 }
48596 {
48597 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
48598 }
48599 {
48600 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
48601 }
48602 {
48603 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
48604 }
48605 {
48606 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
48607 }
48608 {
48609 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
48610 }
48611 {
48612 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
48613 }
48614 {
48615 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
48616 }
48617 {
48618 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
48619 }
48620 {
48621 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
48622 }
48623 {
48624 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
48625 }
48626 {
48627 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
48628 }
48629 {
48630 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
48631 }
48632 {
48633 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
48634 }
48635 {
48636 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
48637 }
48638 {
48639 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
48640 }
48641 {
48642 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
48643 }
48644 {
48645 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
48646 }
48647 {
48648 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
48649 }
48650 {
48651 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
48652 }
48653 {
48654 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
48655 }
48656 {
48657 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
48658 }
48659 {
48660 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
48661 }
48662 {
48663 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
48664 }
48665 {
48666 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
48667 }
48668 {
48669 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
48670 }
48671 {
48672 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
48673 }
48674 {
48675 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
48676 }
48677 {
48678 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
48679 }
48680 {
48681 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
48682 }
48683 {
48684 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
48685 }
48686 {
48687 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
48688 }
48689 {
48690 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
48691 }
48692 {
48693 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
48694 }
48695 {
48696 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
48697 }
48698 {
48699 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
48700 }
48701 {
48702 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48703 }
48704 {
48705 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48706 }
48707 {
48708 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48709 }
48710 {
48711 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48712 }
48713 {
48714 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48715 }
48716 {
48717 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48718 }
48719 {
48720 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48721 }
48722 {
48723 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48724 }
48725 {
48726 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48727 }
48728 {
48729 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48730 }
48731 {
48732 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48733 }
48734 {
48735 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48736 }
48737 {
48738 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48739 }
48740 {
48741 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48742 }
48743 {
48744 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48745 }
48746 {
48747 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48748 }
48749 {
48750 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48751 }
48752 {
48753 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48754 }
48755 {
48756 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48757 }
48758 {
48759 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48760 }
48761 {
48762 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48763 }
48764 {
48765 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48766 }
48767 {
48768 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48769 }
48770 {
48771 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48772 }
48773 {
48774 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48775 }
48776 {
48777 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48778 }
48779 {
48780 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48781 }
48782 {
48783 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48784 }
48785 {
48786 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48787 }
48788 {
48789 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48790 }
48791 {
48792 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48793 }
48794 {
48795 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48796 }
48797 {
48798 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48799 }
48800 {
48801 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48802 }
48803 {
48804 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48805 }
48806 {
48807 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48808 }
48809 {
48810 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48811 }
48812 {
48813 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48814 }
48815 {
48816 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48817 }
48818 {
48819 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48820 }
48821 {
48822 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48823 }
48824 {
48825 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48826 }
48827 {
48828 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48829 }
48830 {
48831 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48832 }
48833 {
48834 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48835 }
48836 {
48837 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48838 }
48839 {
48840 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48841 }
48842 {
48843 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48844 }
48845 {
48846 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48847 }
48848 {
48849 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48850 }
48851 {
48852 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48853 }
48854 {
48855 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48856 }
48857 {
48858 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48859 }
48860 {
48861 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48862 }
48863 {
48864 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48865 }
48866 {
48867 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48868 }
48869 {
48870 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48871 }
48872 {
48873 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48874 }
48875 {
48876 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48877 }
48878 {
48879 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48880 }
48881 {
48882 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48883 }
48884 {
48885 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48886 }
48887 {
48888 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48889 }
48890 {
48891 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48892 }
48893 {
48894 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48895 }
48896 {
48897 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48898 }
48899 {
48900 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48901 }
48902 {
48903 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48904 }
48905 {
48906 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48907 }
48908 {
48909 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48910 }
48911 {
48912 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48913 }
48914 {
48915 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48916 }
48917 {
48918 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48919 }
48920 {
48921 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48922 }
48923 {
48924 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48925 }
48926 {
48927 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48928 }
48929 {
48930 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48931 }
48932 {
48933 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48934 }
48935 {
48936 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48937 }
48938 {
48939 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48940 }
48941 {
48942 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48943 }
48944 {
48945 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48946 }
48947 {
48948 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48949 }
48950 {
48951 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48952 }
48953 {
48954 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48955 }
48956 {
48957 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48958 }
48959 {
48960 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48961 }
48962 {
48963 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48964 }
48965 {
48966 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48967 }
48968 {
48969 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48970 }
48971 {
48972 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48973 }
48974 {
48975 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48976 }
48977 {
48978 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48979 }
48980 {
48981 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48982 }
48983 {
48984 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48985 }
48986 {
48987 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48988 }
48989 {
48990 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48991 }
48992 {
48993 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48994 }
48995 {
48996 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48997 }
48998 {
48999 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
49000 }
49001 {
49002 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
49003 }
49004 {
49005 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
49006 }
49007 {
49008 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
49009 }
49010 {
49011 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
49012 }
49013 {
49014 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
49015 }
49016 {
49017 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
49018 }
49019 {
49020 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
49021 }
49022 {
49023 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
49024 }
49025 {
49026 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
49027 }
49028 {
49029 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
49030 }
49031 {
49032 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
49033 }
49034 {
49035 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
49036 }
49037 {
49038 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
49039 }
49040 {
49041 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
49042 }
49043 {
49044 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
49045 }
49046 {
49047 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
49048 }
49049 {
49050 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
49051 }
49052 {
49053 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
49054 }
49055 {
49056 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
49057 }
49058 {
49059 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
49060 }
49061 {
49062 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
49063 }
49064 {
49065 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
49066 }
49067 {
49068 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
49069 }
49070 {
49071 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
49072 }
49073 {
49074 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
49075 }
49076 {
49077 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
49078 }
49079 {
49080 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
49081 }
49082 {
49083 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
49084 }
49085 {
49086 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
49087 }
49088 {
49089 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
49090 }
49091 {
49092 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
49093 }
49094 {
49095 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
49096 }
49097 {
49098 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
49099 }
49100 {
49101 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
49102 }
49103 {
49104 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
49105 }
49106 {
49107 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
49108 }
49109 {
49110 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
49111 }
49112 {
49113 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
49114 }
49115 {
49116 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
49117 }
49118 {
49119 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
49120 }
49121 {
49122 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
49123 }
49124 {
49125 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
49126 }
49127 {
49128 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
49129 }
49130 {
49131 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
49132 }
49133 {
49134 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
49135 }
49136 {
49137 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
49138 }
49139 {
49140 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
49141 }
49142 {
49143 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
49144 }
49145 {
49146 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
49147 }
49148 {
49149 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
49150 }
49151 {
49152 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
49153 }
49154 {
49155 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
49156 }
49157 {
49158 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
49159 }
49160 {
49161 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
49162 }
49163 {
49164 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
49165 }
49166 {
49167 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
49168 }
49169 {
49170 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
49171 }
49172 {
49173 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
49174 }
49175 {
49176 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
49177 }
49178 {
49179 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
49180 }
49181 {
49182 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
49183 }
49184 {
49185 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
49186 }
49187 {
49188 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
49189 }
49190 {
49191 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
49192 }
49193 {
49194 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
49195 }
49196 {
49197 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
49198 }
49199 {
49200 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
49201 }
49202 {
49203 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
49204 }
49205 {
49206 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
49207 }
49208 {
49209 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
49210 }
49211 {
49212 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
49213 }
49214 {
49215 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
49216 }
49217 {
49218 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
49219 }
49220 {
49221 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
49222 }
49223 {
49224 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
49225 }
49226 {
49227 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
49228 }
49229 {
49230 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
49231 }
49232 {
49233 PyDict_SetItemString(d,"STIPPLE_MASK", SWIG_From_int((int)(wxSTIPPLE_MASK)));
49234 }
49235 {
49236 PyDict_SetItemString(d,"STIPPLE_MASK_OPAQUE", SWIG_From_int((int)(wxSTIPPLE_MASK_OPAQUE)));
49237 }
49238 {
49239 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
49240 }
49241 {
49242 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
49243 }
49244 {
49245 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
49246 }
49247 {
49248 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
49249 }
49250 {
49251 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
49252 }
49253 {
49254 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
49255 }
49256 {
49257 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
49258 }
49259 {
49260 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
49261 }
49262 {
49263 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
49264 }
49265 {
49266 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
49267 }
49268 {
49269 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
49270 }
49271 {
49272 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
49273 }
49274 {
49275 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
49276 }
49277 {
49278 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
49279 }
49280 {
49281 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
49282 }
49283 {
49284 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
49285 }
49286 {
49287 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
49288 }
49289 {
49290 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
49291 }
49292 {
49293 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
49294 }
49295 {
49296 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
49297 }
49298 {
49299 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
49300 }
49301 {
49302 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
49303 }
49304 {
49305 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
49306 }
49307 {
49308 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
49309 }
49310 {
49311 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
49312 }
49313 {
49314 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
49315 }
49316 {
49317 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
49318 }
49319 {
49320 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
49321 }
49322 {
49323 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
49324 }
49325 {
49326 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
49327 }
49328 {
49329 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
49330 }
49331 {
49332 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
49333 }
49334 {
49335 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
49336 }
49337 {
49338 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
49339 }
49340 {
49341 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
49342 }
49343 {
49344 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
49345 }
49346 {
49347 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
49348 }
49349 {
49350 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
49351 }
49352 {
49353 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
49354 }
49355 {
49356 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
49357 }
49358 {
49359 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
49360 }
49361 {
49362 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
49363 }
49364 {
49365 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
49366 }
49367 {
49368 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
49369 }
49370 {
49371 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
49372 }
49373 {
49374 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
49375 }
49376 {
49377 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
49378 }
49379 {
49380 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
49381 }
49382 {
49383 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
49384 }
49385 {
49386 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
49387 }
49388 {
49389 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
49390 }
49391 {
49392 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
49393 }
49394 {
49395 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
49396 }
49397 {
49398 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
49399 }
49400 {
49401 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
49402 }
49403 {
49404 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
49405 }
49406 {
49407 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
49408 }
49409 {
49410 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
49411 }
49412 {
49413 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
49414 }
49415 {
49416 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
49417 }
49418 {
49419 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
49420 }
49421 {
49422 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
49423 }
49424 {
49425 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
49426 }
49427 {
49428 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
49429 }
49430 {
49431 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
49432 }
49433 {
49434 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
49435 }
49436 {
49437 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
49438 }
49439 {
49440 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
49441 }
49442 {
49443 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
49444 }
49445 {
49446 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
49447 }
49448 {
49449 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
49450 }
49451 {
49452 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
49453 }
49454 {
49455 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
49456 }
49457 {
49458 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
49459 }
49460 {
49461 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
49462 }
49463 {
49464 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
49465 }
49466 {
49467 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
49468 }
49469 {
49470 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
49471 }
49472 {
49473 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
49474 }
49475 {
49476 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
49477 }
49478 {
49479 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
49480 }
49481 {
49482 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
49483 }
49484 {
49485 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
49486 }
49487 {
49488 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
49489 }
49490 {
49491 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
49492 }
49493 {
49494 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
49495 }
49496 {
49497 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
49498 }
49499 {
49500 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
49501 }
49502 {
49503 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
49504 }
49505 {
49506 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
49507 }
49508 {
49509 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
49510 }
49511 {
49512 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
49513 }
49514 {
49515 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
49516 }
49517 {
49518 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
49519 }
49520 {
49521 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
49522 }
49523 {
49524 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
49525 }
49526 {
49527 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
49528 }
49529 {
49530 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
49531 }
49532 {
49533 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
49534 }
49535 {
49536 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
49537 }
49538 {
49539 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
49540 }
49541 {
49542 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
49543 }
49544 {
49545 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
49546 }
49547 {
49548 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
49549 }
49550 {
49551 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
49552 }
49553 {
49554 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
49555 }
49556 {
49557 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
49558 }
49559 {
49560 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
49561 }
49562 {
49563 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
49564 }
49565 {
49566 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
49567 }
49568 {
49569 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
49570 }
49571 {
49572 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
49573 }
49574 {
49575 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
49576 }
49577 {
49578 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
49579 }
49580 {
49581 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
49582 }
49583 {
49584 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
49585 }
49586 {
49587 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
49588 }
49589 {
49590 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
49591 }
49592 {
49593 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
49594 }
49595 {
49596 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
49597 }
49598 {
49599 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
49600 }
49601 {
49602 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
49603 }
49604 {
49605 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
49606 }
49607 {
49608 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
49609 }
49610 {
49611 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
49612 }
49613 {
49614 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
49615 }
49616 {
49617 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
49618 }
49619 {
49620 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
49621 }
49622 {
49623 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
49624 }
49625 {
49626 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
49627 }
49628 {
49629 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
49630 }
49631 {
49632 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
49633 }
49634 {
49635 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
49636 }
49637 {
49638 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
49639 }
49640 {
49641 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
49642 }
49643 {
49644 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
49645 }
49646 {
49647 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
49648 }
49649 {
49650 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
49651 }
49652 {
49653 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
49654 }
49655 {
49656 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
49657 }
49658 {
49659 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
49660 }
49661 {
49662 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
49663 }
49664 {
49665 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
49666 }
49667 {
49668 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
49669 }
49670 {
49671 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
49672 }
49673 {
49674 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
49675 }
49676 {
49677 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
49678 }
49679 {
49680 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
49681 }
49682 {
49683 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
49684 }
49685 {
49686 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
49687 }
49688 {
49689 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
49690 }
49691 {
49692 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
49693 }
49694 {
49695 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
49696 }
49697 {
49698 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
49699 }
49700 {
49701 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
49702 }
49703 {
49704 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49705 }
49706 {
49707 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49708 }
49709 {
49710 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49711 }
49712 {
49713 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49714 }
49715 {
49716 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49717 }
49718 {
49719 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49720 }
49721 {
49722 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49723 }
49724 {
49725 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49726 }
49727 {
49728 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49729 }
49730 {
49731 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49732 }
49733 {
49734 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49735 }
49736 {
49737 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49738 }
49739 {
49740 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49741 }
49742 {
49743 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49744 }
49745 {
49746 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49747 }
49748 {
49749 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49750 }
49751 {
49752 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49753 }
49754 {
49755 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49756 }
49757 {
49758 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49759 }
49760 {
49761 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49762 }
49763 {
49764 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49765 }
49766 {
49767 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49768 }
49769 {
49770 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49771 }
49772 {
49773 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49774 }
49775 {
49776 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49777 }
49778 {
49779 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49780 }
49781 {
49782 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49783 }
49784 {
49785 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49786 }
49787 {
49788 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49789 }
49790 {
49791 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49792 }
49793 {
49794 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49795 }
49796 {
49797 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49798 }
49799 {
49800 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49801 }
49802 {
49803 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49804 }
49805 {
49806 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49807 }
49808 {
49809 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49810 }
49811 {
49812 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49813 }
49814 {
49815 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49816 }
49817 {
49818 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49819 }
49820 {
49821 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49822 }
49823 {
49824 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49825 }
49826 {
49827 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49828 }
49829 {
49830 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49831 }
49832 {
49833 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49834 }
49835 {
49836 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49837 }
49838 {
49839 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49840 }
49841 {
49842 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49843 }
49844 {
49845 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49846 }
49847 {
49848 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49849 }
49850 {
49851 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49852 }
49853 {
49854 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49855 }
49856 {
49857 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49858 }
49859 {
49860 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49861 }
49862 {
49863 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49864 }
49865 {
49866 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49867 }
49868 {
49869 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49870 }
49871 {
49872 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49873 }
49874 {
49875 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49876 }
49877 {
49878 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49879 }
49880 {
49881 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49882 }
49883 {
49884 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49885 }
49886 {
49887 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49888 }
49889 {
49890 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49891 }
49892 {
49893 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49894 }
49895 {
49896 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49897 }
49898 {
49899 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49900 }
49901 {
49902 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49903 }
49904 {
49905 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_DBL_JAPANESE_POSTCARD)));
49906 }
49907 {
49908 PyDict_SetItemString(d,"PAPER_A6", SWIG_From_int((int)(wxPAPER_A6)));
49909 }
49910 {
49911 PyDict_SetItemString(d,"PAPER_JENV_KAKU2", SWIG_From_int((int)(wxPAPER_JENV_KAKU2)));
49912 }
49913 {
49914 PyDict_SetItemString(d,"PAPER_JENV_KAKU3", SWIG_From_int((int)(wxPAPER_JENV_KAKU3)));
49915 }
49916 {
49917 PyDict_SetItemString(d,"PAPER_JENV_CHOU3", SWIG_From_int((int)(wxPAPER_JENV_CHOU3)));
49918 }
49919 {
49920 PyDict_SetItemString(d,"PAPER_JENV_CHOU4", SWIG_From_int((int)(wxPAPER_JENV_CHOU4)));
49921 }
49922 {
49923 PyDict_SetItemString(d,"PAPER_LETTER_ROTATED", SWIG_From_int((int)(wxPAPER_LETTER_ROTATED)));
49924 }
49925 {
49926 PyDict_SetItemString(d,"PAPER_A3_ROTATED", SWIG_From_int((int)(wxPAPER_A3_ROTATED)));
49927 }
49928 {
49929 PyDict_SetItemString(d,"PAPER_A4_ROTATED", SWIG_From_int((int)(wxPAPER_A4_ROTATED)));
49930 }
49931 {
49932 PyDict_SetItemString(d,"PAPER_A5_ROTATED", SWIG_From_int((int)(wxPAPER_A5_ROTATED)));
49933 }
49934 {
49935 PyDict_SetItemString(d,"PAPER_B4_JIS_ROTATED", SWIG_From_int((int)(wxPAPER_B4_JIS_ROTATED)));
49936 }
49937 {
49938 PyDict_SetItemString(d,"PAPER_B5_JIS_ROTATED", SWIG_From_int((int)(wxPAPER_B5_JIS_ROTATED)));
49939 }
49940 {
49941 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD_ROTATED", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
49942 }
49943 {
49944 PyDict_SetItemString(d,"PAPER_DBL_JAPANESE_POSTCARD_ROTATED", SWIG_From_int((int)(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
49945 }
49946 {
49947 PyDict_SetItemString(d,"PAPER_A6_ROTATED", SWIG_From_int((int)(wxPAPER_A6_ROTATED)));
49948 }
49949 {
49950 PyDict_SetItemString(d,"PAPER_JENV_KAKU2_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_KAKU2_ROTATED)));
49951 }
49952 {
49953 PyDict_SetItemString(d,"PAPER_JENV_KAKU3_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_KAKU3_ROTATED)));
49954 }
49955 {
49956 PyDict_SetItemString(d,"PAPER_JENV_CHOU3_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_CHOU3_ROTATED)));
49957 }
49958 {
49959 PyDict_SetItemString(d,"PAPER_JENV_CHOU4_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_CHOU4_ROTATED)));
49960 }
49961 {
49962 PyDict_SetItemString(d,"PAPER_B6_JIS", SWIG_From_int((int)(wxPAPER_B6_JIS)));
49963 }
49964 {
49965 PyDict_SetItemString(d,"PAPER_B6_JIS_ROTATED", SWIG_From_int((int)(wxPAPER_B6_JIS_ROTATED)));
49966 }
49967 {
49968 PyDict_SetItemString(d,"PAPER_12X11", SWIG_From_int((int)(wxPAPER_12X11)));
49969 }
49970 {
49971 PyDict_SetItemString(d,"PAPER_JENV_YOU4", SWIG_From_int((int)(wxPAPER_JENV_YOU4)));
49972 }
49973 {
49974 PyDict_SetItemString(d,"PAPER_JENV_YOU4_ROTATED", SWIG_From_int((int)(wxPAPER_JENV_YOU4_ROTATED)));
49975 }
49976 {
49977 PyDict_SetItemString(d,"PAPER_P16K", SWIG_From_int((int)(wxPAPER_P16K)));
49978 }
49979 {
49980 PyDict_SetItemString(d,"PAPER_P32K", SWIG_From_int((int)(wxPAPER_P32K)));
49981 }
49982 {
49983 PyDict_SetItemString(d,"PAPER_P32KBIG", SWIG_From_int((int)(wxPAPER_P32KBIG)));
49984 }
49985 {
49986 PyDict_SetItemString(d,"PAPER_PENV_1", SWIG_From_int((int)(wxPAPER_PENV_1)));
49987 }
49988 {
49989 PyDict_SetItemString(d,"PAPER_PENV_2", SWIG_From_int((int)(wxPAPER_PENV_2)));
49990 }
49991 {
49992 PyDict_SetItemString(d,"PAPER_PENV_3", SWIG_From_int((int)(wxPAPER_PENV_3)));
49993 }
49994 {
49995 PyDict_SetItemString(d,"PAPER_PENV_4", SWIG_From_int((int)(wxPAPER_PENV_4)));
49996 }
49997 {
49998 PyDict_SetItemString(d,"PAPER_PENV_5", SWIG_From_int((int)(wxPAPER_PENV_5)));
49999 }
50000 {
50001 PyDict_SetItemString(d,"PAPER_PENV_6", SWIG_From_int((int)(wxPAPER_PENV_6)));
50002 }
50003 {
50004 PyDict_SetItemString(d,"PAPER_PENV_7", SWIG_From_int((int)(wxPAPER_PENV_7)));
50005 }
50006 {
50007 PyDict_SetItemString(d,"PAPER_PENV_8", SWIG_From_int((int)(wxPAPER_PENV_8)));
50008 }
50009 {
50010 PyDict_SetItemString(d,"PAPER_PENV_9", SWIG_From_int((int)(wxPAPER_PENV_9)));
50011 }
50012 {
50013 PyDict_SetItemString(d,"PAPER_PENV_10", SWIG_From_int((int)(wxPAPER_PENV_10)));
50014 }
50015 {
50016 PyDict_SetItemString(d,"PAPER_P16K_ROTATED", SWIG_From_int((int)(wxPAPER_P16K_ROTATED)));
50017 }
50018 {
50019 PyDict_SetItemString(d,"PAPER_P32K_ROTATED", SWIG_From_int((int)(wxPAPER_P32K_ROTATED)));
50020 }
50021 {
50022 PyDict_SetItemString(d,"PAPER_P32KBIG_ROTATED", SWIG_From_int((int)(wxPAPER_P32KBIG_ROTATED)));
50023 }
50024 {
50025 PyDict_SetItemString(d,"PAPER_PENV_1_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_1_ROTATED)));
50026 }
50027 {
50028 PyDict_SetItemString(d,"PAPER_PENV_2_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_2_ROTATED)));
50029 }
50030 {
50031 PyDict_SetItemString(d,"PAPER_PENV_3_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_3_ROTATED)));
50032 }
50033 {
50034 PyDict_SetItemString(d,"PAPER_PENV_4_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_4_ROTATED)));
50035 }
50036 {
50037 PyDict_SetItemString(d,"PAPER_PENV_5_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_5_ROTATED)));
50038 }
50039 {
50040 PyDict_SetItemString(d,"PAPER_PENV_6_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_6_ROTATED)));
50041 }
50042 {
50043 PyDict_SetItemString(d,"PAPER_PENV_7_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_7_ROTATED)));
50044 }
50045 {
50046 PyDict_SetItemString(d,"PAPER_PENV_8_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_8_ROTATED)));
50047 }
50048 {
50049 PyDict_SetItemString(d,"PAPER_PENV_9_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_9_ROTATED)));
50050 }
50051 {
50052 PyDict_SetItemString(d,"PAPER_PENV_10_ROTATED", SWIG_From_int((int)(wxPAPER_PENV_10_ROTATED)));
50053 }
50054 {
50055 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
50056 }
50057 {
50058 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
50059 }
50060 {
50061 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
50062 }
50063 {
50064 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
50065 }
50066 {
50067 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
50068 }
50069 {
50070 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
50071 }
50072 {
50073 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
50074 }
50075 {
50076 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
50077 }
50078 {
50079 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
50080 }
50081 {
50082 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
50083 }
50084 {
50085 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
50086 }
50087 {
50088 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
50089 }
50090 {
50091 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
50092 }
50093 {
50094 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
50095 }
50096 {
50097 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
50098 }
50099 {
50100 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
50101 }
50102 {
50103 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
50104 }
50105 {
50106 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
50107 }
50108 {
50109 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
50110 }
50111 {
50112 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
50113 }
50114 {
50115 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
50116 }
50117 {
50118 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
50119 }
50120 {
50121 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
50122 }
50123 {
50124 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
50125 }
50126 {
50127 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
50128 }
50129 {
50130 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
50131 }
50132 {
50133 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
50134 }
50135 {
50136 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
50137 }
50138 {
50139 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
50140 }
50141 {
50142 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
50143 }
50144 {
50145 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
50146 }
50147 {
50148 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
50149 }
50150 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
50151 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
50152 {
50153 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
50154 }
50155 {
50156 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
50157 }
50158 {
50159 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
50160 }
50161 {
50162 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
50163 }
50164 {
50165 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
50166 }
50167 {
50168 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
50169 }
50170 {
50171 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
50172 }
50173 {
50174 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
50175 }
50176 {
50177 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
50178 }
50179 {
50180 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
50181 }
50182 {
50183 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
50184 }
50185 {
50186 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
50187 }
50188 {
50189 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
50190 }
50191 {
50192 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
50193 }
50194 {
50195 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
50196 }
50197 {
50198 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
50199 }
50200 {
50201 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
50202 }
50203 {
50204 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
50205 }
50206 {
50207 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
50208 }
50209 {
50210 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
50211 }
50212 {
50213 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
50214 }
50215 {
50216 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
50217 }
50218 {
50219 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
50220 }
50221 {
50222 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
50223 }
50224 {
50225 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
50226 }
50227 {
50228 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
50229 }
50230 {
50231 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
50232 }
50233 {
50234 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
50235 }
50236 {
50237 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
50238 }
50239 {
50240 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
50241 }
50242 {
50243 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
50244 }
50245 {
50246 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
50247 }
50248 {
50249 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
50250 }
50251 {
50252 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
50253 }
50254 {
50255 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
50256 }
50257 {
50258 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
50259 }
50260 {
50261 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
50262 }
50263 {
50264 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
50265 }
50266 {
50267 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
50268 }
50269 {
50270 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
50271 }
50272 {
50273 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
50274 }
50275 {
50276 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
50277 }
50278 {
50279 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
50280 }
50281 {
50282 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
50283 }
50284 {
50285 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
50286 }
50287 {
50288 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
50289 }
50290 {
50291 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
50292 }
50293 {
50294 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
50295 }
50296 {
50297 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
50298 }
50299 {
50300 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
50301 }
50302 {
50303 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
50304 }
50305 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
50306 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
50307 {
50308 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
50309 }
50310 {
50311 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
50312 }
50313 {
50314 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
50315 }
50316
50317 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
50318
50319
50320 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
50321
50322 {
50323 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int((int)(wxIMAGE_ALPHA_TRANSPARENT)));
50324 }
50325 {
50326 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int((int)(wxIMAGE_ALPHA_THRESHOLD)));
50327 }
50328 {
50329 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int((int)(wxIMAGE_ALPHA_OPAQUE)));
50330 }
50331 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
50332 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
50333 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
50334 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
50335 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
50336 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
50337 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
50338 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
50339 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
50340 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
50341 {
50342 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
50343 }
50344 {
50345 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
50346 }
50347 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
50348 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
50349 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
50350 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
50351 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
50352 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
50353 {
50354 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
50355 }
50356 {
50357 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
50358 }
50359 {
50360 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
50361 }
50362 {
50363 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
50364 }
50365 {
50366 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
50367 }
50368 {
50369 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
50370 }
50371 {
50372 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
50373 }
50374 {
50375 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
50376 }
50377 {
50378 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
50379 }
50380 {
50381 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
50382 }
50383 {
50384 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
50385 }
50386 {
50387 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
50388 }
50389 {
50390 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
50391 }
50392 {
50393 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
50394 }
50395 {
50396 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
50397 }
50398 {
50399 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
50400 }
50401 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
50402 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
50403 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
50404 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
50405 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
50406 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
50407 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
50408 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
50409 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
50410 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
50411 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
50412 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
50413 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
50414 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
50415 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
50416 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
50417 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
50418 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
50419 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
50420 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
50421 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
50422 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
50423 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
50424 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
50425 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
50426 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
50427 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
50428 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
50429 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
50430 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
50431 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
50432 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
50433 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
50434 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
50435 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
50436 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
50437 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
50438 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
50439 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
50440 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
50441 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
50442 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
50443 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
50444 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
50445 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
50446 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
50447 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
50448 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
50449 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
50450 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
50451 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
50452 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
50453 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
50454 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
50455 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
50456 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
50457 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
50458 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
50459 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
50460 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
50461 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
50462 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
50463 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
50464 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
50465 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
50466 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
50467 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
50468 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
50469 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
50470 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
50471 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
50472 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
50473 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
50474 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
50475 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
50476 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
50477 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
50478 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
50479 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
50480 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
50481 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
50482 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
50483 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
50484 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
50485 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
50486 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
50487 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
50488 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
50489 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
50490 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
50491 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
50492 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
50493 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
50494 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
50495 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
50496 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
50497 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
50498 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
50499 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
50500 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
50501 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
50502 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
50503 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
50504 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
50505 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
50506 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
50507 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
50508 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
50509 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
50510 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
50511 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
50512 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
50513 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
50514 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
50515 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
50516 {
50517 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
50518 }
50519 {
50520 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
50521 }
50522 {
50523 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
50524 }
50525 {
50526 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
50527 }
50528 {
50529 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
50530 }
50531 {
50532 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
50533 }
50534 {
50535 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
50536 }
50537 {
50538 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
50539 }
50540 {
50541 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
50542 }
50543 {
50544 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
50545 }
50546 {
50547 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
50548 }
50549 {
50550 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
50551 }
50552 {
50553 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
50554 }
50555 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
50556 {
50557 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
50558 }
50559 {
50560 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
50561 }
50562 {
50563 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
50564 }
50565 {
50566 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
50567 }
50568 {
50569 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
50570 }
50571 {
50572 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
50573 }
50574 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
50575 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
50576 {
50577 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
50578 }
50579 {
50580 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
50581 }
50582 {
50583 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
50584 }
50585 {
50586 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
50587 }
50588 {
50589 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
50590 }
50591 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
50592 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
50593 {
50594 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
50595 }
50596 {
50597 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
50598 }
50599 {
50600 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
50601 }
50602 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
50603 {
50604 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
50605 }
50606 {
50607 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
50608 }
50609 {
50610 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
50611 }
50612 {
50613 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
50614 }
50615 {
50616 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
50617 }
50618 {
50619 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
50620 }
50621 {
50622 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
50623 }
50624 {
50625 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
50626 }
50627 {
50628 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
50629 }
50630 {
50631 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
50632 }
50633 {
50634 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
50635 }
50636 {
50637 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
50638 }
50639 {
50640 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
50641 }
50642 {
50643 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
50644 }
50645 {
50646 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
50647 }
50648 {
50649 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
50650 }
50651 {
50652 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
50653 }
50654 {
50655 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
50656 }
50657 {
50658 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
50659 }
50660
50661 // Initialize threading, some globals and such
50662 __wxPyPreStart(d);
50663
50664
50665 // Although these are defined in __version__ they need to be here too so
50666 // that an assert can be done to ensure that the wxPython and the wxWindows
50667 // versions match.
50668 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
50669 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
50670 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
50671
50672 }
50673
wxWidgets (Impactor)