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


fbd79c59111ad5ee3dc117e7d502e3567cb9cc17
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.24
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12
13 #ifdef __cplusplus
14 template<class T> class SwigValueWrapper {
15 T *tt;
16 public:
17 SwigValueWrapper() : tt(0) { }
18 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
19 SwigValueWrapper(const T& t) : tt(new T(t)) { }
20 ~SwigValueWrapper() { delete tt; }
21 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
22 operator T&() const { return *tt; }
23 T *operator&() { return tt; }
24 private:
25 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
26 };
27 #endif
28
29
30 #ifndef SWIG_TEMPLATE_DISAMBIGUATOR
31 # if defined(__SUNPRO_CC)
32 # define SWIG_TEMPLATE_DISAMBIGUATOR template
33 # else
34 # define SWIG_TEMPLATE_DISAMBIGUATOR
35 # endif
36 #endif
37
38
39 #include <Python.h>
40
41 /***********************************************************************
42 * swigrun.swg
43 *
44 * This file contains generic CAPI SWIG runtime support for pointer
45 * type checking.
46 *
47 ************************************************************************/
48
49 /* This should only be incremented when either the layout of swig_type_info changes,
50 or for whatever reason, the runtime changes incompatibly */
51 #define SWIG_RUNTIME_VERSION "1"
52
53 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
54 #ifdef SWIG_TYPE_TABLE
55 #define SWIG_QUOTE_STRING(x) #x
56 #define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
57 #define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
58 #else
59 #define SWIG_TYPE_TABLE_NAME
60 #endif
61
62 #include <string.h>
63
64 #ifndef SWIGINLINE
65 #if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
66 # define SWIGINLINE inline
67 #else
68 # define SWIGINLINE
69 #endif
70 #endif
71
72 /*
73 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
74 creating a static or dynamic library from the swig runtime code.
75 In 99.9% of the cases, swig just needs to declare them as 'static'.
76
77 But only do this if is strictly necessary, ie, if you have problems
78 with your compiler or so.
79 */
80 #ifndef SWIGRUNTIME
81 #define SWIGRUNTIME static
82 #endif
83 #ifndef SWIGRUNTIMEINLINE
84 #define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
85 #endif
86
87 #ifdef __cplusplus
88 extern "C" {
89 #endif
90
91 typedef void *(*swig_converter_func)(void *);
92 typedef struct swig_type_info *(*swig_dycast_func)(void **);
93
94 typedef struct swig_type_info {
95 const char *name;
96 swig_converter_func converter;
97 const char *str;
98 void *clientdata;
99 swig_dycast_func dcast;
100 struct swig_type_info *next;
101 struct swig_type_info *prev;
102 } swig_type_info;
103
104 /*
105 Compare two type names skipping the space characters, therefore
106 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
107
108 Return 0 when the two name types are equivalent, as in
109 strncmp, but skipping ' '.
110 */
111 SWIGRUNTIME int
112 SWIG_TypeNameComp(const char *f1, const char *l1,
113 const char *f2, const char *l2) {
114 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
115 while ((*f1 == ' ') && (f1 != l1)) ++f1;
116 while ((*f2 == ' ') && (f2 != l2)) ++f2;
117 if (*f1 != *f2) return *f1 - *f2;
118 }
119 return (l1 - f1) - (l2 - f2);
120 }
121
122 /*
123 Check type equivalence in a name list like <name1>|<name2>|...
124 */
125 SWIGRUNTIME int
126 SWIG_TypeEquiv(const char *nb, const char *tb) {
127 int equiv = 0;
128 const char* te = tb + strlen(tb);
129 const char* ne = nb;
130 while (!equiv && *ne) {
131 for (nb = ne; *ne; ++ne) {
132 if (*ne == '|') break;
133 }
134 equiv = SWIG_TypeNameComp(nb, ne, tb, te) == 0;
135 if (*ne) ++ne;
136 }
137 return equiv;
138 }
139
140 /*
141 Register a type mapping with the type-checking
142 */
143 SWIGRUNTIME swig_type_info *
144 SWIG_TypeRegisterTL(swig_type_info **tl, swig_type_info *ti) {
145 swig_type_info *tc, *head, *ret, *next;
146 /* Check to see if this type has already been registered */
147 tc = *tl;
148 while (tc) {
149 /* check simple type equivalence */
150 int typeequiv = (strcmp(tc->name, ti->name) == 0);
151 /* check full type equivalence, resolving typedefs */
152 if (!typeequiv) {
153 /* only if tc is not a typedef (no '|' on it) */
154 if (tc->str && ti->str && !strstr(tc->str,"|")) {
155 typeequiv = SWIG_TypeEquiv(ti->str,tc->str);
156 }
157 }
158 if (typeequiv) {
159 /* Already exists in the table. Just add additional types to the list */
160 if (ti->clientdata) tc->clientdata = ti->clientdata;
161 head = tc;
162 next = tc->next;
163 goto l1;
164 }
165 tc = tc->prev;
166 }
167 head = ti;
168 next = 0;
169
170 /* Place in list */
171 ti->prev = *tl;
172 *tl = ti;
173
174 /* Build linked lists */
175 l1:
176 ret = head;
177 tc = ti + 1;
178 /* Patch up the rest of the links */
179 while (tc->name) {
180 head->next = tc;
181 tc->prev = head;
182 head = tc;
183 tc++;
184 }
185 if (next) next->prev = head;
186 head->next = next;
187
188 return ret;
189 }
190
191 /*
192 Check the typename
193 */
194 SWIGRUNTIME swig_type_info *
195 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
196 swig_type_info *s;
197 if (!ty) return 0; /* Void pointer */
198 s = ty->next; /* First element always just a name */
199 do {
200 if (strcmp(s->name,c) == 0) {
201 if (s == ty->next) return s;
202 /* Move s to the top of the linked list */
203 s->prev->next = s->next;
204 if (s->next) {
205 s->next->prev = s->prev;
206 }
207 /* Insert s as second element in the list */
208 s->next = ty->next;
209 if (ty->next) ty->next->prev = s;
210 ty->next = s;
211 s->prev = ty;
212 return s;
213 }
214 s = s->next;
215 } while (s && (s != ty->next));
216 return 0;
217 }
218
219 /*
220 Cast a pointer up an inheritance hierarchy
221 */
222 SWIGRUNTIMEINLINE void *
223 SWIG_TypeCast(swig_type_info *ty, void *ptr) {
224 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
225 }
226
227 /*
228 Dynamic pointer casting. Down an inheritance hierarchy
229 */
230 SWIGRUNTIME swig_type_info *
231 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
232 swig_type_info *lastty = ty;
233 if (!ty || !ty->dcast) return ty;
234 while (ty && (ty->dcast)) {
235 ty = (*ty->dcast)(ptr);
236 if (ty) lastty = ty;
237 }
238 return lastty;
239 }
240
241 /*
242 Return the name associated with this type
243 */
244 SWIGRUNTIMEINLINE const char *
245 SWIG_TypeName(const swig_type_info *ty) {
246 return ty->name;
247 }
248
249 /*
250 Return the pretty name associated with this type,
251 that is an unmangled type name in a form presentable to the user.
252 */
253 SWIGRUNTIME const char *
254 SWIG_TypePrettyName(const swig_type_info *type) {
255 /* The "str" field contains the equivalent pretty names of the
256 type, separated by vertical-bar characters. We choose
257 to print the last name, as it is often (?) the most
258 specific. */
259 if (type->str != NULL) {
260 const char *last_name = type->str;
261 const char *s;
262 for (s = type->str; *s; s++)
263 if (*s == '|') last_name = s+1;
264 return last_name;
265 }
266 else
267 return type->name;
268 }
269
270 /*
271 Search for a swig_type_info structure
272 */
273 SWIGRUNTIME swig_type_info *
274 SWIG_TypeQueryTL(swig_type_info *tl, const char *name) {
275 swig_type_info *ty = tl;
276 while (ty) {
277 if (ty->str && (SWIG_TypeEquiv(ty->str,name))) return ty;
278 if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
279 ty = ty->prev;
280 }
281 return 0;
282 }
283
284 /*
285 Set the clientdata field for a type
286 */
287 SWIGRUNTIME void
288 SWIG_TypeClientDataTL(swig_type_info *tl, swig_type_info *ti, void *clientdata) {
289 swig_type_info *tc, *equiv;
290 if (ti->clientdata) return;
291 /* if (ti->clientdata == clientdata) return; */
292 ti->clientdata = clientdata;
293 equiv = ti->next;
294 while (equiv) {
295 if (!equiv->converter) {
296 tc = tl;
297 while (tc) {
298 if ((strcmp(tc->name, equiv->name) == 0))
299 SWIG_TypeClientDataTL(tl,tc,clientdata);
300 tc = tc->prev;
301 }
302 }
303 equiv = equiv->next;
304 }
305 }
306
307 /*
308 Pack binary data into a string
309 */
310 SWIGRUNTIME char *
311 SWIG_PackData(char *c, void *ptr, size_t sz) {
312 static char hex[17] = "0123456789abcdef";
313 unsigned char *u = (unsigned char *) ptr;
314 const unsigned char *eu = u + sz;
315 register unsigned char uu;
316 for (; u != eu; ++u) {
317 uu = *u;
318 *(c++) = hex[(uu & 0xf0) >> 4];
319 *(c++) = hex[uu & 0xf];
320 }
321 return c;
322 }
323
324 /*
325 Unpack binary data from a string
326 */
327 SWIGRUNTIME const char *
328 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
329 register unsigned char *u = (unsigned char *) ptr;
330 register const unsigned char *eu = u + sz;
331 for (; u != eu; ++u) {
332 register int d = *(c++);
333 register unsigned char uu = 0;
334 if ((d >= '0') && (d <= '9'))
335 uu = ((d - '0') << 4);
336 else if ((d >= 'a') && (d <= 'f'))
337 uu = ((d - ('a'-10)) << 4);
338 else
339 return (char *) 0;
340 d = *(c++);
341 if ((d >= '0') && (d <= '9'))
342 uu |= (d - '0');
343 else if ((d >= 'a') && (d <= 'f'))
344 uu |= (d - ('a'-10));
345 else
346 return (char *) 0;
347 *u = uu;
348 }
349 return c;
350 }
351
352 /*
353 This function will propagate the clientdata field of type to any new
354 swig_type_info structures that have been added into the list of
355 equivalent types. It is like calling SWIG_TypeClientData(type,
356 clientdata) a second time.
357 */
358 SWIGRUNTIME void
359 SWIG_PropagateClientDataTL(swig_type_info *tl, swig_type_info *type) {
360 swig_type_info *equiv = type->next;
361 swig_type_info *tc;
362 if (!type->clientdata) return;
363 while (equiv) {
364 if (!equiv->converter) {
365 tc = tl;
366 while (tc) {
367 if ((strcmp(tc->name, equiv->name) == 0) && !tc->clientdata)
368 SWIG_TypeClientDataTL(tl,tc, type->clientdata);
369 tc = tc->prev;
370 }
371 }
372 equiv = equiv->next;
373 }
374 }
375
376 /*
377 Pack 'void *' into a string buffer.
378 */
379 SWIGRUNTIME char *
380 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
381 char *r = buff;
382 if ((2*sizeof(void *) + 2) > bsz) return 0;
383 *(r++) = '_';
384 r = SWIG_PackData(r,&ptr,sizeof(void *));
385 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
386 strcpy(r,name);
387 return buff;
388 }
389
390 SWIGRUNTIME const char *
391 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
392 if (*c != '_') {
393 if (strcmp(c,"NULL") == 0) {
394 *ptr = (void *) 0;
395 return name;
396 } else {
397 return 0;
398 }
399 }
400 return SWIG_UnpackData(++c,ptr,sizeof(void *));
401 }
402
403 SWIGRUNTIME char *
404 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
405 char *r = buff;
406 size_t lname = (name ? strlen(name) : 0);
407 if ((2*sz + 2 + lname) > bsz) return 0;
408 *(r++) = '_';
409 r = SWIG_PackData(r,ptr,sz);
410 if (lname) {
411 strncpy(r,name,lname+1);
412 } else {
413 *r = 0;
414 }
415 return buff;
416 }
417
418 SWIGRUNTIME const char *
419 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
420 if (*c != '_') {
421 if (strcmp(c,"NULL") == 0) {
422 memset(ptr,0,sz);
423 return name;
424 } else {
425 return 0;
426 }
427 }
428 return SWIG_UnpackData(++c,ptr,sz);
429 }
430
431 #ifdef __cplusplus
432 }
433 #endif
434
435 /***********************************************************************
436 * common.swg
437 *
438 * This file contains generic SWIG runtime support for pointer
439 * type checking as well as a few commonly used macros to control
440 * external linkage.
441 *
442 * Author : David Beazley (beazley@cs.uchicago.edu)
443 *
444 * Copyright (c) 1999-2000, The University of Chicago
445 *
446 * This file may be freely redistributed without license or fee provided
447 * this copyright message remains intact.
448 ************************************************************************/
449
450
451 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
452 # if !defined(STATIC_LINKED)
453 # define SWIGEXPORT(a) __declspec(dllexport) a
454 # else
455 # define SWIGEXPORT(a) a
456 # endif
457 #else
458 # define SWIGEXPORT(a) a
459 #endif
460
461 #ifdef __cplusplus
462 extern "C" {
463 #endif
464
465
466 /*************************************************************************/
467
468
469 /* The static type info list */
470
471 static swig_type_info *swig_type_list = 0;
472 static swig_type_info **swig_type_list_handle = &swig_type_list;
473
474
475 /* Register a type mapping with the type-checking */
476 static swig_type_info *
477 SWIG_TypeRegister(swig_type_info *ti) {
478 return SWIG_TypeRegisterTL(swig_type_list_handle, ti);
479 }
480
481 /* Search for a swig_type_info structure */
482 static swig_type_info *
483 SWIG_TypeQuery(const char *name) {
484 return SWIG_TypeQueryTL(*swig_type_list_handle, name);
485 }
486
487 /* Set the clientdata field for a type */
488 static void
489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
490 SWIG_TypeClientDataTL(*swig_type_list_handle, ti, clientdata);
491 }
492
493 /* This function will propagate the clientdata field of type to
494 * any new swig_type_info structures that have been added into the list
495 * of equivalent types. It is like calling
496 * SWIG_TypeClientData(type, clientdata) a second time.
497 */
498 static void
499 SWIG_PropagateClientData(swig_type_info *type) {
500 SWIG_PropagateClientDataTL(*swig_type_list_handle, type);
501 }
502
503 #ifdef __cplusplus
504 }
505 #endif
506
507 /* -----------------------------------------------------------------------------
508 * SWIG API. Portion that goes into the runtime
509 * ----------------------------------------------------------------------------- */
510
511 #ifdef __cplusplus
512 extern "C" {
513 #endif
514
515 /* -----------------------------------------------------------------------------
516 * for internal method declarations
517 * ----------------------------------------------------------------------------- */
518
519 #ifndef SWIGINTERN
520 #define SWIGINTERN static
521 #endif
522
523 #ifndef SWIGINTERNSHORT
524 #ifdef __cplusplus
525 #define SWIGINTERNSHORT static inline
526 #else /* C case */
527 #define SWIGINTERNSHORT static
528 #endif /* __cplusplus */
529 #endif
530
531
532 /*
533 Exception handling in wrappers
534 */
535 #define SWIG_fail goto fail
536 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
537 #define SWIG_append_errmsg(msg) SWIG_Python_AddErrMesg(msg,0)
538 #define SWIG_preppend_errmsg(msg) SWIG_Python_AddErrMesg(msg,1)
539 #define SWIG_type_error(type,obj) SWIG_Python_TypeError(type,obj)
540 #define SWIG_null_ref(type) SWIG_Python_NullRef(type)
541
542 /*
543 Contract support
544 */
545 #define SWIG_contract_assert(expr, msg) \
546 if (!(expr)) { PyErr_SetString(PyExc_RuntimeError, (char *) msg ); goto fail; } else
547
548 /* -----------------------------------------------------------------------------
549 * Constant declarations
550 * ----------------------------------------------------------------------------- */
551
552 /* Constant Types */
553 #define SWIG_PY_INT 1
554 #define SWIG_PY_FLOAT 2
555 #define SWIG_PY_STRING 3
556 #define SWIG_PY_POINTER 4
557 #define SWIG_PY_BINARY 5
558
559 /* Constant information structure */
560 typedef struct swig_const_info {
561 int type;
562 char *name;
563 long lvalue;
564 double dvalue;
565 void *pvalue;
566 swig_type_info **ptype;
567 } swig_const_info;
568
569
570 /* -----------------------------------------------------------------------------
571 * Alloc. memory flags
572 * ----------------------------------------------------------------------------- */
573 #define SWIG_OLDOBJ 1
574 #define SWIG_NEWOBJ SWIG_OLDOBJ + 1
575 #define SWIG_PYSTR SWIG_NEWOBJ + 1
576
577 #ifdef __cplusplus
578 }
579 #endif
580
581
582 /***********************************************************************
583 * pyrun.swg
584 *
585 * This file contains the runtime support for Python modules
586 * and includes code for managing global variables and pointer
587 * type checking.
588 *
589 * Author : David Beazley (beazley@cs.uchicago.edu)
590 ************************************************************************/
591
592 /* Common SWIG API */
593 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Python_ConvertPtr(obj, pp, type, flags)
594 #define SWIG_NewPointerObj(p, type, flags) SWIG_Python_NewPointerObj(p, type, flags)
595 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
596
597
598 /* Python-specific SWIG API */
599 #define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Python_ConvertPacked(obj, ptr, sz, ty, flags)
600 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
601
602
603 /* -----------------------------------------------------------------------------
604 * Pointer declarations
605 * ----------------------------------------------------------------------------- */
606 /*
607 Use SWIG_NO_COBJECT_TYPES to force the use of strings to represent
608 C/C++ pointers in the python side. Very useful for debugging, but
609 not always safe.
610 */
611 #if !defined(SWIG_NO_COBJECT_TYPES) && !defined(SWIG_COBJECT_TYPES)
612 # define SWIG_COBJECT_TYPES
613 #endif
614
615 /* Flags for pointer conversion */
616 #define SWIG_POINTER_EXCEPTION 0x1
617 #define SWIG_POINTER_DISOWN 0x2
618
619
620 #ifdef __cplusplus
621 extern "C" {
622 #endif
623
624 /* -----------------------------------------------------------------------------
625 * Create a new pointer string
626 * ----------------------------------------------------------------------------- */
627
628 #ifndef SWIG_BUFFER_SIZE
629 #define SWIG_BUFFER_SIZE 1024
630 #endif
631
632 #if defined(SWIG_COBJECT_TYPES)
633 #if !defined(SWIG_COBJECT_PYTHON)
634 /* -----------------------------------------------------------------------------
635 * Implements a simple Swig Object type, and use it instead of PyCObject
636 * ----------------------------------------------------------------------------- */
637
638 typedef struct {
639 PyObject_HEAD
640 void *ptr;
641 const char *desc;
642 } PySwigObject;
643
644 /* Declarations for objects of type PySwigObject */
645
646 SWIGRUNTIME int
647 PySwigObject_print(PySwigObject *v, FILE *fp, int flags)
648 {
649 char result[SWIG_BUFFER_SIZE];
650 if (SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result))) {
651 fputs("<Swig Object at ", fp); fputs(result, fp); fputs(">", fp);
652 return 0;
653 } else {
654 return 1;
655 }
656 }
657
658 SWIGRUNTIME PyObject *
659 PySwigObject_repr(PySwigObject *v)
660 {
661 char result[SWIG_BUFFER_SIZE];
662 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
663 PyString_FromFormat("<Swig Object at %s>", result) : 0;
664 }
665
666 SWIGRUNTIME PyObject *
667 PySwigObject_str(PySwigObject *v)
668 {
669 char result[SWIG_BUFFER_SIZE];
670 return SWIG_PackVoidPtr(result, v->ptr, v->desc, sizeof(result)) ?
671 PyString_FromString(result) : 0;
672 }
673
674 SWIGRUNTIME PyObject *
675 PySwigObject_long(PySwigObject *v)
676 {
677 return PyLong_FromUnsignedLong((unsigned long) v->ptr);
678 }
679
680 SWIGRUNTIME PyObject *
681 PySwigObject_oct(PySwigObject *v)
682 {
683 char buf[100];
684 unsigned long x = (unsigned long)v->ptr;
685 if (x == 0)
686 strcpy(buf, "0");
687 else
688 PyOS_snprintf(buf, sizeof(buf), "0%lo", x);
689 return PyString_FromString(buf);
690 }
691
692 SWIGRUNTIME PyObject *
693 PySwigObject_hex(PySwigObject *v)
694 {
695 char buf[100];
696 PyOS_snprintf(buf, sizeof(buf), "0x%lx", (unsigned long)v->ptr);
697 return PyString_FromString(buf);
698 }
699
700 SWIGRUNTIME int
701 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
702 {
703 int c = strcmp(v->desc, w->desc);
704 if (c) {
705 return c;
706 } else {
707 void *i = v->ptr;
708 void *j = w->ptr;
709 return (i < j) ? -1 : (i > j) ? 1 : 0;
710 }
711 }
712
713 SWIGRUNTIME void
714 PySwigObject_dealloc(PySwigObject *self)
715 {
716 PyObject_DEL(self);
717 }
718
719 SWIGRUNTIME PyTypeObject*
720 PySwigObject_GetType() {
721 static char PySwigObject_Type__doc__[] =
722 "Swig object carries a C/C++ instance pointer";
723
724 static PyNumberMethods PySwigObject_as_number = {
725 (binaryfunc)0, /*nb_add*/
726 (binaryfunc)0, /*nb_subtract*/
727 (binaryfunc)0, /*nb_multiply*/
728 (binaryfunc)0, /*nb_divide*/
729 (binaryfunc)0, /*nb_remainder*/
730 (binaryfunc)0, /*nb_divmod*/
731 (ternaryfunc)0,/*nb_power*/
732 (unaryfunc)0, /*nb_negative*/
733 (unaryfunc)0, /*nb_positive*/
734 (unaryfunc)0, /*nb_absolute*/
735 (inquiry)0, /*nb_nonzero*/
736 0, /*nb_invert*/
737 0, /*nb_lshift*/
738 0, /*nb_rshift*/
739 0, /*nb_and*/
740 0, /*nb_xor*/
741 0, /*nb_or*/
742 (coercion)0, /*nb_coerce*/
743 (unaryfunc)PySwigObject_long, /*nb_int*/
744 (unaryfunc)PySwigObject_long, /*nb_long*/
745 (unaryfunc)0, /*nb_float*/
746 (unaryfunc)PySwigObject_oct, /*nb_oct*/
747 (unaryfunc)PySwigObject_hex, /*nb_hex*/
748 #if PY_VERSION_HEX >= 0x02000000
749 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
750 #endif
751 };
752
753 static int type_init = 0;
754 static PyTypeObject PySwigObject_Type;
755
756 if (!type_init) {
757 PyTypeObject tmp = {
758 PyObject_HEAD_INIT(&PyType_Type)
759 0, /*ob_size*/
760 "PySwigObject", /*tp_name*/
761 sizeof(PySwigObject), /*tp_basicsize*/
762 0, /*tp_itemsize*/
763 /* methods */
764 (destructor)PySwigObject_dealloc, /*tp_dealloc*/
765 (printfunc)PySwigObject_print, /*tp_print*/
766 (getattrfunc)0, /*tp_getattr*/
767 (setattrfunc)0, /*tp_setattr*/
768 (cmpfunc)PySwigObject_compare, /*tp_compare*/
769 (reprfunc)PySwigObject_repr, /*tp_repr*/
770 &PySwigObject_as_number, /*tp_as_number*/
771 0, /*tp_as_sequence*/
772 0, /*tp_as_mapping*/
773 (hashfunc)0, /*tp_hash*/
774 (ternaryfunc)0, /*tp_call*/
775 (reprfunc)PySwigObject_str, /*tp_str*/
776 /* Space for future expansion */
777 0L,0L,0L,0L,
778 PySwigObject_Type__doc__, /* Documentation string */
779 #if PY_VERSION_HEX >= 0x02000000
780 0, /* tp_traverse */
781 0, /* tp_clear */
782 #endif
783 #if PY_VERSION_HEX >= 0x02010000
784 0, /* tp_richcompare */
785 0, /* tp_weaklistoffset */
786 #endif
787 #if PY_VERSION_HEX >= 0x02020000
788 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
789 #endif
790 #if PY_VERSION_HEX >= 0x02030000
791 0, /* tp_del */
792 #endif
793 #ifdef COUNT_ALLOCS
794 0,0,0,0 /* tp_alloc -> tp_next */
795 #endif
796 };
797
798 PySwigObject_Type = tmp;
799 type_init = 1;
800 }
801
802 return &PySwigObject_Type;
803 }
804
805 SWIGRUNTIME PyObject *
806 PySwigObject_FromVoidPtrAndDesc(void *ptr, const char *desc)
807 {
808 PySwigObject *self = PyObject_NEW(PySwigObject, PySwigObject_GetType());
809 if (self == NULL) return NULL;
810 self->ptr = ptr;
811 self->desc = desc;
812 return (PyObject *)self;
813 }
814
815 SWIGRUNTIMEINLINE void *
816 PySwigObject_AsVoidPtr(PyObject *self)
817 {
818 return ((PySwigObject *)self)->ptr;
819 }
820
821 SWIGRUNTIMEINLINE const char *
822 PySwigObject_GetDesc(PyObject *self)
823 {
824 return ((PySwigObject *)self)->desc;
825 }
826
827 SWIGRUNTIMEINLINE int
828 PySwigObject_Check(PyObject *op) {
829 return ((op)->ob_type == PySwigObject_GetType())
830 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
831 }
832
833 /* -----------------------------------------------------------------------------
834 * Implements a simple Swig Packed type, and use it instead of string
835 * ----------------------------------------------------------------------------- */
836
837 typedef struct {
838 PyObject_HEAD
839 void *pack;
840 const char *desc;
841 size_t size;
842 } PySwigPacked;
843
844 SWIGRUNTIME int
845 PySwigPacked_print(PySwigPacked *v, FILE *fp, int flags)
846 {
847 char result[SWIG_BUFFER_SIZE];
848 fputs("<Swig Packed ", fp);
849 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
850 fputs("at ", fp);
851 fputs(result, fp);
852 }
853 fputs(v->desc,fp);
854 fputs(">", fp);
855 return 0;
856 }
857
858 SWIGRUNTIME PyObject *
859 PySwigPacked_repr(PySwigPacked *v)
860 {
861 char result[SWIG_BUFFER_SIZE];
862 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
863 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->desc);
864 } else {
865 return PyString_FromFormat("<Swig Packed %s>", v->desc);
866 }
867 }
868
869 SWIGRUNTIME PyObject *
870 PySwigPacked_str(PySwigPacked *v)
871 {
872 char result[SWIG_BUFFER_SIZE];
873 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
874 return PyString_FromFormat("%s%s", result, v->desc);
875 } else {
876 return PyString_FromFormat("%s", v->desc);
877 }
878 }
879
880 SWIGRUNTIME int
881 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
882 {
883 int c = strcmp(v->desc, w->desc);
884 if (c) {
885 return c;
886 } else {
887 size_t i = v->size;
888 size_t j = w->size;
889 int s = (i < j) ? -1 : (i > j) ? 1 : 0;
890 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
891 }
892 }
893
894 SWIGRUNTIME void
895 PySwigPacked_dealloc(PySwigPacked *self)
896 {
897 free(self->pack);
898 PyObject_DEL(self);
899 }
900
901 SWIGRUNTIME PyTypeObject*
902 PySwigPacked_GetType() {
903 static char PySwigPacked_Type__doc__[] =
904 "Swig object carries a C/C++ instance pointer";
905 static int type_init = 0;
906
907 static PyTypeObject PySwigPacked_Type;
908 if (!type_init) {
909 PyTypeObject tmp = {
910 PyObject_HEAD_INIT(&PyType_Type)
911 0, /*ob_size*/
912 "PySwigPacked", /*tp_name*/
913 sizeof(PySwigPacked), /*tp_basicsize*/
914 0, /*tp_itemsize*/
915 /* methods */
916 (destructor)PySwigPacked_dealloc, /*tp_dealloc*/
917 (printfunc)PySwigPacked_print, /*tp_print*/
918 (getattrfunc)0, /*tp_getattr*/
919 (setattrfunc)0, /*tp_setattr*/
920 (cmpfunc)PySwigPacked_compare, /*tp_compare*/
921 (reprfunc)PySwigPacked_repr, /*tp_repr*/
922 0, /*tp_as_number*/
923 0, /*tp_as_sequence*/
924 0, /*tp_as_mapping*/
925 (hashfunc)0, /*tp_hash*/
926 (ternaryfunc)0, /*tp_call*/
927 (reprfunc)PySwigPacked_str, /*tp_str*/
928 /* Space for future expansion */
929 0L,0L,0L,0L,
930 PySwigPacked_Type__doc__, /* Documentation string */
931 #if PY_VERSION_HEX >= 0x02000000
932 0, /* tp_traverse */
933 0, /* tp_clear */
934 #endif
935 #if PY_VERSION_HEX >= 0x02010000
936 0, /* tp_richcompare */
937 0, /* tp_weaklistoffset */
938 #endif
939 #if PY_VERSION_HEX >= 0x02020000
940 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
941 #endif
942 #if PY_VERSION_HEX >= 0x02030000
943 0, /* tp_del */
944 #endif
945 #ifdef COUNT_ALLOCS
946 0,0,0,0 /* tp_alloc -> tp_next */
947 #endif
948 };
949
950 PySwigPacked_Type = tmp;
951 type_init = 1;
952 }
953
954
955
956 return &PySwigPacked_Type;
957 }
958
959 SWIGRUNTIME PyObject *
960 PySwigPacked_FromDataAndDesc(void *ptr, size_t size, const char *desc)
961 {
962 PySwigPacked *self = PyObject_NEW(PySwigPacked, PySwigPacked_GetType());
963 if (self == NULL) {
964 return NULL;
965 } else {
966 void *pack = malloc(size);
967 memcpy(pack, ptr, size);
968 self->pack = pack;
969 self->desc = desc;
970 self->size = size;
971 return (PyObject *) self;
972 }
973 }
974
975 SWIGRUNTIMEINLINE const char *
976 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
977 {
978 PySwigPacked *self = (PySwigPacked *)obj;
979 if (self->size != size) return 0;
980 memcpy(ptr, self->pack, size);
981 return self->desc;
982 }
983
984 SWIGRUNTIMEINLINE const char *
985 PySwigPacked_GetDesc(PyObject *self)
986 {
987 return ((PySwigPacked *)self)->desc;
988 }
989
990 SWIGRUNTIMEINLINE int
991 PySwigPacked_Check(PyObject *op) {
992 return ((op)->ob_type == PySwigPacked_GetType())
993 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
994 }
995
996 #else
997 /* -----------------------------------------------------------------------------
998 * Use the old Python PyCObject instead of PySwigObject
999 * ----------------------------------------------------------------------------- */
1000
1001 #define PySwigObject_GetDesc(obj) PyCObject_GetDesc(obj)
1002 #define PySwigObject_Check(obj) PyCObject_Check(obj)
1003 #define PySwigObject_AsVoidPtr(obj) PyCObject_AsVoidPtr(obj)
1004 #define PySwigObject_FromVoidPtrAndDesc(p, d) PyCObject_FromVoidPtrAndDesc(p, d, NULL)
1005
1006 #endif
1007
1008 #endif
1009
1010 /* -----------------------------------------------------------------------------
1011 * errors manipulation
1012 * ----------------------------------------------------------------------------- */
1013
1014 SWIGRUNTIME void
1015 SWIG_Python_TypeError(const char *type, PyObject *obj)
1016 {
1017 if (type) {
1018 #if defined(SWIG_COBJECT_TYPES)
1019 if (PySwigObject_Check(obj)) {
1020 const char *otype = (const char *) PySwigObject_GetDesc(obj);
1021 if (otype) {
1022 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
1023 type, otype);
1024 return;
1025 }
1026 } else
1027 #endif
1028 {
1029 const char *otype = (obj ? obj->ob_type->tp_name : 0);
1030 if (otype) {
1031 PyObject *str = PyObject_Str(obj);
1032 const char *cstr = str ? PyString_AsString(str) : 0;
1033 if (cstr) {
1034 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
1035 type, otype, cstr);
1036 } else {
1037 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
1038 type, otype);
1039 }
1040 Py_DECREF(str);
1041 return;
1042 }
1043 }
1044 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
1045 } else {
1046 PyErr_Format(PyExc_TypeError, "unexpected type is received");
1047 }
1048 }
1049
1050 SWIGRUNTIMEINLINE void
1051 SWIG_Python_NullRef(const char *type)
1052 {
1053 if (type) {
1054 PyErr_Format(PyExc_TypeError, "null reference of type '%s' was received",type);
1055 } else {
1056 PyErr_Format(PyExc_TypeError, "null reference was received");
1057 }
1058 }
1059
1060 SWIGRUNTIME int
1061 SWIG_Python_AddErrMesg(const char* mesg, int infront)
1062 {
1063 if (PyErr_Occurred()) {
1064 PyObject *type = 0;
1065 PyObject *value = 0;
1066 PyObject *traceback = 0;
1067 PyErr_Fetch(&type, &value, &traceback);
1068 if (value) {
1069 PyObject *old_str = PyObject_Str(value);
1070 Py_XINCREF(type);
1071 PyErr_Clear();
1072 if (infront) {
1073 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
1074 } else {
1075 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
1076 }
1077 Py_DECREF(old_str);
1078 }
1079 return 1;
1080 } else {
1081 return 0;
1082 }
1083 }
1084
1085 SWIGRUNTIME int
1086 SWIG_Python_ArgFail(int argnum)
1087 {
1088 if (PyErr_Occurred()) {
1089 /* add information about failing argument */
1090 char mesg[256];
1091 sprintf(mesg, "argument number %d:", argnum);
1092 return SWIG_Python_AddErrMesg(mesg, 1);
1093 } else {
1094 return 0;
1095 }
1096 }
1097
1098
1099 /* -----------------------------------------------------------------------------
1100 * pointers/data manipulation
1101 * ----------------------------------------------------------------------------- */
1102
1103 /* Convert a pointer value */
1104 SWIGRUNTIME int
1105 SWIG_Python_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
1106 swig_type_info *tc;
1107 const char *c = 0;
1108 static PyObject *SWIG_this = 0;
1109 int newref = 0;
1110 PyObject *pyobj = 0;
1111 void *vptr;
1112
1113 if (!obj) return 0;
1114 if (obj == Py_None) {
1115 *ptr = 0;
1116 return 0;
1117 }
1118
1119 #ifdef SWIG_COBJECT_TYPES
1120 if (!(PySwigObject_Check(obj))) {
1121 if (!SWIG_this)
1122 SWIG_this = PyString_FromString("this");
1123 pyobj = obj;
1124 obj = PyObject_GetAttr(obj,SWIG_this);
1125 newref = 1;
1126 if (!obj) goto type_error;
1127 if (!PySwigObject_Check(obj)) {
1128 Py_DECREF(obj);
1129 goto type_error;
1130 }
1131 }
1132 vptr = PySwigObject_AsVoidPtr(obj);
1133 c = (const char *) PySwigObject_GetDesc(obj);
1134 if (newref) { Py_DECREF(obj); }
1135 goto type_check;
1136 #else
1137 if (!(PyString_Check(obj))) {
1138 if (!SWIG_this)
1139 SWIG_this = PyString_FromString("this");
1140 pyobj = obj;
1141 obj = PyObject_GetAttr(obj,SWIG_this);
1142 newref = 1;
1143 if (!obj) goto type_error;
1144 if (!PyString_Check(obj)) {
1145 Py_DECREF(obj);
1146 goto type_error;
1147 }
1148 }
1149 c = PyString_AS_STRING(obj);
1150 /* Pointer values must start with leading underscore */
1151 c = SWIG_UnpackVoidPtr(c, &vptr, ty->name);
1152 if (newref) { Py_DECREF(obj); }
1153 if (!c) goto type_error;
1154 #endif
1155
1156 type_check:
1157
1158 if (ty) {
1159 tc = SWIG_TypeCheck(c,ty);
1160 if (!tc) goto type_error;
1161 *ptr = SWIG_TypeCast(tc,vptr);
1162 } else {
1163 *ptr = vptr;
1164 }
1165
1166 if ((pyobj) && (flags & SWIG_POINTER_DISOWN)) {
1167 PyObject_SetAttrString(pyobj,(char*)"thisown",Py_False);
1168 }
1169 return 0;
1170
1171 type_error:
1172 PyErr_Clear();
1173 if (pyobj && !obj) {
1174 obj = pyobj;
1175 if (PyCFunction_Check(obj)) {
1176 /* here we get the method pointer for callbacks */
1177 char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
1178 c = doc ? strstr(doc, "swig_ptr: ") : 0;
1179 if (c) {
1180 c = SWIG_UnpackVoidPtr(c + 10, &vptr, ty->name);
1181 if (!c) goto type_error;
1182 goto type_check;
1183 }
1184 }
1185 }
1186 if (flags & SWIG_POINTER_EXCEPTION) {
1187 if (ty) {
1188 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1189 } else {
1190 SWIG_Python_TypeError("C/C++ pointer", obj);
1191 }
1192 }
1193 return -1;
1194 }
1195
1196 /* Convert a pointer value, signal an exception on a type mismatch */
1197 SWIGRUNTIME void *
1198 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
1199 void *result;
1200 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
1201 PyErr_Clear();
1202 if (flags & SWIG_POINTER_EXCEPTION) {
1203 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1204 SWIG_Python_ArgFail(argnum);
1205 }
1206 }
1207 return result;
1208 }
1209
1210 /* Convert a packed value value */
1211 SWIGRUNTIME int
1212 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty, int flags) {
1213 swig_type_info *tc;
1214 const char *c = 0;
1215
1216 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1217 c = PySwigPacked_UnpackData(obj, ptr, sz);
1218 #else
1219 if ((!obj) || (!PyString_Check(obj))) goto type_error;
1220 c = PyString_AS_STRING(obj);
1221 /* Pointer values must start with leading underscore */
1222 c = SWIG_UnpackDataName(c, ptr, sz, ty->name);
1223 #endif
1224 if (!c) goto type_error;
1225 if (ty) {
1226 tc = SWIG_TypeCheck(c,ty);
1227 if (!tc) goto type_error;
1228 }
1229 return 0;
1230
1231 type_error:
1232 PyErr_Clear();
1233 if (flags & SWIG_POINTER_EXCEPTION) {
1234 if (ty) {
1235 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
1236 } else {
1237 SWIG_Python_TypeError("C/C++ packed data", obj);
1238 }
1239 }
1240 return -1;
1241 }
1242
1243 /* Create a new array object */
1244 SWIGRUNTIME PyObject *
1245 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int own) {
1246 PyObject *robj = 0;
1247 if (!ptr) {
1248 Py_INCREF(Py_None);
1249 return Py_None;
1250 }
1251 #ifdef SWIG_COBJECT_TYPES
1252 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)type->name);
1253 #else
1254 {
1255 char result[SWIG_BUFFER_SIZE];
1256 robj = SWIG_PackVoidPtr(result, ptr, type->name, sizeof(result)) ?
1257 PyString_FromString(result) : 0;
1258 }
1259 #endif
1260 if (!robj || (robj == Py_None)) return robj;
1261 if (type->clientdata) {
1262 PyObject *inst;
1263 PyObject *args = Py_BuildValue((char*)"(O)", robj);
1264 Py_DECREF(robj);
1265 inst = PyObject_CallObject((PyObject *) type->clientdata, args);
1266 Py_DECREF(args);
1267 if (inst) {
1268 if (own) {
1269 PyObject_SetAttrString(inst,(char*)"thisown",Py_True);
1270 }
1271 robj = inst;
1272 }
1273 }
1274 return robj;
1275 }
1276
1277 SWIGRUNTIME PyObject *
1278 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
1279 PyObject *robj = 0;
1280 if (!ptr) {
1281 Py_INCREF(Py_None);
1282 return Py_None;
1283 }
1284 #if defined(SWIG_COBJECT_TYPES) && !defined(SWIG_COBJECT_PYTHON)
1285 robj = PySwigPacked_FromDataAndDesc((void *) ptr, sz, (char *)type->name);
1286 #else
1287 {
1288 char result[SWIG_BUFFER_SIZE];
1289 robj = SWIG_PackDataName(result, ptr, sz, type->name, sizeof(result)) ?
1290 PyString_FromString(result) : 0;
1291 }
1292 #endif
1293 return robj;
1294 }
1295
1296 /* -----------------------------------------------------------------------------*
1297 * Get type list
1298 * -----------------------------------------------------------------------------*/
1299
1300 #ifdef SWIG_LINK_RUNTIME
1301 void *SWIG_ReturnGlobalTypeList(void *);
1302 #endif
1303
1304 SWIGRUNTIME swig_type_info **
1305 SWIG_Python_GetTypeListHandle() {
1306 static void *type_pointer = (void *)0;
1307 /* first check if module already created */
1308 if (!type_pointer) {
1309 #ifdef SWIG_LINK_RUNTIME
1310 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
1311 #else
1312 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
1313 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
1314 if (PyErr_Occurred()) {
1315 PyErr_Clear();
1316 type_pointer = (void *)0;
1317 }
1318 }
1319 #endif
1320 return (swig_type_info **) type_pointer;
1321 }
1322
1323 /*
1324 Search for a swig_type_info structure
1325 */
1326 SWIGRUNTIMEINLINE swig_type_info *
1327 SWIG_Python_GetTypeList() {
1328 swig_type_info **tlh = SWIG_Python_GetTypeListHandle();
1329 return tlh ? *tlh : (swig_type_info*)0;
1330 }
1331
1332 #define SWIG_Runtime_GetTypeList SWIG_Python_GetTypeList
1333
1334 #ifdef __cplusplus
1335 }
1336 #endif
1337
1338
1339 /* -------- TYPES TABLE (BEGIN) -------- */
1340
1341 #define SWIGTYPE_p_wxLayoutConstraints swig_types[0]
1342 #define SWIGTYPE_p_wxRealPoint swig_types[1]
1343 #define SWIGTYPE_p_wxSizerItem swig_types[2]
1344 #define SWIGTYPE_p_wxGBSizerItem swig_types[3]
1345 #define SWIGTYPE_p_wxScrollEvent swig_types[4]
1346 #define SWIGTYPE_p_wxEventLoop swig_types[5]
1347 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[6]
1348 #define SWIGTYPE_p_wxSizer swig_types[7]
1349 #define SWIGTYPE_p_wxBoxSizer swig_types[8]
1350 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[9]
1351 #define SWIGTYPE_p_wxGridBagSizer swig_types[10]
1352 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[11]
1353 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[12]
1354 #define SWIGTYPE_p_wxEvent swig_types[13]
1355 #define SWIGTYPE_p_buffer swig_types[14]
1356 #define SWIGTYPE_p_wxMenu swig_types[15]
1357 #define SWIGTYPE_p_wxGridSizer swig_types[16]
1358 #define SWIGTYPE_p_wxFlexGridSizer swig_types[17]
1359 #define SWIGTYPE_p_wxInitDialogEvent swig_types[18]
1360 #define SWIGTYPE_p_wxItemContainer swig_types[19]
1361 #define SWIGTYPE_p_wxNcPaintEvent swig_types[20]
1362 #define SWIGTYPE_p_wxPaintEvent swig_types[21]
1363 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[22]
1364 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[23]
1365 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[24]
1366 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[25]
1367 #define SWIGTYPE_p_wxControl swig_types[26]
1368 #define SWIGTYPE_p_wxFont swig_types[27]
1369 #define SWIGTYPE_p_wxMenuBarBase swig_types[28]
1370 #define SWIGTYPE_p_wxSetCursorEvent swig_types[29]
1371 #define SWIGTYPE_p_wxFSFile swig_types[30]
1372 #define SWIGTYPE_p_wxCaret swig_types[31]
1373 #define SWIGTYPE_ptrdiff_t swig_types[32]
1374 #define SWIGTYPE_std__ptrdiff_t swig_types[33]
1375 #define SWIGTYPE_p_wxRegion swig_types[34]
1376 #define SWIGTYPE_p_wxPoint2D swig_types[35]
1377 #define SWIGTYPE_p_int swig_types[36]
1378 #define SWIGTYPE_p_wxSize swig_types[37]
1379 #define SWIGTYPE_p_wxDC swig_types[38]
1380 #define SWIGTYPE_p_wxPySizer swig_types[39]
1381 #define SWIGTYPE_p_wxVisualAttributes swig_types[40]
1382 #define SWIGTYPE_p_wxNotifyEvent swig_types[41]
1383 #define SWIGTYPE_p_wxPyEvent swig_types[42]
1384 #define SWIGTYPE_p_wxPropagationDisabler swig_types[43]
1385 #define SWIGTYPE_p_form_ops_t swig_types[44]
1386 #define SWIGTYPE_p_wxAppTraits swig_types[45]
1387 #define SWIGTYPE_p_wxArrayString swig_types[46]
1388 #define SWIGTYPE_p_wxShowEvent swig_types[47]
1389 #define SWIGTYPE_p_wxToolTip swig_types[48]
1390 #define SWIGTYPE_p_wxMoveEvent swig_types[49]
1391 #define SWIGTYPE_p_wxSizeEvent swig_types[50]
1392 #define SWIGTYPE_p_wxActivateEvent swig_types[51]
1393 #define SWIGTYPE_p_wxIconizeEvent swig_types[52]
1394 #define SWIGTYPE_p_wxMaximizeEvent swig_types[53]
1395 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[54]
1396 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[55]
1397 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
1398 #define SWIGTYPE_p_wxDateEvent swig_types[57]
1399 #define SWIGTYPE_p_wxMenuItem swig_types[58]
1400 #define SWIGTYPE_p_wxStaticBox swig_types[59]
1401 #define SWIGTYPE_p_long swig_types[60]
1402 #define SWIGTYPE_p_wxDuplexMode swig_types[61]
1403 #define SWIGTYPE_p_wxTIFFHandler swig_types[62]
1404 #define SWIGTYPE_p_wxXPMHandler swig_types[63]
1405 #define SWIGTYPE_p_wxPNMHandler swig_types[64]
1406 #define SWIGTYPE_p_wxJPEGHandler swig_types[65]
1407 #define SWIGTYPE_p_wxPCXHandler swig_types[66]
1408 #define SWIGTYPE_p_wxGIFHandler swig_types[67]
1409 #define SWIGTYPE_p_wxPNGHandler swig_types[68]
1410 #define SWIGTYPE_p_wxANIHandler swig_types[69]
1411 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[70]
1412 #define SWIGTYPE_p_wxZipFSHandler swig_types[71]
1413 #define SWIGTYPE_p_wxInternetFSHandler swig_types[72]
1414 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[73]
1415 #define SWIGTYPE_p_wxEvtHandler swig_types[74]
1416 #define SWIGTYPE_p_wxCURHandler swig_types[75]
1417 #define SWIGTYPE_p_wxICOHandler swig_types[76]
1418 #define SWIGTYPE_p_wxBMPHandler swig_types[77]
1419 #define SWIGTYPE_p_wxImageHandler swig_types[78]
1420 #define SWIGTYPE_p_wxFileSystemHandler swig_types[79]
1421 #define SWIGTYPE_p_wxRect swig_types[80]
1422 #define SWIGTYPE_p_wxButton swig_types[81]
1423 #define SWIGTYPE_p_wxGBSpan swig_types[82]
1424 #define SWIGTYPE_p_wxPropagateOnce swig_types[83]
1425 #define SWIGTYPE_p_wxAcceleratorTable swig_types[84]
1426 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[85]
1427 #define SWIGTYPE_p_char swig_types[86]
1428 #define SWIGTYPE_p_wxGBPosition swig_types[87]
1429 #define SWIGTYPE_p_wxImage swig_types[88]
1430 #define SWIGTYPE_p_wxFrame swig_types[89]
1431 #define SWIGTYPE_p_wxScrollWinEvent swig_types[90]
1432 #define SWIGTYPE_p_wxPaperSize swig_types[91]
1433 #define SWIGTYPE_p_wxImageHistogram swig_types[92]
1434 #define SWIGTYPE_p_wxPoint swig_types[93]
1435 #define SWIGTYPE_p_wxCursor swig_types[94]
1436 #define SWIGTYPE_p_wxObject swig_types[95]
1437 #define SWIGTYPE_p_wxInputStream swig_types[96]
1438 #define SWIGTYPE_p_wxOutputStream swig_types[97]
1439 #define SWIGTYPE_p_wxPyInputStream swig_types[98]
1440 #define SWIGTYPE_p_wxDateTime swig_types[99]
1441 #define SWIGTYPE_p_wxKeyEvent swig_types[100]
1442 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[101]
1443 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[102]
1444 #define SWIGTYPE_p_unsigned_long swig_types[103]
1445 #define SWIGTYPE_p_wxWindow swig_types[104]
1446 #define SWIGTYPE_p_wxMenuBar swig_types[105]
1447 #define SWIGTYPE_p_wxFileSystem swig_types[106]
1448 #define SWIGTYPE_p_wxBitmap swig_types[107]
1449 #define SWIGTYPE_unsigned_int swig_types[108]
1450 #define SWIGTYPE_p_unsigned_int swig_types[109]
1451 #define SWIGTYPE_p_wxMenuEvent swig_types[110]
1452 #define SWIGTYPE_p_wxContextMenuEvent swig_types[111]
1453 #define SWIGTYPE_p_unsigned_char swig_types[112]
1454 #define SWIGTYPE_p_wxEraseEvent swig_types[113]
1455 #define SWIGTYPE_p_wxMouseEvent swig_types[114]
1456 #define SWIGTYPE_p_wxCloseEvent swig_types[115]
1457 #define SWIGTYPE_p_wxPyApp swig_types[116]
1458 #define SWIGTYPE_p_wxCommandEvent swig_types[117]
1459 #define SWIGTYPE_p_wxPyCommandEvent swig_types[118]
1460 #define SWIGTYPE_p_wxPyDropTarget swig_types[119]
1461 #define SWIGTYPE_p_wxQuantize swig_types[120]
1462 #define SWIGTYPE_p_wxFocusEvent swig_types[121]
1463 #define SWIGTYPE_p_wxChildFocusEvent swig_types[122]
1464 #define SWIGTYPE_p_wxDropFilesEvent swig_types[123]
1465 #define SWIGTYPE_p_wxControlWithItems swig_types[124]
1466 #define SWIGTYPE_p_wxColour swig_types[125]
1467 #define SWIGTYPE_p_wxValidator swig_types[126]
1468 #define SWIGTYPE_p_wxPyValidator swig_types[127]
1469 static swig_type_info *swig_types[129];
1470
1471 /* -------- TYPES TABLE (END) -------- */
1472
1473
1474 /*-----------------------------------------------
1475 @(target):= _core_.so
1476 ------------------------------------------------*/
1477 #define SWIG_init init_core_
1478
1479 #define SWIG_name "_core_"
1480
1481 #include "wx/wxPython/wxPython_int.h"
1482 #include "wx/wxPython/pyclasses.h"
1483
1484
1485 #ifndef wxPyUSE_EXPORT
1486 // Helper functions for dealing with SWIG objects and such. These are
1487 // located here so they know about the SWIG types and functions declared
1488 // in the wrapper code.
1489
1490 #include <wx/hashmap.h>
1491 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
1492
1493
1494 // Maintains a hashmap of className to swig_type_info pointers. Given the
1495 // name of a class either looks up the type info in the cache, or scans the
1496 // SWIG tables for it.
1497 extern PyObject* wxPyPtrTypeMap;
1498 static
1499 swig_type_info* wxPyFindSwigType(const wxChar* className) {
1500
1501 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
1502
1503 if (typeInfoCache == NULL)
1504 typeInfoCache = new wxPyTypeInfoHashMap;
1505
1506 wxString name(className);
1507 swig_type_info* swigType = (*typeInfoCache)[name];
1508
1509 if (! swigType) {
1510 // it wasn't in the cache, so look it up from SWIG
1511 name.Append(wxT(" *"));
1512 swigType = SWIG_TypeQuery(name.mb_str());
1513
1514 // if it still wasn't found, try looking for a mapped name
1515 if (!swigType) {
1516 PyObject* item;
1517 name = className;
1518
1519 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
1520 (char*)(const char*)name.mbc_str())) != NULL) {
1521 name = wxString(PyString_AsString(item), *wxConvCurrent);
1522 name.Append(wxT(" *"));
1523 swigType = SWIG_TypeQuery(name.mb_str());
1524 }
1525 }
1526 if (swigType) {
1527 // and add it to the map if found
1528 (*typeInfoCache)[className] = swigType;
1529 }
1530 }
1531 return swigType;
1532 }
1533
1534
1535 // Check if a class name is a type known to SWIG
1536 bool wxPyCheckSwigType(const wxChar* className) {
1537
1538 swig_type_info* swigType = wxPyFindSwigType(className);
1539 return swigType != NULL;
1540 }
1541
1542
1543 // Given a pointer to a C++ object and a class name, construct a Python proxy
1544 // object for it.
1545 PyObject* wxPyConstructObject(void* ptr,
1546 const wxChar* className,
1547 int setThisOwn) {
1548
1549 swig_type_info* swigType = wxPyFindSwigType(className);
1550 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
1551
1552 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
1553 }
1554
1555
1556 // Extract a pointer to the wrapped C++ object from a Python proxy object.
1557 // Ensures that the proxy object is of the specified (or derived) type. If
1558 // not able to perform the conversion then a Python exception is set and the
1559 // error should be handled properly in the caller. Returns True on success.
1560 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
1561 const wxChar* className) {
1562
1563 swig_type_info* swigType = wxPyFindSwigType(className);
1564 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
1565
1566 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
1567 }
1568
1569
1570 // Make a SWIGified pointer object suitable for a .this attribute
1571 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
1572
1573 PyObject* robj = NULL;
1574
1575 swig_type_info* swigType = wxPyFindSwigType(className);
1576 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConvertSwigPtr"));
1577
1578 #ifdef SWIG_COBJECT_TYPES
1579 robj = PySwigObject_FromVoidPtrAndDesc((void *) ptr, (char *)swigType->name);
1580 #else
1581 {
1582 char result[1024];
1583 robj = SWIG_PackVoidPtr(result, ptr, swigType->name, sizeof(result)) ?
1584 PyString_FromString(result) : 0;
1585 }
1586 #endif
1587
1588 return robj;
1589 }
1590
1591
1592
1593
1594 // Export a C API in a struct. Other modules will be able to load this from
1595 // the wx._core_ module and will then have safe access to these functions,
1596 // even if they are located in another shared library.
1597 static wxPyCoreAPI API = {
1598
1599 wxPyCheckSwigType,
1600 wxPyConstructObject,
1601 wxPyConvertSwigPtr,
1602 wxPyMakeSwigPtr,
1603
1604 wxPyBeginAllowThreads,
1605 wxPyEndAllowThreads,
1606 wxPyBeginBlockThreads,
1607 wxPyEndBlockThreads,
1608
1609 wxPy_ConvertList,
1610
1611 wxString_in_helper,
1612 Py2wxString,
1613 wx2PyString,
1614
1615 byte_LIST_helper,
1616 int_LIST_helper,
1617 long_LIST_helper,
1618 string_LIST_helper,
1619 wxPoint_LIST_helper,
1620 wxBitmap_LIST_helper,
1621 wxString_LIST_helper,
1622 wxAcceleratorEntry_LIST_helper,
1623
1624 wxSize_helper,
1625 wxPoint_helper,
1626 wxRealPoint_helper,
1627 wxRect_helper,
1628 wxColour_helper,
1629 wxPoint2D_helper,
1630
1631 wxPySimple_typecheck,
1632 wxColour_typecheck,
1633
1634 wxPyCBH_setCallbackInfo,
1635 wxPyCBH_findCallback,
1636 wxPyCBH_callCallback,
1637 wxPyCBH_callCallbackObj,
1638 wxPyCBH_delete,
1639
1640 wxPyMake_wxObject,
1641 wxPyMake_wxSizer,
1642 wxPyPtrTypeMap_Add,
1643 wxPy2int_seq_helper,
1644 wxPy4int_seq_helper,
1645 wxArrayString2PyList_helper,
1646 wxArrayInt2PyList_helper,
1647
1648 wxPyClientData_dtor,
1649 wxPyUserData_dtor,
1650 wxPyOORClientData_dtor,
1651
1652 wxPyCBInputStream_create,
1653 wxPyCBInputStream_copy,
1654
1655 wxPyInstance_Check,
1656 wxPySwigInstance_Check,
1657
1658 wxPyCheckForApp
1659
1660 };
1661
1662 #endif
1663
1664
1665 #if !WXWIN_COMPATIBILITY_2_4
1666 #define wxHIDE_READONLY 0
1667 #endif
1668
1669
1670 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1671 #define SWIG_From_int PyInt_FromLong
1672 /*@@*/
1673
1674
1675 #if ! wxUSE_HOTKEY
1676 enum wxHotkeyModifier
1677 {
1678 wxMOD_NONE = 0,
1679 wxMOD_ALT = 1,
1680 wxMOD_CONTROL = 2,
1681 wxMOD_SHIFT = 4,
1682 wxMOD_WIN = 8
1683 };
1684 #define wxEVT_HOTKEY 9999
1685 #endif
1686
1687 static const wxString wxPyEmptyString(wxEmptyString);
1688 static wxString wxObject_GetClassName(wxObject *self){
1689 return self->GetClassInfo()->GetClassName();
1690 }
1691 static void wxObject_Destroy(wxObject *self){
1692 delete self;
1693 }
1694
1695 #ifndef __WXMAC__
1696 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
1697 #endif
1698
1699
1700 #include <limits.h>
1701
1702
1703 SWIGINTERN int
1704 SWIG_CheckLongInRange(long value, long min_value, long max_value,
1705 const char *errmsg)
1706 {
1707 if (value < min_value) {
1708 if (errmsg) {
1709 PyErr_Format(PyExc_OverflowError,
1710 "value %ld is less than '%s' minimum %ld",
1711 value, errmsg, min_value);
1712 }
1713 return 0;
1714 } else if (value > max_value) {
1715 if (errmsg) {
1716 PyErr_Format(PyExc_OverflowError,
1717 "value %ld is greater than '%s' maximum %ld",
1718 value, errmsg, max_value);
1719 }
1720 return 0;
1721 }
1722 return 1;
1723 }
1724
1725
1726 SWIGINTERN int
1727 SWIG_AsVal_long(PyObject* obj, long* val)
1728 {
1729 if (PyNumber_Check(obj)) {
1730 if (val) *val = PyInt_AsLong(obj);
1731 return 1;
1732 }
1733 else {
1734 SWIG_type_error("number", obj);
1735 }
1736 return 0;
1737 }
1738
1739
1740 #if INT_MAX != LONG_MAX
1741 SWIGINTERN int
1742 SWIG_AsVal_int(PyObject *obj, int *val)
1743 {
1744 const char* errmsg = val ? "int" : (char*)0;
1745 long v;
1746 if (SWIG_AsVal_long(obj, &v)) {
1747 if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
1748 if (val) *val = (int)(v);
1749 return 1;
1750 } else {
1751 return 0;
1752 }
1753 } else {
1754 PyErr_Clear();
1755 }
1756 if (val) {
1757 SWIG_type_error(errmsg, obj);
1758 }
1759 return 0;
1760 }
1761 #else
1762 SWIGINTERNSHORT int
1763 SWIG_AsVal_int(PyObject *obj, int *val)
1764 {
1765 return SWIG_AsVal_long(obj,(long*)val);
1766 }
1767 #endif
1768
1769
1770 SWIGINTERNSHORT int
1771 SWIG_As_int(PyObject* obj)
1772 {
1773 int v;
1774 if (!SWIG_AsVal_int(obj, &v)) {
1775 /*
1776 this is needed to make valgrind/purify happier.
1777 */
1778 memset((void*)&v, 0, sizeof(int));
1779 }
1780 return v;
1781 }
1782
1783
1784 SWIGINTERNSHORT int
1785 SWIG_Check_int(PyObject* obj)
1786 {
1787 return SWIG_AsVal_int(obj, (int*)0);
1788 }
1789
1790 static PyObject *wxSize_Get(wxSize *self){
1791 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1792 PyObject* tup = PyTuple_New(2);
1793 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1794 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1795 wxPyEndBlockThreads(blocked);
1796 return tup;
1797 }
1798
1799 SWIGINTERN int
1800 SWIG_AsVal_double(PyObject *obj, double* val)
1801 {
1802 if (PyNumber_Check(obj)) {
1803 if (val) *val = PyFloat_AsDouble(obj);
1804 return 1;
1805 }
1806 else {
1807 SWIG_type_error("number", obj);
1808 }
1809 return 0;
1810 }
1811
1812
1813 SWIGINTERNSHORT double
1814 SWIG_As_double(PyObject* obj)
1815 {
1816 double v;
1817 if (!SWIG_AsVal_double(obj, &v)) {
1818 /*
1819 this is needed to make valgrind/purify happier.
1820 */
1821 memset((void*)&v, 0, sizeof(double));
1822 }
1823 return v;
1824 }
1825
1826
1827 SWIGINTERNSHORT int
1828 SWIG_Check_double(PyObject* obj)
1829 {
1830 return SWIG_AsVal_double(obj, (double*)0);
1831 }
1832
1833
1834 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
1835 #define SWIG_From_double PyFloat_FromDouble
1836 /*@@*/
1837
1838 static void wxRealPoint_Set(wxRealPoint *self,double x,double y){
1839 self->x = x;
1840 self->y = y;
1841 }
1842 static PyObject *wxRealPoint_Get(wxRealPoint *self){
1843 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1844 PyObject* tup = PyTuple_New(2);
1845 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
1846 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
1847 wxPyEndBlockThreads(blocked);
1848 return tup;
1849 }
1850
1851 SWIGINTERNSHORT long
1852 SWIG_As_long(PyObject* obj)
1853 {
1854 long v;
1855 if (!SWIG_AsVal_long(obj, &v)) {
1856 /*
1857 this is needed to make valgrind/purify happier.
1858 */
1859 memset((void*)&v, 0, sizeof(long));
1860 }
1861 return v;
1862 }
1863
1864
1865 SWIGINTERNSHORT int
1866 SWIG_Check_long(PyObject* obj)
1867 {
1868 return SWIG_AsVal_long(obj, (long*)0);
1869 }
1870
1871 static void wxPoint_Set(wxPoint *self,long x,long y){
1872 self->x = x;
1873 self->y = y;
1874 }
1875 static PyObject *wxPoint_Get(wxPoint *self){
1876 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1877 PyObject* tup = PyTuple_New(2);
1878 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1879 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1880 wxPyEndBlockThreads(blocked);
1881 return tup;
1882 }
1883 static void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
1884 self->x = x;
1885 self->y = y;
1886 self->width = width;
1887 self->height = height;
1888 }
1889 static PyObject *wxRect_Get(wxRect *self){
1890 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1891 PyObject* tup = PyTuple_New(4);
1892 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
1893 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
1894 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
1895 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
1896 wxPyEndBlockThreads(blocked);
1897 return tup;
1898 }
1899
1900 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
1901 wxRegion reg1(*r1);
1902 wxRegion reg2(*r2);
1903 wxRect dest(0,0,0,0);
1904 PyObject* obj;
1905
1906 reg1.Intersect(reg2);
1907 dest = reg1.GetBox();
1908
1909 if (dest != wxRect(0,0,0,0)) {
1910 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1911 wxRect* newRect = new wxRect(dest);
1912 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
1913 wxPyEndBlockThreads(blocked);
1914 return obj;
1915 }
1916 Py_INCREF(Py_None);
1917 return Py_None;
1918 }
1919
1920
1921 static PyObject* t_output_helper(PyObject* target, PyObject* o) {
1922 PyObject* o2;
1923 PyObject* o3;
1924
1925 if (!target) {
1926 target = o;
1927 } else if (target == Py_None) {
1928 Py_DECREF(Py_None);
1929 target = o;
1930 } else {
1931 if (!PyTuple_Check(target)) {
1932 o2 = target;
1933 target = PyTuple_New(1);
1934 PyTuple_SetItem(target, 0, o2);
1935 }
1936 o3 = PyTuple_New(1);
1937 PyTuple_SetItem(o3, 0, o);
1938
1939 o2 = target;
1940 target = PySequence_Concat(o2, o3);
1941 Py_DECREF(o2);
1942 Py_DECREF(o3);
1943 }
1944 return target;
1945 }
1946
1947
1948 static void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
1949 self->m_x = x;
1950 self->m_y = y;
1951 }
1952 static PyObject *wxPoint2D_Get(wxPoint2D *self){
1953 wxPyBlock_t blocked = wxPyBeginBlockThreads();
1954 PyObject* tup = PyTuple_New(2);
1955 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
1956 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
1957 wxPyEndBlockThreads(blocked);
1958 return tup;
1959 }
1960
1961 #include "wx/wxPython/pyistream.h"
1962
1963 static wxPyInputStream *new_wxPyInputStream(PyObject *p){
1964 wxInputStream* wxis = wxPyCBInputStream::create(p);
1965 if (wxis)
1966 return new wxPyInputStream(wxis);
1967 else
1968 return NULL;
1969 }
1970
1971 SWIGINTERNSHORT PyObject*
1972 SWIG_From_char(char c)
1973 {
1974 return PyString_FromStringAndSize(&c,1);
1975 }
1976
1977
1978 SWIGINTERNSHORT PyObject*
1979 SWIG_From_unsigned_SS_long(unsigned long value)
1980 {
1981 return (value > LONG_MAX) ?
1982 PyLong_FromUnsignedLong(value)
1983 : PyInt_FromLong((long)(value));
1984 }
1985
1986
1987 /* returns SWIG_OLDOBJ if the input is a raw char*, SWIG_PYSTR if is a PyString */
1988 SWIGINTERN int
1989 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize)
1990 {
1991 static swig_type_info* pchar_info = 0;
1992 char* vptr = 0;
1993 if (!pchar_info) pchar_info = SWIG_TypeQuery("char *");
1994 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_info, 0) != -1) {
1995 if (cptr) *cptr = vptr;
1996 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
1997 return SWIG_OLDOBJ;
1998 } else {
1999 PyErr_Clear();
2000 if (PyString_Check(obj)) {
2001 if (cptr) {
2002 *cptr = PyString_AS_STRING(obj);
2003 if (psize) {
2004 *psize = PyString_GET_SIZE(obj) + 1;
2005 }
2006 }
2007 return SWIG_PYSTR;
2008 }
2009 }
2010 if (cptr) {
2011 SWIG_type_error("char *", obj);
2012 }
2013 return 0;
2014 }
2015
2016
2017 SWIGINTERN int
2018 SWIG_AsCharArray(PyObject *obj, char *val, size_t size)
2019 {
2020 char* cptr; size_t csize;
2021 if (SWIG_AsCharPtrAndSize(obj, &cptr, &csize)) {
2022 /* in C you can do:
2023
2024 char x[5] = "hello";
2025
2026 ie, assing the array using an extra '0' char.
2027 */
2028 if ((csize == size + 1) && !(cptr[csize-1])) --csize;
2029 if (csize <= size) {
2030 if (val) {
2031 if (csize) memcpy(val, cptr, csize);
2032 if (csize < size) memset(val + csize, 0, size - csize);
2033 }
2034 return 1;
2035 }
2036 }
2037 if (val) {
2038 PyErr_Format(PyExc_TypeError,
2039 "a char array of maximum size %lu is expected",
2040 (unsigned long) size);
2041 }
2042 return 0;
2043 }
2044
2045
2046 SWIGINTERN int
2047 SWIG_AsVal_char(PyObject *obj, char *val)
2048 {
2049 const char* errmsg = val ? "char" : (char*)0;
2050 long v;
2051 if (SWIG_AsVal_long(obj, &v)) {
2052 if (SWIG_CheckLongInRange(v, CHAR_MIN,CHAR_MAX, errmsg)) {
2053 if (val) *val = (char)(v);
2054 return 1;
2055 } else {
2056 return 0;
2057 }
2058 } else {
2059 PyErr_Clear();
2060 return SWIG_AsCharArray(obj, val, 1);
2061 }
2062 }
2063
2064
2065 SWIGINTERNSHORT char
2066 SWIG_As_char(PyObject* obj)
2067 {
2068 char v;
2069 if (!SWIG_AsVal_char(obj, &v)) {
2070 /*
2071 this is needed to make valgrind/purify happier.
2072 */
2073 memset((void*)&v, 0, sizeof(char));
2074 }
2075 return v;
2076 }
2077
2078
2079 SWIGINTERNSHORT int
2080 SWIG_Check_char(PyObject* obj)
2081 {
2082 return SWIG_AsVal_char(obj, (char*)0);
2083 }
2084
2085
2086 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2087 #define SWIG_From_long PyInt_FromLong
2088 /*@@*/
2089
2090 static void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
2091 // We use only strings for the streams, not unicode
2092 PyObject* str = PyObject_Str(obj);
2093 if (! str) {
2094 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
2095 return;
2096 }
2097 self->Write(PyString_AS_STRING(str),
2098 PyString_GET_SIZE(str));
2099 Py_DECREF(str);
2100 }
2101
2102 #include "wx/wxPython/pyistream.h"
2103
2104
2105 class wxPyFileSystemHandler : public wxFileSystemHandler
2106 {
2107 public:
2108 wxPyFileSystemHandler() : wxFileSystemHandler() {}
2109
2110 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
2111 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
2112 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
2113 DEC_PYCALLBACK_STRING__pure(FindNext);
2114
2115 wxString GetProtocol(const wxString& location) {
2116 return wxFileSystemHandler::GetProtocol(location);
2117 }
2118
2119 wxString GetLeftLocation(const wxString& location) {
2120 return wxFileSystemHandler::GetLeftLocation(location);
2121 }
2122
2123 wxString GetAnchor(const wxString& location) {
2124 return wxFileSystemHandler::GetAnchor(location);
2125 }
2126
2127 wxString GetRightLocation(const wxString& location) {
2128 return wxFileSystemHandler::GetRightLocation(location);
2129 }
2130
2131 wxString GetMimeTypeFromExt(const wxString& location) {
2132 return wxFileSystemHandler::GetMimeTypeFromExt(location);
2133 }
2134
2135 PYPRIVATE;
2136 };
2137
2138
2139 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
2140 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
2141 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
2142 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
2143
2144
2145 SWIGINTERN int
2146 SWIG_AsVal_bool(PyObject *obj, bool *val)
2147 {
2148 if (obj == Py_True) {
2149 if (val) *val = true;
2150 return 1;
2151 }
2152 if (obj == Py_False) {
2153 if (val) *val = false;
2154 return 1;
2155 }
2156 int res = 0;
2157 if (SWIG_AsVal_int(obj, &res)) {
2158 if (val) *val = res ? true : false;
2159 return 1;
2160 } else {
2161 PyErr_Clear();
2162 }
2163 if (val) {
2164 SWIG_type_error("bool", obj);
2165 }
2166 return 0;
2167 }
2168
2169
2170 SWIGINTERNSHORT bool
2171 SWIG_As_bool(PyObject* obj)
2172 {
2173 bool v;
2174 if (!SWIG_AsVal_bool(obj, &v)) {
2175 /*
2176 this is needed to make valgrind/purify happier.
2177 */
2178 memset((void*)&v, 0, sizeof(bool));
2179 }
2180 return v;
2181 }
2182
2183
2184 SWIGINTERNSHORT int
2185 SWIG_Check_bool(PyObject* obj)
2186 {
2187 return SWIG_AsVal_bool(obj, (bool*)0);
2188 }
2189
2190 static wxString FileSystem_URLToFileName(wxString const &url){
2191 wxFileName fname = wxFileSystem::URLToFileName(url);
2192 return fname.GetFullPath();
2193 }
2194
2195 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
2196 wxImage& image,
2197 long type) {
2198 wxMemoryFSHandler::AddFile(filename, image, type);
2199 }
2200
2201 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
2202 const wxBitmap& bitmap,
2203 long type) {
2204 wxMemoryFSHandler::AddFile(filename, bitmap, type);
2205 }
2206
2207 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
2208 PyObject* data) {
2209 if (! PyString_Check(data)) {
2210 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
2211 "Expected string object"));
2212 return;
2213 }
2214
2215 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2216 void* ptr = (void*)PyString_AsString(data);
2217 size_t size = PyString_Size(data);
2218 wxPyEndBlockThreads(blocked);
2219
2220 wxMemoryFSHandler::AddFile(filename, ptr, size);
2221 }
2222
2223
2224 #include "wx/wxPython/pyistream.h"
2225
2226
2227 SWIGINTERN int
2228 SWIG_AsVal_unsigned_SS_long(PyObject* obj, unsigned long* val)
2229 {
2230 long v = 0;
2231 if (SWIG_AsVal_long(obj, &v) && v < 0) {
2232 SWIG_type_error("unsigned number", obj);
2233 }
2234 else if (val)
2235 *val = (unsigned long)v;
2236 return 1;
2237 }
2238
2239
2240 SWIGINTERNSHORT int
2241 SWIG_CheckUnsignedLongInRange(unsigned long value,
2242 unsigned long max_value,
2243 const char *errmsg)
2244 {
2245 if (value > max_value) {
2246 if (errmsg) {
2247 PyErr_Format(PyExc_OverflowError,
2248 "value %lu is greater than '%s' minimum %lu",
2249 value, errmsg, max_value);
2250 }
2251 return 0;
2252 }
2253 return 1;
2254 }
2255
2256
2257 SWIGINTERN int
2258 SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
2259 {
2260 const char* errmsg = val ? "unsigned char" : (char*)0;
2261 unsigned long v;
2262 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2263 if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
2264 if (val) *val = (unsigned char)(v);
2265 return 1;
2266 } else {
2267 return 0;
2268 }
2269 } else {
2270 PyErr_Clear();
2271 }
2272 if (val) {
2273 SWIG_type_error(errmsg, obj);
2274 }
2275 return 0;
2276 }
2277
2278
2279 SWIGINTERNSHORT unsigned char
2280 SWIG_As_unsigned_SS_char(PyObject* obj)
2281 {
2282 unsigned char v;
2283 if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
2284 /*
2285 this is needed to make valgrind/purify happier.
2286 */
2287 memset((void*)&v, 0, sizeof(unsigned char));
2288 }
2289 return v;
2290 }
2291
2292
2293 SWIGINTERNSHORT int
2294 SWIG_Check_unsigned_SS_char(PyObject* obj)
2295 {
2296 return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
2297 }
2298
2299
2300 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2301 #define SWIG_From_unsigned_SS_char PyInt_FromLong
2302 /*@@*/
2303
2304
2305
2306 SWIGINTERNSHORT unsigned long
2307 SWIG_As_unsigned_SS_long(PyObject* obj)
2308 {
2309 unsigned long v;
2310 if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2311 /*
2312 this is needed to make valgrind/purify happier.
2313 */
2314 memset((void*)&v, 0, sizeof(unsigned long));
2315 }
2316 return v;
2317 }
2318
2319
2320 SWIGINTERNSHORT int
2321 SWIG_Check_unsigned_SS_long(PyObject* obj)
2322 {
2323 return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
2324 }
2325
2326 static unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
2327 wxImageHistogramEntry e = (*self)[key];
2328 return e.value;
2329 }
2330 static unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,unsigned char r,unsigned char g,unsigned char b){
2331 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
2332 wxImageHistogramEntry e = (*self)[key];
2333 return e.value;
2334 }
2335 static unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
2336 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
2337 colour.Green(),
2338 colour.Blue());
2339 wxImageHistogramEntry e = (*self)[key];
2340 return e.value;
2341 }
2342
2343 typedef unsigned char* buffer;
2344
2345 static wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
2346 if (width > 0 && height > 0)
2347 return new wxImage(width, height, clear);
2348 else
2349 return new wxImage;
2350 }
2351 static wxImage *new_wxImage(wxBitmap const &bitmap){
2352 return new wxImage(bitmap.ConvertToImage());
2353 }
2354 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
2355 if (DATASIZE != width*height*3) {
2356 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2357 return NULL;
2358 }
2359
2360 // Copy the source data so the wxImage can clean it up later
2361 buffer copy = (buffer)malloc(DATASIZE);
2362 if (copy == NULL) {
2363 wxPyBLOCK_THREADS(PyErr_NoMemory());
2364 return NULL;
2365 }
2366 memcpy(copy, data, DATASIZE);
2367 return new wxImage(width, height, copy, false);
2368 }
2369 static wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
2370 if (DATASIZE != width*height*3) {
2371 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2372 return NULL;
2373 }
2374 if (ALPHASIZE != width*height) {
2375 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2376 return NULL;
2377 }
2378
2379 // Copy the source data so the wxImage can clean it up later
2380 buffer dcopy = (buffer)malloc(DATASIZE);
2381 if (dcopy == NULL) {
2382 wxPyBLOCK_THREADS(PyErr_NoMemory());
2383 return NULL;
2384 }
2385 memcpy(dcopy, data, DATASIZE);
2386
2387 buffer acopy = (buffer)malloc(ALPHASIZE);
2388 if (acopy == NULL) {
2389 wxPyBLOCK_THREADS(PyErr_NoMemory());
2390 return NULL;
2391 }
2392 memcpy(acopy, alpha, ALPHASIZE);
2393
2394 return new wxImage(width, height, dcopy, acopy, false);
2395 }
2396 static wxSize wxImage_GetSize(wxImage *self){
2397 wxSize size(self->GetWidth(), self->GetHeight());
2398 return size;
2399 }
2400 static PyObject *wxImage_GetData(wxImage *self){
2401 buffer data = self->GetData();
2402 int len = self->GetWidth() * self->GetHeight() * 3;
2403 PyObject* rv;
2404 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
2405 return rv;
2406 }
2407 static void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
2408 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2409 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2410 return;
2411 }
2412 buffer copy = (buffer)malloc(DATASIZE);
2413 if (copy == NULL) {
2414 wxPyBLOCK_THREADS(PyErr_NoMemory());
2415 return;
2416 }
2417 memcpy(copy, data, DATASIZE);
2418 self->SetData(copy, false);
2419 // wxImage takes ownership of copy...
2420 }
2421 static PyObject *wxImage_GetDataBuffer(wxImage *self){
2422 buffer data = self->GetData();
2423 int len = self->GetWidth() * self->GetHeight() * 3;
2424 PyObject* rv;
2425 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2426 return rv;
2427 }
2428 static void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
2429 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
2430 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
2431 return;
2432 }
2433 self->SetData(data, true);
2434 }
2435 static PyObject *wxImage_GetAlphaData(wxImage *self){
2436 buffer data = self->GetAlpha();
2437 if (! data) {
2438 RETURN_NONE();
2439 } else {
2440 int len = self->GetWidth() * self->GetHeight();
2441 PyObject* rv;
2442 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
2443 return rv;
2444 }
2445 }
2446 static void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
2447 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2448 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2449 return;
2450 }
2451 buffer acopy = (buffer)malloc(ALPHASIZE);
2452 if (acopy == NULL) {
2453 wxPyBLOCK_THREADS(PyErr_NoMemory());
2454 return;
2455 }
2456 memcpy(acopy, alpha, ALPHASIZE);
2457 self->SetAlpha(acopy, false);
2458 // wxImage takes ownership of acopy...
2459 }
2460 static PyObject *wxImage_GetAlphaBuffer(wxImage *self){
2461 buffer data = self->GetAlpha();
2462 int len = self->GetWidth() * self->GetHeight();
2463 PyObject* rv;
2464 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
2465 return rv;
2466 }
2467 static void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
2468 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
2469 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
2470 return;
2471 }
2472 self->SetAlpha(alpha, true);
2473 }
2474 static wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
2475 wxBitmap bitmap(*self, depth);
2476 return bitmap;
2477 }
2478 static wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,unsigned char red,unsigned char green,unsigned char blue){
2479 wxImage mono = self->ConvertToMono( red, green, blue );
2480 wxBitmap bitmap( mono, 1 );
2481 return bitmap;
2482 }
2483 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
2484 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
2485 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
2486 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
2487 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
2488 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
2489 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
2490 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
2491 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
2492 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
2493 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
2494 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
2495 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
2496 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
2497 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
2498
2499 #include <wx/quantize.h>
2500
2501 static bool Quantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
2502 return wxQuantize::Quantize(src, dest,
2503 //NULL, // palette
2504 desiredNoColours,
2505 NULL, // eightBitData
2506 flags);
2507 }
2508 static void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
2509 if (PyCallable_Check(func)) {
2510 self->Connect(id, lastId, eventType,
2511 (wxObjectEventFunction) &wxPyCallback::EventThunker,
2512 new wxPyCallback(func));
2513 }
2514 else if (func == Py_None) {
2515 self->Disconnect(id, lastId, eventType,
2516 (wxObjectEventFunction)
2517 &wxPyCallback::EventThunker);
2518 }
2519 else {
2520 wxPyBLOCK_THREADS(
2521 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
2522 }
2523 }
2524 static bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
2525 return self->Disconnect(id, lastId, eventType,
2526 (wxObjectEventFunction)
2527 &wxPyCallback::EventThunker);
2528 }
2529 static void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
2530 if (_self && _self != Py_None) {
2531 self->SetClientObject(new wxPyOORClientData(_self, incref));
2532 }
2533 else {
2534 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
2535 if (data) {
2536 self->SetClientObject(NULL); // This will delete it too
2537 }
2538 }
2539 }
2540
2541 static int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
2542 #if wxUSE_UNICODE
2543 return self->GetUnicodeKey();
2544 #else
2545 return 0;
2546 #endif
2547 }
2548
2549 #if UINT_MAX < LONG_MAX
2550 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2551 #define SWIG_From_unsigned_SS_int SWIG_From_long
2552 /*@@*/
2553 #else
2554 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2555 #define SWIG_From_unsigned_SS_int SWIG_From_unsigned_SS_long
2556 /*@@*/
2557 #endif
2558
2559
2560 #if UINT_MAX != ULONG_MAX
2561 SWIGINTERN int
2562 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2563 {
2564 const char* errmsg = val ? "unsigned int" : (char*)0;
2565 unsigned long v;
2566 if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
2567 if (SWIG_CheckUnsignedLongInRange(v, INT_MAX, errmsg)) {
2568 if (val) *val = (unsigned int)(v);
2569 return 1;
2570 }
2571 } else {
2572 PyErr_Clear();
2573 }
2574 if (val) {
2575 SWIG_type_error(errmsg, obj);
2576 }
2577 return 0;
2578 }
2579 #else
2580 SWIGINTERNSHORT unsigned int
2581 SWIG_AsVal_unsigned_SS_int(PyObject *obj, unsigned int *val)
2582 {
2583 return SWIG_AsVal_unsigned_SS_long(obj,(unsigned long *)val);
2584 }
2585 #endif
2586
2587
2588 SWIGINTERNSHORT unsigned int
2589 SWIG_As_unsigned_SS_int(PyObject* obj)
2590 {
2591 unsigned int v;
2592 if (!SWIG_AsVal_unsigned_SS_int(obj, &v)) {
2593 /*
2594 this is needed to make valgrind/purify happier.
2595 */
2596 memset((void*)&v, 0, sizeof(unsigned int));
2597 }
2598 return v;
2599 }
2600
2601
2602 SWIGINTERNSHORT int
2603 SWIG_Check_unsigned_SS_int(PyObject* obj)
2604 {
2605 return SWIG_AsVal_unsigned_SS_int(obj, (unsigned int*)0);
2606 }
2607
2608 static void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
2609 self->m_size = size;
2610 }
2611 static PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
2612 int count = self->GetNumberOfFiles();
2613 wxString* files = self->GetFiles();
2614 PyObject* list = PyList_New(count);
2615
2616 if (!list) {
2617 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
2618 return NULL;
2619 }
2620
2621 for (int i=0; i<count; i++) {
2622 PyList_SetItem(list, i, wx2PyString(files[i]));
2623 }
2624 return list;
2625 }
2626
2627
2628 static wxPyApp *new_wxPyApp(){
2629 wxPythonApp = new wxPyApp();
2630 return wxPythonApp;
2631 }
2632 static int PyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
2633
2634 void wxApp_CleanUp() {
2635 __wxPyCleanup();
2636 }
2637
2638
2639 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
2640
2641
2642 SWIGINTERNSHORT int
2643 SWIG_AsCharPtr(PyObject *obj, char **val)
2644 {
2645 if (SWIG_AsCharPtrAndSize(obj, val, (size_t*)(0))) {
2646 return 1;
2647 }
2648 if (val) {
2649 PyErr_Clear();
2650 SWIG_type_error("char *", obj);
2651 }
2652 return 0;
2653 }
2654
2655
2656 SWIGINTERN PyObject *
2657 SWIG_FromCharPtr(const char* cptr)
2658 {
2659 if (cptr) {
2660 size_t size = strlen(cptr);
2661 if (size > INT_MAX) {
2662 return SWIG_NewPointerObj((char*)(cptr),
2663 SWIG_TypeQuery("char *"), 0);
2664 } else {
2665 if (size != 0) {
2666 return PyString_FromStringAndSize(cptr, size);
2667 } else {
2668 return PyString_FromString(cptr);
2669 }
2670 }
2671 }
2672 Py_INCREF(Py_None);
2673 return Py_None;
2674 }
2675
2676
2677 #ifdef __WXMAC__
2678
2679 // A dummy class that raises an exception if used...
2680 class wxEventLoop
2681 {
2682 public:
2683 wxEventLoop() { wxPyRaiseNotImplemented(); }
2684 int Run() { return 0; }
2685 void Exit(int rc = 0) {}
2686 bool Pending() const { return false; }
2687 bool Dispatch() { return false; }
2688 bool IsRunning() const { return false; }
2689 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
2690 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
2691 };
2692
2693 #else
2694
2695 #include <wx/evtloop.h>
2696
2697 #endif
2698
2699
2700
2701 static const wxString wxPyPanelNameStr(wxPanelNameStr);
2702 static wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
2703 static void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
2704 static PyObject *wxWindow_GetChildren(wxWindow *self){
2705 wxWindowList& list = self->GetChildren();
2706 return wxPy_ConvertList(&list);
2707 }
2708 static bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
2709 #if wxUSE_HOTKEY
2710 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
2711 #else
2712 return false;
2713 #endif
2714 }
2715 static bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
2716
2717
2718
2719 return false;
2720
2721 }
2722 static long wxWindow_GetHandle(wxWindow *self){
2723 return wxPyGetWinHandle(self);
2724 }
2725 static void wxWindow_AssociateHandle(wxWindow *self,long handle){
2726 self->AssociateHandle((WXWidget)handle);
2727 }
2728
2729 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
2730 return wxWindow::FindWindowById(id, parent);
2731 }
2732
2733 wxWindow* wxFindWindowByName( const wxString& name,
2734 const wxWindow *parent = NULL ) {
2735 return wxWindow::FindWindowByName(name, parent);
2736 }
2737
2738 wxWindow* wxFindWindowByLabel( const wxString& label,
2739 const wxWindow *parent = NULL ) {
2740 return wxWindow::FindWindowByLabel(label, parent);
2741 }
2742
2743
2744 #ifdef __WXMSW__
2745 #include <wx/msw/private.h> // to get wxGetWindowId
2746 #endif
2747
2748
2749 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
2750 #ifdef __WXMSW__
2751 WXHWND hWnd = (WXHWND)_hWnd;
2752 long id = wxGetWindowId(hWnd);
2753 wxWindow* win = new wxWindow;
2754 parent->AddChild(win);
2755 win->SetEventHandler(win);
2756 win->SetHWND(hWnd);
2757 win->SetId(id);
2758 win->SubclassWin(hWnd);
2759 win->AdoptAttributesFromHWND();
2760 win->SetupColours();
2761 return win;
2762 #else
2763 wxPyRaiseNotImplemented();
2764 return NULL;
2765 #endif
2766 }
2767
2768
2769 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
2770 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
2771 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
2772
2773 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
2774
2775 static void wxMenu_Destroy(wxMenu *self){ delete self; }
2776 static PyObject *wxMenu_GetMenuItems(wxMenu *self){
2777 wxMenuItemList& list = self->GetMenuItems();
2778 return wxPy_ConvertList(&list);
2779 }
2780 static void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
2781 static wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
2782 static void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
2783 static wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
2784 static void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
2785 static wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
2786 static void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){}
2787 static void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
2788 static wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
2789 static void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
2790 static int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
2791 static int MenuItem_GetDefaultMarginWidth(){ return 0; }
2792 static bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
2793 static void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
2794 static void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
2795 static const wxString wxPyControlNameStr(wxControlNameStr);
2796 static int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
2797 if (clientData) {
2798 wxPyClientData* data = new wxPyClientData(clientData);
2799 return self->Append(item, data);
2800 } else
2801 return self->Append(item);
2802 }
2803 static int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
2804 if (clientData) {
2805 wxPyClientData* data = new wxPyClientData(clientData);
2806 return self->Insert(item, pos, data);
2807 } else
2808 return self->Insert(item, pos);
2809 }
2810 static PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
2811 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
2812 if (data) {
2813 Py_INCREF(data->m_obj);
2814 return data->m_obj;
2815 } else {
2816 Py_INCREF(Py_None);
2817 return Py_None;
2818 }
2819 }
2820 static void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
2821 wxPyClientData* data = new wxPyClientData(clientData);
2822 self->SetClientObject(n, data);
2823 }
2824
2825
2826 static wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
2827 wxPyUserData* data = NULL;
2828 if ( userData ) {
2829 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2830 data = new wxPyUserData(userData);
2831 wxPyEndBlockThreads(blocked);
2832 }
2833 return new wxSizerItem(window, proportion, flag, border, data);
2834 }
2835 static wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
2836 wxPyUserData* data = NULL;
2837 if ( userData ) {
2838 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2839 data = new wxPyUserData(userData);
2840 wxPyEndBlockThreads(blocked);
2841 }
2842 return new wxSizerItem(width, height, proportion, flag, border, data);
2843 }
2844 static wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
2845 wxPyUserData* data = NULL;
2846 if ( userData ) {
2847 wxPyBlock_t blocked = wxPyBeginBlockThreads();
2848 data = new wxPyUserData(userData);
2849 wxPyEndBlockThreads(blocked);
2850 }
2851 return new wxSizerItem(sizer, proportion, flag, border, data);
2852 }
2853
2854 #include <float.h>
2855 SWIGINTERN int
2856 SWIG_CheckDoubleInRange(double value, double min_value,
2857 double max_value, const char* errmsg)
2858 {
2859 if (value < min_value) {
2860 if (errmsg) {
2861 PyErr_Format(PyExc_OverflowError,
2862 "value %g is less than %s minimum %g",
2863 value, errmsg, min_value);
2864 }
2865 return 0;
2866 } else if (value > max_value) {
2867 if (errmsg) {
2868 PyErr_Format(PyExc_OverflowError,
2869 "value %g is greater than %s maximum %g",
2870 value, errmsg, max_value);
2871 }
2872 return 0;
2873 }
2874 return 1;
2875 }
2876
2877
2878 SWIGINTERN int
2879 SWIG_AsVal_float(PyObject *obj, float *val)
2880 {
2881 const char* errmsg = val ? "float" : (char*)0;
2882 double v;
2883 if (SWIG_AsVal_double(obj, &v)) {
2884 if (SWIG_CheckDoubleInRange(v, -FLT_MAX, FLT_MAX, errmsg)) {
2885 if (val) *val = (float)(v);
2886 return 1;
2887 } else {
2888 return 0;
2889 }
2890 } else {
2891 PyErr_Clear();
2892 }
2893 if (val) {
2894 SWIG_type_error(errmsg, obj);
2895 }
2896 return 0;
2897 }
2898
2899
2900 SWIGINTERNSHORT float
2901 SWIG_As_float(PyObject* obj)
2902 {
2903 float v;
2904 if (!SWIG_AsVal_float(obj, &v)) {
2905 /*
2906 this is needed to make valgrind/purify happier.
2907 */
2908 memset((void*)&v, 0, sizeof(float));
2909 }
2910 return v;
2911 }
2912
2913
2914 SWIGINTERNSHORT int
2915 SWIG_Check_float(PyObject* obj)
2916 {
2917 return SWIG_AsVal_float(obj, (float*)0);
2918 }
2919
2920
2921 /*@/opt/swig/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
2922 #define SWIG_From_float PyFloat_FromDouble
2923 /*@@*/
2924
2925 static PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
2926 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
2927 if (data) {
2928 Py_INCREF(data->m_obj);
2929 return data->m_obj;
2930 } else {
2931 Py_INCREF(Py_None);
2932 return Py_None;
2933 }
2934 }
2935
2936 // Figure out the type of the sizer item
2937
2938 struct wxPySizerItemInfo {
2939 wxPySizerItemInfo()
2940 : window(NULL), sizer(NULL), gotSize(false),
2941 size(wxDefaultSize), gotPos(false), pos(-1)
2942 {}
2943
2944 wxWindow* window;
2945 wxSizer* sizer;
2946 bool gotSize;
2947 wxSize size;
2948 bool gotPos;
2949 int pos;
2950 };
2951
2952 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
2953
2954 wxPySizerItemInfo info;
2955 wxSize size;
2956 wxSize* sizePtr = &size;
2957
2958 // Find out what the type of the item is
2959 // try wxWindow
2960 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
2961 PyErr_Clear();
2962 info.window = NULL;
2963
2964 // try wxSizer
2965 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
2966 PyErr_Clear();
2967 info.sizer = NULL;
2968
2969 // try wxSize or (w,h)
2970 if ( checkSize && wxSize_helper(item, &sizePtr)) {
2971 info.size = *sizePtr;
2972 info.gotSize = true;
2973 }
2974
2975 // or a single int
2976 if (checkIdx && PyInt_Check(item)) {
2977 info.pos = PyInt_AsLong(item);
2978 info.gotPos = true;
2979 }
2980 }
2981 }
2982
2983 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
2984 // no expected type, figure out what kind of error message to generate
2985 if ( !checkSize && !checkIdx )
2986 PyErr_SetString(PyExc_TypeError, "wxWindow or wxSizer expected for item");
2987 else if ( checkSize && !checkIdx )
2988 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) expected for item");
2989 else if ( !checkSize && checkIdx)
2990 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer or int (position) expected for item");
2991 else
2992 // can this one happen?
2993 PyErr_SetString(PyExc_TypeError, "wxWindow, wxSizer, wxSize, or (w,h) or int (position) expected for item");
2994 }
2995
2996 return info;
2997 }
2998
2999 static void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
3000 if (!self->GetClientObject())
3001 self->SetClientObject(new wxPyOORClientData(_self));
3002 }
3003 static wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3004
3005 wxPyUserData* data = NULL;
3006 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3007 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3008 if ( userData && (info.window || info.sizer || info.gotSize) )
3009 data = new wxPyUserData(userData);
3010 wxPyEndBlockThreads(blocked);
3011
3012 // Now call the real Add method if a valid item type was found
3013 if ( info.window )
3014 return self->Add(info.window, proportion, flag, border, data);
3015 else if ( info.sizer )
3016 return self->Add(info.sizer, proportion, flag, border, data);
3017 else if (info.gotSize)
3018 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
3019 proportion, flag, border, data);
3020 else
3021 return NULL;
3022 }
3023 static wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3024
3025 wxPyUserData* data = NULL;
3026 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3027 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3028 if ( userData && (info.window || info.sizer || info.gotSize) )
3029 data = new wxPyUserData(userData);
3030 wxPyEndBlockThreads(blocked);
3031
3032 // Now call the real Insert method if a valid item type was found
3033 if ( info.window )
3034 return self->Insert(before, info.window, proportion, flag, border, data);
3035 else if ( info.sizer )
3036 return self->Insert(before, info.sizer, proportion, flag, border, data);
3037 else if (info.gotSize)
3038 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
3039 proportion, flag, border, data);
3040 else
3041 return NULL;
3042 }
3043 static wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
3044
3045 wxPyUserData* data = NULL;
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3048 if ( userData && (info.window || info.sizer || info.gotSize) )
3049 data = new wxPyUserData(userData);
3050 wxPyEndBlockThreads(blocked);
3051
3052 // Now call the real Prepend method if a valid item type was found
3053 if ( info.window )
3054 return self->Prepend(info.window, proportion, flag, border, data);
3055 else if ( info.sizer )
3056 return self->Prepend(info.sizer, proportion, flag, border, data);
3057 else if (info.gotSize)
3058 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
3059 proportion, flag, border, data);
3060 else
3061 return NULL;
3062 }
3063 static bool wxSizer_Remove(wxSizer *self,PyObject *item){
3064 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3065 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3066 wxPyEndBlockThreads(blocked);
3067 if ( info.window )
3068 return self->Remove(info.window);
3069 else if ( info.sizer )
3070 return self->Remove(info.sizer);
3071 else if ( info.gotPos )
3072 return self->Remove(info.pos);
3073 else
3074 return false;
3075 }
3076 static bool wxSizer_Detach(wxSizer *self,PyObject *item){
3077 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3078 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3079 wxPyEndBlockThreads(blocked);
3080 if ( info.window )
3081 return self->Detach(info.window);
3082 else if ( info.sizer )
3083 return self->Detach(info.sizer);
3084 else if ( info.gotPos )
3085 return self->Detach(info.pos);
3086 else
3087 return false;
3088 }
3089 static wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
3090 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3091 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3092 wxPyEndBlockThreads(blocked);
3093 if ( info.window )
3094 return self->GetItem(info.window);
3095 else if ( info.sizer )
3096 return self->GetItem(info.sizer);
3097 else if ( info.gotPos )
3098 return self->GetItem(info.pos);
3099 else
3100 return NULL;
3101 }
3102 static void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
3103 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3104 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3105 wxPyEndBlockThreads(blocked);
3106 if ( info.window )
3107 self->SetItemMinSize(info.window, size);
3108 else if ( info.sizer )
3109 self->SetItemMinSize(info.sizer, size);
3110 else if ( info.gotPos )
3111 self->SetItemMinSize(info.pos, size);
3112 }
3113 static PyObject *wxSizer_GetChildren(wxSizer *self){
3114 wxSizerItemList& list = self->GetChildren();
3115 return wxPy_ConvertList(&list);
3116 }
3117 static bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
3118 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3119 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
3120 wxPyEndBlockThreads(blocked);
3121 if ( info.window )
3122 return self->Show(info.window, show, recursive);
3123 else if ( info.sizer )
3124 return self->Show(info.sizer, show, recursive);
3125 else if ( info.gotPos )
3126 return self->Show(info.pos, show);
3127 else
3128 return false;
3129 }
3130 static bool wxSizer_IsShown(wxSizer *self,PyObject *item){
3131 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3132 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
3133 wxPyEndBlockThreads(blocked);
3134 if ( info.window )
3135 return self->IsShown(info.window);
3136 else if ( info.sizer )
3137 return self->IsShown(info.sizer);
3138 else if ( info.gotPos )
3139 return self->IsShown(info.pos);
3140 else
3141 return false;
3142 }
3143
3144 // See pyclasses.h
3145 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
3146 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
3147 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
3148
3149
3150
3151
3152 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
3153 {
3154 if (source == Py_None) {
3155 **obj = wxGBPosition(-1,-1);
3156 return true;
3157 }
3158 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
3159 }
3160
3161 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
3162 {
3163 if (source == Py_None) {
3164 **obj = wxGBSpan(-1,-1);
3165 return true;
3166 }
3167 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
3168 }
3169
3170
3171 static void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
3172 self->SetRow(row);
3173 self->SetCol(col);
3174 }
3175 static PyObject *wxGBPosition_Get(wxGBPosition *self){
3176 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3177 PyObject* tup = PyTuple_New(2);
3178 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
3179 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
3180 wxPyEndBlockThreads(blocked);
3181 return tup;
3182 }
3183 static void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
3184 self->SetRowspan(rowspan);
3185 self->SetColspan(colspan);
3186 }
3187 static PyObject *wxGBSpan_Get(wxGBSpan *self){
3188 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3189 PyObject* tup = PyTuple_New(2);
3190 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
3191 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
3192 wxPyEndBlockThreads(blocked);
3193 return tup;
3194 }
3195 static wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3196 wxPyUserData* data = NULL;
3197 if ( userData ) {
3198 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3199 data = new wxPyUserData(userData);
3200 wxPyEndBlockThreads(blocked);
3201 }
3202 return new wxGBSizerItem(window, pos, span, flag, border, data);
3203 }
3204 static wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3205 wxPyUserData* data = NULL;
3206 if ( userData ) {
3207 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3208 data = new wxPyUserData(userData);
3209 wxPyEndBlockThreads(blocked);
3210 }
3211 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
3212 }
3213 static wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
3214 wxPyUserData* data = NULL;
3215 if ( userData ) {
3216 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3217 data = new wxPyUserData(userData);
3218 wxPyEndBlockThreads(blocked);
3219 }
3220 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
3221 }
3222 static wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
3223 int row, col;
3224 self->GetEndPos(row, col);
3225 return wxGBPosition(row, col);
3226 }
3227 static wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
3228
3229 wxPyUserData* data = NULL;
3230 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3231 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
3232 if ( userData && (info.window || info.sizer || info.gotSize) )
3233 data = new wxPyUserData(userData);
3234 wxPyEndBlockThreads(blocked);
3235
3236 // Now call the real Add method if a valid item type was found
3237 if ( info.window )
3238 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
3239 else if ( info.sizer )
3240 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
3241 else if (info.gotSize)
3242 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
3243 pos, span, flag, border, data);
3244 return NULL;
3245 }
3246
3247
3248 #ifdef __cplusplus
3249 extern "C" {
3250 #endif
3251 static int _wrap_EmptyString_set(PyObject *) {
3252 PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
3253 return 1;
3254 }
3255
3256
3257 static PyObject *_wrap_EmptyString_get(void) {
3258 PyObject *pyobj;
3259
3260 {
3261 #if wxUSE_UNICODE
3262 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3263 #else
3264 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
3265 #endif
3266 }
3267 return pyobj;
3268 }
3269
3270
3271 static PyObject *_wrap_Object_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
3272 PyObject *resultobj;
3273 wxObject *arg1 = (wxObject *) 0 ;
3274 wxString result;
3275 PyObject * obj0 = 0 ;
3276 char *kwnames[] = {
3277 (char *) "self", NULL
3278 };
3279
3280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_GetClassName",kwnames,&obj0)) goto fail;
3281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3282 if (SWIG_arg_fail(1)) SWIG_fail;
3283 {
3284 PyThreadState* __tstate = wxPyBeginAllowThreads();
3285 result = wxObject_GetClassName(arg1);
3286
3287 wxPyEndAllowThreads(__tstate);
3288 if (PyErr_Occurred()) SWIG_fail;
3289 }
3290 {
3291 #if wxUSE_UNICODE
3292 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
3293 #else
3294 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
3295 #endif
3296 }
3297 return resultobj;
3298 fail:
3299 return NULL;
3300 }
3301
3302
3303 static PyObject *_wrap_Object_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
3304 PyObject *resultobj;
3305 wxObject *arg1 = (wxObject *) 0 ;
3306 PyObject * obj0 = 0 ;
3307 char *kwnames[] = {
3308 (char *) "self", NULL
3309 };
3310
3311 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Object_Destroy",kwnames,&obj0)) goto fail;
3312 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
3313 if (SWIG_arg_fail(1)) SWIG_fail;
3314 {
3315 PyThreadState* __tstate = wxPyBeginAllowThreads();
3316 wxObject_Destroy(arg1);
3317
3318 wxPyEndAllowThreads(__tstate);
3319 if (PyErr_Occurred()) SWIG_fail;
3320 }
3321 Py_INCREF(Py_None); resultobj = Py_None;
3322 return resultobj;
3323 fail:
3324 return NULL;
3325 }
3326
3327
3328 static PyObject * Object_swigregister(PyObject *, PyObject *args) {
3329 PyObject *obj;
3330 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3331 SWIG_TypeClientData(SWIGTYPE_p_wxObject, obj);
3332 Py_INCREF(obj);
3333 return Py_BuildValue((char *)"");
3334 }
3335 static PyObject *_wrap_Size_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
3336 PyObject *resultobj;
3337 wxSize *arg1 = (wxSize *) 0 ;
3338 int arg2 ;
3339 PyObject * obj0 = 0 ;
3340 PyObject * obj1 = 0 ;
3341 char *kwnames[] = {
3342 (char *) "self",(char *) "x", NULL
3343 };
3344
3345 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_width_set",kwnames,&obj0,&obj1)) goto fail;
3346 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3347 if (SWIG_arg_fail(1)) SWIG_fail;
3348 {
3349 arg2 = (int)(SWIG_As_int(obj1));
3350 if (SWIG_arg_fail(2)) SWIG_fail;
3351 }
3352 if (arg1) (arg1)->x = arg2;
3353
3354 Py_INCREF(Py_None); resultobj = Py_None;
3355 return resultobj;
3356 fail:
3357 return NULL;
3358 }
3359
3360
3361 static PyObject *_wrap_Size_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
3362 PyObject *resultobj;
3363 wxSize *arg1 = (wxSize *) 0 ;
3364 int result;
3365 PyObject * obj0 = 0 ;
3366 char *kwnames[] = {
3367 (char *) "self", NULL
3368 };
3369
3370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_width_get",kwnames,&obj0)) goto fail;
3371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3372 if (SWIG_arg_fail(1)) SWIG_fail;
3373 result = (int) ((arg1)->x);
3374
3375 {
3376 resultobj = SWIG_From_int((int)(result));
3377 }
3378 return resultobj;
3379 fail:
3380 return NULL;
3381 }
3382
3383
3384 static PyObject *_wrap_Size_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
3385 PyObject *resultobj;
3386 wxSize *arg1 = (wxSize *) 0 ;
3387 int arg2 ;
3388 PyObject * obj0 = 0 ;
3389 PyObject * obj1 = 0 ;
3390 char *kwnames[] = {
3391 (char *) "self",(char *) "y", NULL
3392 };
3393
3394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_height_set",kwnames,&obj0,&obj1)) goto fail;
3395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3396 if (SWIG_arg_fail(1)) SWIG_fail;
3397 {
3398 arg2 = (int)(SWIG_As_int(obj1));
3399 if (SWIG_arg_fail(2)) SWIG_fail;
3400 }
3401 if (arg1) (arg1)->y = arg2;
3402
3403 Py_INCREF(Py_None); resultobj = Py_None;
3404 return resultobj;
3405 fail:
3406 return NULL;
3407 }
3408
3409
3410 static PyObject *_wrap_Size_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
3411 PyObject *resultobj;
3412 wxSize *arg1 = (wxSize *) 0 ;
3413 int result;
3414 PyObject * obj0 = 0 ;
3415 char *kwnames[] = {
3416 (char *) "self", NULL
3417 };
3418
3419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_height_get",kwnames,&obj0)) goto fail;
3420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3421 if (SWIG_arg_fail(1)) SWIG_fail;
3422 result = (int) ((arg1)->y);
3423
3424 {
3425 resultobj = SWIG_From_int((int)(result));
3426 }
3427 return resultobj;
3428 fail:
3429 return NULL;
3430 }
3431
3432
3433 static PyObject *_wrap_new_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3434 PyObject *resultobj;
3435 int arg1 = (int) 0 ;
3436 int arg2 = (int) 0 ;
3437 wxSize *result;
3438 PyObject * obj0 = 0 ;
3439 PyObject * obj1 = 0 ;
3440 char *kwnames[] = {
3441 (char *) "w",(char *) "h", NULL
3442 };
3443
3444 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) goto fail;
3445 if (obj0) {
3446 {
3447 arg1 = (int)(SWIG_As_int(obj0));
3448 if (SWIG_arg_fail(1)) SWIG_fail;
3449 }
3450 }
3451 if (obj1) {
3452 {
3453 arg2 = (int)(SWIG_As_int(obj1));
3454 if (SWIG_arg_fail(2)) SWIG_fail;
3455 }
3456 }
3457 {
3458 PyThreadState* __tstate = wxPyBeginAllowThreads();
3459 result = (wxSize *)new wxSize(arg1,arg2);
3460
3461 wxPyEndAllowThreads(__tstate);
3462 if (PyErr_Occurred()) SWIG_fail;
3463 }
3464 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 1);
3465 return resultobj;
3466 fail:
3467 return NULL;
3468 }
3469
3470
3471 static PyObject *_wrap_delete_Size(PyObject *, PyObject *args, PyObject *kwargs) {
3472 PyObject *resultobj;
3473 wxSize *arg1 = (wxSize *) 0 ;
3474 PyObject * obj0 = 0 ;
3475 char *kwnames[] = {
3476 (char *) "self", NULL
3477 };
3478
3479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Size",kwnames,&obj0)) goto fail;
3480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3481 if (SWIG_arg_fail(1)) SWIG_fail;
3482 {
3483 PyThreadState* __tstate = wxPyBeginAllowThreads();
3484 delete arg1;
3485
3486 wxPyEndAllowThreads(__tstate);
3487 if (PyErr_Occurred()) SWIG_fail;
3488 }
3489 Py_INCREF(Py_None); resultobj = Py_None;
3490 return resultobj;
3491 fail:
3492 return NULL;
3493 }
3494
3495
3496 static PyObject *_wrap_Size___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
3497 PyObject *resultobj;
3498 wxSize *arg1 = (wxSize *) 0 ;
3499 wxSize *arg2 = 0 ;
3500 bool result;
3501 wxSize temp2 ;
3502 PyObject * obj0 = 0 ;
3503 PyObject * obj1 = 0 ;
3504 char *kwnames[] = {
3505 (char *) "self",(char *) "sz", NULL
3506 };
3507
3508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) goto fail;
3509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3510 if (SWIG_arg_fail(1)) SWIG_fail;
3511 {
3512 arg2 = &temp2;
3513 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3514 }
3515 {
3516 PyThreadState* __tstate = wxPyBeginAllowThreads();
3517 result = (bool)(arg1)->operator ==((wxSize const &)*arg2);
3518
3519 wxPyEndAllowThreads(__tstate);
3520 if (PyErr_Occurred()) SWIG_fail;
3521 }
3522 {
3523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3524 }
3525 return resultobj;
3526 fail:
3527 return NULL;
3528 }
3529
3530
3531 static PyObject *_wrap_Size___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
3532 PyObject *resultobj;
3533 wxSize *arg1 = (wxSize *) 0 ;
3534 wxSize *arg2 = 0 ;
3535 bool result;
3536 wxSize temp2 ;
3537 PyObject * obj0 = 0 ;
3538 PyObject * obj1 = 0 ;
3539 char *kwnames[] = {
3540 (char *) "self",(char *) "sz", NULL
3541 };
3542
3543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) goto fail;
3544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3545 if (SWIG_arg_fail(1)) SWIG_fail;
3546 {
3547 arg2 = &temp2;
3548 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3549 }
3550 {
3551 PyThreadState* __tstate = wxPyBeginAllowThreads();
3552 result = (bool)(arg1)->operator !=((wxSize const &)*arg2);
3553
3554 wxPyEndAllowThreads(__tstate);
3555 if (PyErr_Occurred()) SWIG_fail;
3556 }
3557 {
3558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3559 }
3560 return resultobj;
3561 fail:
3562 return NULL;
3563 }
3564
3565
3566 static PyObject *_wrap_Size___add__(PyObject *, PyObject *args, PyObject *kwargs) {
3567 PyObject *resultobj;
3568 wxSize *arg1 = (wxSize *) 0 ;
3569 wxSize *arg2 = 0 ;
3570 wxSize result;
3571 wxSize temp2 ;
3572 PyObject * obj0 = 0 ;
3573 PyObject * obj1 = 0 ;
3574 char *kwnames[] = {
3575 (char *) "self",(char *) "sz", NULL
3576 };
3577
3578 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) goto fail;
3579 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3580 if (SWIG_arg_fail(1)) SWIG_fail;
3581 {
3582 arg2 = &temp2;
3583 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3584 }
3585 {
3586 PyThreadState* __tstate = wxPyBeginAllowThreads();
3587 result = (arg1)->operator +((wxSize const &)*arg2);
3588
3589 wxPyEndAllowThreads(__tstate);
3590 if (PyErr_Occurred()) SWIG_fail;
3591 }
3592 {
3593 wxSize * resultptr;
3594 resultptr = new wxSize((wxSize &)(result));
3595 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3596 }
3597 return resultobj;
3598 fail:
3599 return NULL;
3600 }
3601
3602
3603 static PyObject *_wrap_Size___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
3604 PyObject *resultobj;
3605 wxSize *arg1 = (wxSize *) 0 ;
3606 wxSize *arg2 = 0 ;
3607 wxSize result;
3608 wxSize temp2 ;
3609 PyObject * obj0 = 0 ;
3610 PyObject * obj1 = 0 ;
3611 char *kwnames[] = {
3612 (char *) "self",(char *) "sz", NULL
3613 };
3614
3615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) goto fail;
3616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3617 if (SWIG_arg_fail(1)) SWIG_fail;
3618 {
3619 arg2 = &temp2;
3620 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3621 }
3622 {
3623 PyThreadState* __tstate = wxPyBeginAllowThreads();
3624 result = (arg1)->operator -((wxSize const &)*arg2);
3625
3626 wxPyEndAllowThreads(__tstate);
3627 if (PyErr_Occurred()) SWIG_fail;
3628 }
3629 {
3630 wxSize * resultptr;
3631 resultptr = new wxSize((wxSize &)(result));
3632 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
3633 }
3634 return resultobj;
3635 fail:
3636 return NULL;
3637 }
3638
3639
3640 static PyObject *_wrap_Size_IncTo(PyObject *, PyObject *args, PyObject *kwargs) {
3641 PyObject *resultobj;
3642 wxSize *arg1 = (wxSize *) 0 ;
3643 wxSize *arg2 = 0 ;
3644 wxSize temp2 ;
3645 PyObject * obj0 = 0 ;
3646 PyObject * obj1 = 0 ;
3647 char *kwnames[] = {
3648 (char *) "self",(char *) "sz", NULL
3649 };
3650
3651 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) goto fail;
3652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3653 if (SWIG_arg_fail(1)) SWIG_fail;
3654 {
3655 arg2 = &temp2;
3656 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3657 }
3658 {
3659 PyThreadState* __tstate = wxPyBeginAllowThreads();
3660 (arg1)->IncTo((wxSize const &)*arg2);
3661
3662 wxPyEndAllowThreads(__tstate);
3663 if (PyErr_Occurred()) SWIG_fail;
3664 }
3665 Py_INCREF(Py_None); resultobj = Py_None;
3666 return resultobj;
3667 fail:
3668 return NULL;
3669 }
3670
3671
3672 static PyObject *_wrap_Size_DecTo(PyObject *, PyObject *args, PyObject *kwargs) {
3673 PyObject *resultobj;
3674 wxSize *arg1 = (wxSize *) 0 ;
3675 wxSize *arg2 = 0 ;
3676 wxSize temp2 ;
3677 PyObject * obj0 = 0 ;
3678 PyObject * obj1 = 0 ;
3679 char *kwnames[] = {
3680 (char *) "self",(char *) "sz", NULL
3681 };
3682
3683 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) goto fail;
3684 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3685 if (SWIG_arg_fail(1)) SWIG_fail;
3686 {
3687 arg2 = &temp2;
3688 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3689 }
3690 {
3691 PyThreadState* __tstate = wxPyBeginAllowThreads();
3692 (arg1)->DecTo((wxSize const &)*arg2);
3693
3694 wxPyEndAllowThreads(__tstate);
3695 if (PyErr_Occurred()) SWIG_fail;
3696 }
3697 Py_INCREF(Py_None); resultobj = Py_None;
3698 return resultobj;
3699 fail:
3700 return NULL;
3701 }
3702
3703
3704 static PyObject *_wrap_Size_Set(PyObject *, PyObject *args, PyObject *kwargs) {
3705 PyObject *resultobj;
3706 wxSize *arg1 = (wxSize *) 0 ;
3707 int arg2 ;
3708 int arg3 ;
3709 PyObject * obj0 = 0 ;
3710 PyObject * obj1 = 0 ;
3711 PyObject * obj2 = 0 ;
3712 char *kwnames[] = {
3713 (char *) "self",(char *) "w",(char *) "h", NULL
3714 };
3715
3716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
3717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3718 if (SWIG_arg_fail(1)) SWIG_fail;
3719 {
3720 arg2 = (int)(SWIG_As_int(obj1));
3721 if (SWIG_arg_fail(2)) SWIG_fail;
3722 }
3723 {
3724 arg3 = (int)(SWIG_As_int(obj2));
3725 if (SWIG_arg_fail(3)) SWIG_fail;
3726 }
3727 {
3728 PyThreadState* __tstate = wxPyBeginAllowThreads();
3729 (arg1)->Set(arg2,arg3);
3730
3731 wxPyEndAllowThreads(__tstate);
3732 if (PyErr_Occurred()) SWIG_fail;
3733 }
3734 Py_INCREF(Py_None); resultobj = Py_None;
3735 return resultobj;
3736 fail:
3737 return NULL;
3738 }
3739
3740
3741 static PyObject *_wrap_Size_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3742 PyObject *resultobj;
3743 wxSize *arg1 = (wxSize *) 0 ;
3744 int arg2 ;
3745 PyObject * obj0 = 0 ;
3746 PyObject * obj1 = 0 ;
3747 char *kwnames[] = {
3748 (char *) "self",(char *) "w", NULL
3749 };
3750
3751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) goto fail;
3752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3753 if (SWIG_arg_fail(1)) SWIG_fail;
3754 {
3755 arg2 = (int)(SWIG_As_int(obj1));
3756 if (SWIG_arg_fail(2)) SWIG_fail;
3757 }
3758 {
3759 PyThreadState* __tstate = wxPyBeginAllowThreads();
3760 (arg1)->SetWidth(arg2);
3761
3762 wxPyEndAllowThreads(__tstate);
3763 if (PyErr_Occurred()) SWIG_fail;
3764 }
3765 Py_INCREF(Py_None); resultobj = Py_None;
3766 return resultobj;
3767 fail:
3768 return NULL;
3769 }
3770
3771
3772 static PyObject *_wrap_Size_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3773 PyObject *resultobj;
3774 wxSize *arg1 = (wxSize *) 0 ;
3775 int arg2 ;
3776 PyObject * obj0 = 0 ;
3777 PyObject * obj1 = 0 ;
3778 char *kwnames[] = {
3779 (char *) "self",(char *) "h", NULL
3780 };
3781
3782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) goto fail;
3783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3784 if (SWIG_arg_fail(1)) SWIG_fail;
3785 {
3786 arg2 = (int)(SWIG_As_int(obj1));
3787 if (SWIG_arg_fail(2)) SWIG_fail;
3788 }
3789 {
3790 PyThreadState* __tstate = wxPyBeginAllowThreads();
3791 (arg1)->SetHeight(arg2);
3792
3793 wxPyEndAllowThreads(__tstate);
3794 if (PyErr_Occurred()) SWIG_fail;
3795 }
3796 Py_INCREF(Py_None); resultobj = Py_None;
3797 return resultobj;
3798 fail:
3799 return NULL;
3800 }
3801
3802
3803 static PyObject *_wrap_Size_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
3804 PyObject *resultobj;
3805 wxSize *arg1 = (wxSize *) 0 ;
3806 int result;
3807 PyObject * obj0 = 0 ;
3808 char *kwnames[] = {
3809 (char *) "self", NULL
3810 };
3811
3812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetWidth",kwnames,&obj0)) goto fail;
3813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3814 if (SWIG_arg_fail(1)) SWIG_fail;
3815 {
3816 PyThreadState* __tstate = wxPyBeginAllowThreads();
3817 result = (int)((wxSize const *)arg1)->GetWidth();
3818
3819 wxPyEndAllowThreads(__tstate);
3820 if (PyErr_Occurred()) SWIG_fail;
3821 }
3822 {
3823 resultobj = SWIG_From_int((int)(result));
3824 }
3825 return resultobj;
3826 fail:
3827 return NULL;
3828 }
3829
3830
3831 static PyObject *_wrap_Size_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
3832 PyObject *resultobj;
3833 wxSize *arg1 = (wxSize *) 0 ;
3834 int result;
3835 PyObject * obj0 = 0 ;
3836 char *kwnames[] = {
3837 (char *) "self", NULL
3838 };
3839
3840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_GetHeight",kwnames,&obj0)) goto fail;
3841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3842 if (SWIG_arg_fail(1)) SWIG_fail;
3843 {
3844 PyThreadState* __tstate = wxPyBeginAllowThreads();
3845 result = (int)((wxSize const *)arg1)->GetHeight();
3846
3847 wxPyEndAllowThreads(__tstate);
3848 if (PyErr_Occurred()) SWIG_fail;
3849 }
3850 {
3851 resultobj = SWIG_From_int((int)(result));
3852 }
3853 return resultobj;
3854 fail:
3855 return NULL;
3856 }
3857
3858
3859 static PyObject *_wrap_Size_IsFullySpecified(PyObject *, PyObject *args, PyObject *kwargs) {
3860 PyObject *resultobj;
3861 wxSize *arg1 = (wxSize *) 0 ;
3862 bool result;
3863 PyObject * obj0 = 0 ;
3864 char *kwnames[] = {
3865 (char *) "self", NULL
3866 };
3867
3868 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_IsFullySpecified",kwnames,&obj0)) goto fail;
3869 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3870 if (SWIG_arg_fail(1)) SWIG_fail;
3871 {
3872 PyThreadState* __tstate = wxPyBeginAllowThreads();
3873 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
3874
3875 wxPyEndAllowThreads(__tstate);
3876 if (PyErr_Occurred()) SWIG_fail;
3877 }
3878 {
3879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
3880 }
3881 return resultobj;
3882 fail:
3883 return NULL;
3884 }
3885
3886
3887 static PyObject *_wrap_Size_SetDefaults(PyObject *, PyObject *args, PyObject *kwargs) {
3888 PyObject *resultobj;
3889 wxSize *arg1 = (wxSize *) 0 ;
3890 wxSize *arg2 = 0 ;
3891 wxSize temp2 ;
3892 PyObject * obj0 = 0 ;
3893 PyObject * obj1 = 0 ;
3894 char *kwnames[] = {
3895 (char *) "self",(char *) "size", NULL
3896 };
3897
3898 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) goto fail;
3899 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3900 if (SWIG_arg_fail(1)) SWIG_fail;
3901 {
3902 arg2 = &temp2;
3903 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
3904 }
3905 {
3906 PyThreadState* __tstate = wxPyBeginAllowThreads();
3907 (arg1)->SetDefaults((wxSize const &)*arg2);
3908
3909 wxPyEndAllowThreads(__tstate);
3910 if (PyErr_Occurred()) SWIG_fail;
3911 }
3912 Py_INCREF(Py_None); resultobj = Py_None;
3913 return resultobj;
3914 fail:
3915 return NULL;
3916 }
3917
3918
3919 static PyObject *_wrap_Size_Get(PyObject *, PyObject *args, PyObject *kwargs) {
3920 PyObject *resultobj;
3921 wxSize *arg1 = (wxSize *) 0 ;
3922 PyObject *result;
3923 PyObject * obj0 = 0 ;
3924 char *kwnames[] = {
3925 (char *) "self", NULL
3926 };
3927
3928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Size_Get",kwnames,&obj0)) goto fail;
3929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
3930 if (SWIG_arg_fail(1)) SWIG_fail;
3931 {
3932 PyThreadState* __tstate = wxPyBeginAllowThreads();
3933 result = (PyObject *)wxSize_Get(arg1);
3934
3935 wxPyEndAllowThreads(__tstate);
3936 if (PyErr_Occurred()) SWIG_fail;
3937 }
3938 resultobj = result;
3939 return resultobj;
3940 fail:
3941 return NULL;
3942 }
3943
3944
3945 static PyObject * Size_swigregister(PyObject *, PyObject *args) {
3946 PyObject *obj;
3947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
3948 SWIG_TypeClientData(SWIGTYPE_p_wxSize, obj);
3949 Py_INCREF(obj);
3950 return Py_BuildValue((char *)"");
3951 }
3952 static PyObject *_wrap_RealPoint_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
3953 PyObject *resultobj;
3954 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3955 double arg2 ;
3956 PyObject * obj0 = 0 ;
3957 PyObject * obj1 = 0 ;
3958 char *kwnames[] = {
3959 (char *) "self",(char *) "x", NULL
3960 };
3961
3962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_x_set",kwnames,&obj0,&obj1)) goto fail;
3963 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3964 if (SWIG_arg_fail(1)) SWIG_fail;
3965 {
3966 arg2 = (double)(SWIG_As_double(obj1));
3967 if (SWIG_arg_fail(2)) SWIG_fail;
3968 }
3969 if (arg1) (arg1)->x = arg2;
3970
3971 Py_INCREF(Py_None); resultobj = Py_None;
3972 return resultobj;
3973 fail:
3974 return NULL;
3975 }
3976
3977
3978 static PyObject *_wrap_RealPoint_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
3979 PyObject *resultobj;
3980 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
3981 double result;
3982 PyObject * obj0 = 0 ;
3983 char *kwnames[] = {
3984 (char *) "self", NULL
3985 };
3986
3987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_x_get",kwnames,&obj0)) goto fail;
3988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
3989 if (SWIG_arg_fail(1)) SWIG_fail;
3990 result = (double) ((arg1)->x);
3991
3992 {
3993 resultobj = SWIG_From_double((double)(result));
3994 }
3995 return resultobj;
3996 fail:
3997 return NULL;
3998 }
3999
4000
4001 static PyObject *_wrap_RealPoint_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4002 PyObject *resultobj;
4003 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4004 double arg2 ;
4005 PyObject * obj0 = 0 ;
4006 PyObject * obj1 = 0 ;
4007 char *kwnames[] = {
4008 (char *) "self",(char *) "y", NULL
4009 };
4010
4011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint_y_set",kwnames,&obj0,&obj1)) goto fail;
4012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4013 if (SWIG_arg_fail(1)) SWIG_fail;
4014 {
4015 arg2 = (double)(SWIG_As_double(obj1));
4016 if (SWIG_arg_fail(2)) SWIG_fail;
4017 }
4018 if (arg1) (arg1)->y = arg2;
4019
4020 Py_INCREF(Py_None); resultobj = Py_None;
4021 return resultobj;
4022 fail:
4023 return NULL;
4024 }
4025
4026
4027 static PyObject *_wrap_RealPoint_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4028 PyObject *resultobj;
4029 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4030 double result;
4031 PyObject * obj0 = 0 ;
4032 char *kwnames[] = {
4033 (char *) "self", NULL
4034 };
4035
4036 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_y_get",kwnames,&obj0)) goto fail;
4037 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4038 if (SWIG_arg_fail(1)) SWIG_fail;
4039 result = (double) ((arg1)->y);
4040
4041 {
4042 resultobj = SWIG_From_double((double)(result));
4043 }
4044 return resultobj;
4045 fail:
4046 return NULL;
4047 }
4048
4049
4050 static PyObject *_wrap_new_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4051 PyObject *resultobj;
4052 double arg1 = (double) 0.0 ;
4053 double arg2 = (double) 0.0 ;
4054 wxRealPoint *result;
4055 PyObject * obj0 = 0 ;
4056 PyObject * obj1 = 0 ;
4057 char *kwnames[] = {
4058 (char *) "x",(char *) "y", NULL
4059 };
4060
4061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) goto fail;
4062 if (obj0) {
4063 {
4064 arg1 = (double)(SWIG_As_double(obj0));
4065 if (SWIG_arg_fail(1)) SWIG_fail;
4066 }
4067 }
4068 if (obj1) {
4069 {
4070 arg2 = (double)(SWIG_As_double(obj1));
4071 if (SWIG_arg_fail(2)) SWIG_fail;
4072 }
4073 }
4074 {
4075 PyThreadState* __tstate = wxPyBeginAllowThreads();
4076 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
4077
4078 wxPyEndAllowThreads(__tstate);
4079 if (PyErr_Occurred()) SWIG_fail;
4080 }
4081 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRealPoint, 1);
4082 return resultobj;
4083 fail:
4084 return NULL;
4085 }
4086
4087
4088 static PyObject *_wrap_delete_RealPoint(PyObject *, PyObject *args, PyObject *kwargs) {
4089 PyObject *resultobj;
4090 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4091 PyObject * obj0 = 0 ;
4092 char *kwnames[] = {
4093 (char *) "self", NULL
4094 };
4095
4096 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_RealPoint",kwnames,&obj0)) goto fail;
4097 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4098 if (SWIG_arg_fail(1)) SWIG_fail;
4099 {
4100 PyThreadState* __tstate = wxPyBeginAllowThreads();
4101 delete arg1;
4102
4103 wxPyEndAllowThreads(__tstate);
4104 if (PyErr_Occurred()) SWIG_fail;
4105 }
4106 Py_INCREF(Py_None); resultobj = Py_None;
4107 return resultobj;
4108 fail:
4109 return NULL;
4110 }
4111
4112
4113 static PyObject *_wrap_RealPoint___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4114 PyObject *resultobj;
4115 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4116 wxRealPoint *arg2 = 0 ;
4117 bool result;
4118 wxRealPoint temp2 ;
4119 PyObject * obj0 = 0 ;
4120 PyObject * obj1 = 0 ;
4121 char *kwnames[] = {
4122 (char *) "self",(char *) "pt", NULL
4123 };
4124
4125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) goto fail;
4126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4127 if (SWIG_arg_fail(1)) SWIG_fail;
4128 {
4129 arg2 = &temp2;
4130 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4131 }
4132 {
4133 PyThreadState* __tstate = wxPyBeginAllowThreads();
4134 result = (bool)(arg1)->operator ==((wxRealPoint const &)*arg2);
4135
4136 wxPyEndAllowThreads(__tstate);
4137 if (PyErr_Occurred()) SWIG_fail;
4138 }
4139 {
4140 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4141 }
4142 return resultobj;
4143 fail:
4144 return NULL;
4145 }
4146
4147
4148 static PyObject *_wrap_RealPoint___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4149 PyObject *resultobj;
4150 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4151 wxRealPoint *arg2 = 0 ;
4152 bool result;
4153 wxRealPoint temp2 ;
4154 PyObject * obj0 = 0 ;
4155 PyObject * obj1 = 0 ;
4156 char *kwnames[] = {
4157 (char *) "self",(char *) "pt", NULL
4158 };
4159
4160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) goto fail;
4161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4162 if (SWIG_arg_fail(1)) SWIG_fail;
4163 {
4164 arg2 = &temp2;
4165 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4166 }
4167 {
4168 PyThreadState* __tstate = wxPyBeginAllowThreads();
4169 result = (bool)(arg1)->operator !=((wxRealPoint const &)*arg2);
4170
4171 wxPyEndAllowThreads(__tstate);
4172 if (PyErr_Occurred()) SWIG_fail;
4173 }
4174 {
4175 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4176 }
4177 return resultobj;
4178 fail:
4179 return NULL;
4180 }
4181
4182
4183 static PyObject *_wrap_RealPoint___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4184 PyObject *resultobj;
4185 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4186 wxRealPoint *arg2 = 0 ;
4187 wxRealPoint result;
4188 wxRealPoint temp2 ;
4189 PyObject * obj0 = 0 ;
4190 PyObject * obj1 = 0 ;
4191 char *kwnames[] = {
4192 (char *) "self",(char *) "pt", NULL
4193 };
4194
4195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) goto fail;
4196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4197 if (SWIG_arg_fail(1)) SWIG_fail;
4198 {
4199 arg2 = &temp2;
4200 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4201 }
4202 {
4203 PyThreadState* __tstate = wxPyBeginAllowThreads();
4204 result = (arg1)->operator +((wxRealPoint const &)*arg2);
4205
4206 wxPyEndAllowThreads(__tstate);
4207 if (PyErr_Occurred()) SWIG_fail;
4208 }
4209 {
4210 wxRealPoint * resultptr;
4211 resultptr = new wxRealPoint((wxRealPoint &)(result));
4212 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4213 }
4214 return resultobj;
4215 fail:
4216 return NULL;
4217 }
4218
4219
4220 static PyObject *_wrap_RealPoint___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4221 PyObject *resultobj;
4222 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4223 wxRealPoint *arg2 = 0 ;
4224 wxRealPoint result;
4225 wxRealPoint temp2 ;
4226 PyObject * obj0 = 0 ;
4227 PyObject * obj1 = 0 ;
4228 char *kwnames[] = {
4229 (char *) "self",(char *) "pt", NULL
4230 };
4231
4232 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) goto fail;
4233 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4234 if (SWIG_arg_fail(1)) SWIG_fail;
4235 {
4236 arg2 = &temp2;
4237 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
4238 }
4239 {
4240 PyThreadState* __tstate = wxPyBeginAllowThreads();
4241 result = (arg1)->operator -((wxRealPoint const &)*arg2);
4242
4243 wxPyEndAllowThreads(__tstate);
4244 if (PyErr_Occurred()) SWIG_fail;
4245 }
4246 {
4247 wxRealPoint * resultptr;
4248 resultptr = new wxRealPoint((wxRealPoint &)(result));
4249 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRealPoint, 1);
4250 }
4251 return resultobj;
4252 fail:
4253 return NULL;
4254 }
4255
4256
4257 static PyObject *_wrap_RealPoint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4258 PyObject *resultobj;
4259 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4260 double arg2 ;
4261 double arg3 ;
4262 PyObject * obj0 = 0 ;
4263 PyObject * obj1 = 0 ;
4264 PyObject * obj2 = 0 ;
4265 char *kwnames[] = {
4266 (char *) "self",(char *) "x",(char *) "y", NULL
4267 };
4268
4269 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4270 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4271 if (SWIG_arg_fail(1)) SWIG_fail;
4272 {
4273 arg2 = (double)(SWIG_As_double(obj1));
4274 if (SWIG_arg_fail(2)) SWIG_fail;
4275 }
4276 {
4277 arg3 = (double)(SWIG_As_double(obj2));
4278 if (SWIG_arg_fail(3)) SWIG_fail;
4279 }
4280 {
4281 PyThreadState* __tstate = wxPyBeginAllowThreads();
4282 wxRealPoint_Set(arg1,arg2,arg3);
4283
4284 wxPyEndAllowThreads(__tstate);
4285 if (PyErr_Occurred()) SWIG_fail;
4286 }
4287 Py_INCREF(Py_None); resultobj = Py_None;
4288 return resultobj;
4289 fail:
4290 return NULL;
4291 }
4292
4293
4294 static PyObject *_wrap_RealPoint_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4295 PyObject *resultobj;
4296 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
4297 PyObject *result;
4298 PyObject * obj0 = 0 ;
4299 char *kwnames[] = {
4300 (char *) "self", NULL
4301 };
4302
4303 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:RealPoint_Get",kwnames,&obj0)) goto fail;
4304 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRealPoint, SWIG_POINTER_EXCEPTION | 0);
4305 if (SWIG_arg_fail(1)) SWIG_fail;
4306 {
4307 PyThreadState* __tstate = wxPyBeginAllowThreads();
4308 result = (PyObject *)wxRealPoint_Get(arg1);
4309
4310 wxPyEndAllowThreads(__tstate);
4311 if (PyErr_Occurred()) SWIG_fail;
4312 }
4313 resultobj = result;
4314 return resultobj;
4315 fail:
4316 return NULL;
4317 }
4318
4319
4320 static PyObject * RealPoint_swigregister(PyObject *, PyObject *args) {
4321 PyObject *obj;
4322 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4323 SWIG_TypeClientData(SWIGTYPE_p_wxRealPoint, obj);
4324 Py_INCREF(obj);
4325 return Py_BuildValue((char *)"");
4326 }
4327 static PyObject *_wrap_Point_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
4328 PyObject *resultobj;
4329 wxPoint *arg1 = (wxPoint *) 0 ;
4330 int arg2 ;
4331 PyObject * obj0 = 0 ;
4332 PyObject * obj1 = 0 ;
4333 char *kwnames[] = {
4334 (char *) "self",(char *) "x", NULL
4335 };
4336
4337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_x_set",kwnames,&obj0,&obj1)) goto fail;
4338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4339 if (SWIG_arg_fail(1)) SWIG_fail;
4340 {
4341 arg2 = (int)(SWIG_As_int(obj1));
4342 if (SWIG_arg_fail(2)) SWIG_fail;
4343 }
4344 if (arg1) (arg1)->x = arg2;
4345
4346 Py_INCREF(Py_None); resultobj = Py_None;
4347 return resultobj;
4348 fail:
4349 return NULL;
4350 }
4351
4352
4353 static PyObject *_wrap_Point_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
4354 PyObject *resultobj;
4355 wxPoint *arg1 = (wxPoint *) 0 ;
4356 int result;
4357 PyObject * obj0 = 0 ;
4358 char *kwnames[] = {
4359 (char *) "self", NULL
4360 };
4361
4362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_x_get",kwnames,&obj0)) goto fail;
4363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4364 if (SWIG_arg_fail(1)) SWIG_fail;
4365 result = (int) ((arg1)->x);
4366
4367 {
4368 resultobj = SWIG_From_int((int)(result));
4369 }
4370 return resultobj;
4371 fail:
4372 return NULL;
4373 }
4374
4375
4376 static PyObject *_wrap_Point_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
4377 PyObject *resultobj;
4378 wxPoint *arg1 = (wxPoint *) 0 ;
4379 int arg2 ;
4380 PyObject * obj0 = 0 ;
4381 PyObject * obj1 = 0 ;
4382 char *kwnames[] = {
4383 (char *) "self",(char *) "y", NULL
4384 };
4385
4386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point_y_set",kwnames,&obj0,&obj1)) goto fail;
4387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4388 if (SWIG_arg_fail(1)) SWIG_fail;
4389 {
4390 arg2 = (int)(SWIG_As_int(obj1));
4391 if (SWIG_arg_fail(2)) SWIG_fail;
4392 }
4393 if (arg1) (arg1)->y = arg2;
4394
4395 Py_INCREF(Py_None); resultobj = Py_None;
4396 return resultobj;
4397 fail:
4398 return NULL;
4399 }
4400
4401
4402 static PyObject *_wrap_Point_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
4403 PyObject *resultobj;
4404 wxPoint *arg1 = (wxPoint *) 0 ;
4405 int result;
4406 PyObject * obj0 = 0 ;
4407 char *kwnames[] = {
4408 (char *) "self", NULL
4409 };
4410
4411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_y_get",kwnames,&obj0)) goto fail;
4412 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4413 if (SWIG_arg_fail(1)) SWIG_fail;
4414 result = (int) ((arg1)->y);
4415
4416 {
4417 resultobj = SWIG_From_int((int)(result));
4418 }
4419 return resultobj;
4420 fail:
4421 return NULL;
4422 }
4423
4424
4425 static PyObject *_wrap_new_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4426 PyObject *resultobj;
4427 int arg1 = (int) 0 ;
4428 int arg2 = (int) 0 ;
4429 wxPoint *result;
4430 PyObject * obj0 = 0 ;
4431 PyObject * obj1 = 0 ;
4432 char *kwnames[] = {
4433 (char *) "x",(char *) "y", NULL
4434 };
4435
4436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) goto fail;
4437 if (obj0) {
4438 {
4439 arg1 = (int)(SWIG_As_int(obj0));
4440 if (SWIG_arg_fail(1)) SWIG_fail;
4441 }
4442 }
4443 if (obj1) {
4444 {
4445 arg2 = (int)(SWIG_As_int(obj1));
4446 if (SWIG_arg_fail(2)) SWIG_fail;
4447 }
4448 }
4449 {
4450 PyThreadState* __tstate = wxPyBeginAllowThreads();
4451 result = (wxPoint *)new wxPoint(arg1,arg2);
4452
4453 wxPyEndAllowThreads(__tstate);
4454 if (PyErr_Occurred()) SWIG_fail;
4455 }
4456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4457 return resultobj;
4458 fail:
4459 return NULL;
4460 }
4461
4462
4463 static PyObject *_wrap_delete_Point(PyObject *, PyObject *args, PyObject *kwargs) {
4464 PyObject *resultobj;
4465 wxPoint *arg1 = (wxPoint *) 0 ;
4466 PyObject * obj0 = 0 ;
4467 char *kwnames[] = {
4468 (char *) "self", NULL
4469 };
4470
4471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Point",kwnames,&obj0)) goto fail;
4472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4473 if (SWIG_arg_fail(1)) SWIG_fail;
4474 {
4475 PyThreadState* __tstate = wxPyBeginAllowThreads();
4476 delete arg1;
4477
4478 wxPyEndAllowThreads(__tstate);
4479 if (PyErr_Occurred()) SWIG_fail;
4480 }
4481 Py_INCREF(Py_None); resultobj = Py_None;
4482 return resultobj;
4483 fail:
4484 return NULL;
4485 }
4486
4487
4488 static PyObject *_wrap_Point___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
4489 PyObject *resultobj;
4490 wxPoint *arg1 = (wxPoint *) 0 ;
4491 wxPoint *arg2 = 0 ;
4492 bool result;
4493 wxPoint temp2 ;
4494 PyObject * obj0 = 0 ;
4495 PyObject * obj1 = 0 ;
4496 char *kwnames[] = {
4497 (char *) "self",(char *) "pt", NULL
4498 };
4499
4500 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) goto fail;
4501 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4502 if (SWIG_arg_fail(1)) SWIG_fail;
4503 {
4504 arg2 = &temp2;
4505 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4506 }
4507 {
4508 PyThreadState* __tstate = wxPyBeginAllowThreads();
4509 result = (bool)(arg1)->operator ==((wxPoint const &)*arg2);
4510
4511 wxPyEndAllowThreads(__tstate);
4512 if (PyErr_Occurred()) SWIG_fail;
4513 }
4514 {
4515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4516 }
4517 return resultobj;
4518 fail:
4519 return NULL;
4520 }
4521
4522
4523 static PyObject *_wrap_Point___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
4524 PyObject *resultobj;
4525 wxPoint *arg1 = (wxPoint *) 0 ;
4526 wxPoint *arg2 = 0 ;
4527 bool result;
4528 wxPoint temp2 ;
4529 PyObject * obj0 = 0 ;
4530 PyObject * obj1 = 0 ;
4531 char *kwnames[] = {
4532 (char *) "self",(char *) "pt", NULL
4533 };
4534
4535 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) goto fail;
4536 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4537 if (SWIG_arg_fail(1)) SWIG_fail;
4538 {
4539 arg2 = &temp2;
4540 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4541 }
4542 {
4543 PyThreadState* __tstate = wxPyBeginAllowThreads();
4544 result = (bool)(arg1)->operator !=((wxPoint const &)*arg2);
4545
4546 wxPyEndAllowThreads(__tstate);
4547 if (PyErr_Occurred()) SWIG_fail;
4548 }
4549 {
4550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4551 }
4552 return resultobj;
4553 fail:
4554 return NULL;
4555 }
4556
4557
4558 static PyObject *_wrap_Point___add__(PyObject *, PyObject *args, PyObject *kwargs) {
4559 PyObject *resultobj;
4560 wxPoint *arg1 = (wxPoint *) 0 ;
4561 wxPoint *arg2 = 0 ;
4562 wxPoint result;
4563 wxPoint temp2 ;
4564 PyObject * obj0 = 0 ;
4565 PyObject * obj1 = 0 ;
4566 char *kwnames[] = {
4567 (char *) "self",(char *) "pt", NULL
4568 };
4569
4570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) goto fail;
4571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4572 if (SWIG_arg_fail(1)) SWIG_fail;
4573 {
4574 arg2 = &temp2;
4575 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4576 }
4577 {
4578 PyThreadState* __tstate = wxPyBeginAllowThreads();
4579 result = (arg1)->operator +((wxPoint const &)*arg2);
4580
4581 wxPyEndAllowThreads(__tstate);
4582 if (PyErr_Occurred()) SWIG_fail;
4583 }
4584 {
4585 wxPoint * resultptr;
4586 resultptr = new wxPoint((wxPoint &)(result));
4587 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4588 }
4589 return resultobj;
4590 fail:
4591 return NULL;
4592 }
4593
4594
4595 static PyObject *_wrap_Point___sub__(PyObject *, PyObject *args, PyObject *kwargs) {
4596 PyObject *resultobj;
4597 wxPoint *arg1 = (wxPoint *) 0 ;
4598 wxPoint *arg2 = 0 ;
4599 wxPoint result;
4600 wxPoint temp2 ;
4601 PyObject * obj0 = 0 ;
4602 PyObject * obj1 = 0 ;
4603 char *kwnames[] = {
4604 (char *) "self",(char *) "pt", NULL
4605 };
4606
4607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) goto fail;
4608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4609 if (SWIG_arg_fail(1)) SWIG_fail;
4610 {
4611 arg2 = &temp2;
4612 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4613 }
4614 {
4615 PyThreadState* __tstate = wxPyBeginAllowThreads();
4616 result = (arg1)->operator -((wxPoint const &)*arg2);
4617
4618 wxPyEndAllowThreads(__tstate);
4619 if (PyErr_Occurred()) SWIG_fail;
4620 }
4621 {
4622 wxPoint * resultptr;
4623 resultptr = new wxPoint((wxPoint &)(result));
4624 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
4625 }
4626 return resultobj;
4627 fail:
4628 return NULL;
4629 }
4630
4631
4632 static PyObject *_wrap_Point___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
4633 PyObject *resultobj;
4634 wxPoint *arg1 = (wxPoint *) 0 ;
4635 wxPoint *arg2 = 0 ;
4636 wxPoint *result;
4637 wxPoint temp2 ;
4638 PyObject * obj0 = 0 ;
4639 PyObject * obj1 = 0 ;
4640 char *kwnames[] = {
4641 (char *) "self",(char *) "pt", NULL
4642 };
4643
4644 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) goto fail;
4645 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4646 if (SWIG_arg_fail(1)) SWIG_fail;
4647 {
4648 arg2 = &temp2;
4649 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4650 }
4651 {
4652 PyThreadState* __tstate = wxPyBeginAllowThreads();
4653 {
4654 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
4655 result = (wxPoint *) &_result_ref;
4656 }
4657
4658 wxPyEndAllowThreads(__tstate);
4659 if (PyErr_Occurred()) SWIG_fail;
4660 }
4661 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4662 return resultobj;
4663 fail:
4664 return NULL;
4665 }
4666
4667
4668 static PyObject *_wrap_Point___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
4669 PyObject *resultobj;
4670 wxPoint *arg1 = (wxPoint *) 0 ;
4671 wxPoint *arg2 = 0 ;
4672 wxPoint *result;
4673 wxPoint temp2 ;
4674 PyObject * obj0 = 0 ;
4675 PyObject * obj1 = 0 ;
4676 char *kwnames[] = {
4677 (char *) "self",(char *) "pt", NULL
4678 };
4679
4680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) goto fail;
4681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
4682 if (SWIG_arg_fail(1)) SWIG_fail;
4683 {
4684 arg2 = &temp2;
4685 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4686 }
4687 {
4688 PyThreadState* __tstate = wxPyBeginAllowThreads();
4689 {
4690 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
4691 result = (wxPoint *) &_result_ref;
4692 }
4693
4694 wxPyEndAllowThreads(__tstate);
4695 if (PyErr_Occurred()) SWIG_fail;
4696 }
4697 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 1);
4698 return resultobj;
4699 fail:
4700 return NULL;
4701 }
4702
4703
4704 static PyObject *_wrap_Point_Set(PyObject *, PyObject *args, PyObject *kwargs) {
4705 PyObject *resultobj;
4706 wxPoint *arg1 = (wxPoint *) 0 ;
4707 long arg2 ;
4708 long arg3 ;
4709 PyObject * obj0 = 0 ;
4710 PyObject * obj1 = 0 ;
4711 PyObject * obj2 = 0 ;
4712 char *kwnames[] = {
4713 (char *) "self",(char *) "x",(char *) "y", NULL
4714 };
4715
4716 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
4717 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4718 if (SWIG_arg_fail(1)) SWIG_fail;
4719 {
4720 arg2 = (long)(SWIG_As_long(obj1));
4721 if (SWIG_arg_fail(2)) SWIG_fail;
4722 }
4723 {
4724 arg3 = (long)(SWIG_As_long(obj2));
4725 if (SWIG_arg_fail(3)) SWIG_fail;
4726 }
4727 {
4728 PyThreadState* __tstate = wxPyBeginAllowThreads();
4729 wxPoint_Set(arg1,arg2,arg3);
4730
4731 wxPyEndAllowThreads(__tstate);
4732 if (PyErr_Occurred()) SWIG_fail;
4733 }
4734 Py_INCREF(Py_None); resultobj = Py_None;
4735 return resultobj;
4736 fail:
4737 return NULL;
4738 }
4739
4740
4741 static PyObject *_wrap_Point_Get(PyObject *, PyObject *args, PyObject *kwargs) {
4742 PyObject *resultobj;
4743 wxPoint *arg1 = (wxPoint *) 0 ;
4744 PyObject *result;
4745 PyObject * obj0 = 0 ;
4746 char *kwnames[] = {
4747 (char *) "self", NULL
4748 };
4749
4750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point_Get",kwnames,&obj0)) goto fail;
4751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
4752 if (SWIG_arg_fail(1)) SWIG_fail;
4753 {
4754 PyThreadState* __tstate = wxPyBeginAllowThreads();
4755 result = (PyObject *)wxPoint_Get(arg1);
4756
4757 wxPyEndAllowThreads(__tstate);
4758 if (PyErr_Occurred()) SWIG_fail;
4759 }
4760 resultobj = result;
4761 return resultobj;
4762 fail:
4763 return NULL;
4764 }
4765
4766
4767 static PyObject * Point_swigregister(PyObject *, PyObject *args) {
4768 PyObject *obj;
4769 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
4770 SWIG_TypeClientData(SWIGTYPE_p_wxPoint, obj);
4771 Py_INCREF(obj);
4772 return Py_BuildValue((char *)"");
4773 }
4774 static PyObject *_wrap_new_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4775 PyObject *resultobj;
4776 int arg1 = (int) 0 ;
4777 int arg2 = (int) 0 ;
4778 int arg3 = (int) 0 ;
4779 int arg4 = (int) 0 ;
4780 wxRect *result;
4781 PyObject * obj0 = 0 ;
4782 PyObject * obj1 = 0 ;
4783 PyObject * obj2 = 0 ;
4784 PyObject * obj3 = 0 ;
4785 char *kwnames[] = {
4786 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
4787 };
4788
4789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
4790 if (obj0) {
4791 {
4792 arg1 = (int)(SWIG_As_int(obj0));
4793 if (SWIG_arg_fail(1)) SWIG_fail;
4794 }
4795 }
4796 if (obj1) {
4797 {
4798 arg2 = (int)(SWIG_As_int(obj1));
4799 if (SWIG_arg_fail(2)) SWIG_fail;
4800 }
4801 }
4802 if (obj2) {
4803 {
4804 arg3 = (int)(SWIG_As_int(obj2));
4805 if (SWIG_arg_fail(3)) SWIG_fail;
4806 }
4807 }
4808 if (obj3) {
4809 {
4810 arg4 = (int)(SWIG_As_int(obj3));
4811 if (SWIG_arg_fail(4)) SWIG_fail;
4812 }
4813 }
4814 {
4815 PyThreadState* __tstate = wxPyBeginAllowThreads();
4816 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
4817
4818 wxPyEndAllowThreads(__tstate);
4819 if (PyErr_Occurred()) SWIG_fail;
4820 }
4821 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4822 return resultobj;
4823 fail:
4824 return NULL;
4825 }
4826
4827
4828 static PyObject *_wrap_new_RectPP(PyObject *, PyObject *args, PyObject *kwargs) {
4829 PyObject *resultobj;
4830 wxPoint *arg1 = 0 ;
4831 wxPoint *arg2 = 0 ;
4832 wxRect *result;
4833 wxPoint temp1 ;
4834 wxPoint temp2 ;
4835 PyObject * obj0 = 0 ;
4836 PyObject * obj1 = 0 ;
4837 char *kwnames[] = {
4838 (char *) "topLeft",(char *) "bottomRight", NULL
4839 };
4840
4841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) goto fail;
4842 {
4843 arg1 = &temp1;
4844 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4845 }
4846 {
4847 arg2 = &temp2;
4848 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
4849 }
4850 {
4851 PyThreadState* __tstate = wxPyBeginAllowThreads();
4852 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
4853
4854 wxPyEndAllowThreads(__tstate);
4855 if (PyErr_Occurred()) SWIG_fail;
4856 }
4857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4858 return resultobj;
4859 fail:
4860 return NULL;
4861 }
4862
4863
4864 static PyObject *_wrap_new_RectPS(PyObject *, PyObject *args, PyObject *kwargs) {
4865 PyObject *resultobj;
4866 wxPoint *arg1 = 0 ;
4867 wxSize *arg2 = 0 ;
4868 wxRect *result;
4869 wxPoint temp1 ;
4870 wxSize temp2 ;
4871 PyObject * obj0 = 0 ;
4872 PyObject * obj1 = 0 ;
4873 char *kwnames[] = {
4874 (char *) "pos",(char *) "size", NULL
4875 };
4876
4877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) goto fail;
4878 {
4879 arg1 = &temp1;
4880 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
4881 }
4882 {
4883 arg2 = &temp2;
4884 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4885 }
4886 {
4887 PyThreadState* __tstate = wxPyBeginAllowThreads();
4888 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
4889
4890 wxPyEndAllowThreads(__tstate);
4891 if (PyErr_Occurred()) SWIG_fail;
4892 }
4893 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4894 return resultobj;
4895 fail:
4896 return NULL;
4897 }
4898
4899
4900 static PyObject *_wrap_new_RectS(PyObject *, PyObject *args, PyObject *kwargs) {
4901 PyObject *resultobj;
4902 wxSize *arg1 = 0 ;
4903 wxRect *result;
4904 wxSize temp1 ;
4905 PyObject * obj0 = 0 ;
4906 char *kwnames[] = {
4907 (char *) "size", NULL
4908 };
4909
4910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) goto fail;
4911 {
4912 arg1 = &temp1;
4913 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
4914 }
4915 {
4916 PyThreadState* __tstate = wxPyBeginAllowThreads();
4917 result = (wxRect *)new wxRect((wxSize const &)*arg1);
4918
4919 wxPyEndAllowThreads(__tstate);
4920 if (PyErr_Occurred()) SWIG_fail;
4921 }
4922 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
4923 return resultobj;
4924 fail:
4925 return NULL;
4926 }
4927
4928
4929 static PyObject *_wrap_delete_Rect(PyObject *, PyObject *args, PyObject *kwargs) {
4930 PyObject *resultobj;
4931 wxRect *arg1 = (wxRect *) 0 ;
4932 PyObject * obj0 = 0 ;
4933 char *kwnames[] = {
4934 (char *) "self", NULL
4935 };
4936
4937 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Rect",kwnames,&obj0)) goto fail;
4938 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4939 if (SWIG_arg_fail(1)) SWIG_fail;
4940 {
4941 PyThreadState* __tstate = wxPyBeginAllowThreads();
4942 delete arg1;
4943
4944 wxPyEndAllowThreads(__tstate);
4945 if (PyErr_Occurred()) SWIG_fail;
4946 }
4947 Py_INCREF(Py_None); resultobj = Py_None;
4948 return resultobj;
4949 fail:
4950 return NULL;
4951 }
4952
4953
4954 static PyObject *_wrap_Rect_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
4955 PyObject *resultobj;
4956 wxRect *arg1 = (wxRect *) 0 ;
4957 int result;
4958 PyObject * obj0 = 0 ;
4959 char *kwnames[] = {
4960 (char *) "self", NULL
4961 };
4962
4963 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetX",kwnames,&obj0)) goto fail;
4964 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4965 if (SWIG_arg_fail(1)) SWIG_fail;
4966 {
4967 PyThreadState* __tstate = wxPyBeginAllowThreads();
4968 result = (int)((wxRect const *)arg1)->GetX();
4969
4970 wxPyEndAllowThreads(__tstate);
4971 if (PyErr_Occurred()) SWIG_fail;
4972 }
4973 {
4974 resultobj = SWIG_From_int((int)(result));
4975 }
4976 return resultobj;
4977 fail:
4978 return NULL;
4979 }
4980
4981
4982 static PyObject *_wrap_Rect_SetX(PyObject *, PyObject *args, PyObject *kwargs) {
4983 PyObject *resultobj;
4984 wxRect *arg1 = (wxRect *) 0 ;
4985 int arg2 ;
4986 PyObject * obj0 = 0 ;
4987 PyObject * obj1 = 0 ;
4988 char *kwnames[] = {
4989 (char *) "self",(char *) "x", NULL
4990 };
4991
4992 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) goto fail;
4993 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
4994 if (SWIG_arg_fail(1)) SWIG_fail;
4995 {
4996 arg2 = (int)(SWIG_As_int(obj1));
4997 if (SWIG_arg_fail(2)) SWIG_fail;
4998 }
4999 {
5000 PyThreadState* __tstate = wxPyBeginAllowThreads();
5001 (arg1)->SetX(arg2);
5002
5003 wxPyEndAllowThreads(__tstate);
5004 if (PyErr_Occurred()) SWIG_fail;
5005 }
5006 Py_INCREF(Py_None); resultobj = Py_None;
5007 return resultobj;
5008 fail:
5009 return NULL;
5010 }
5011
5012
5013 static PyObject *_wrap_Rect_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
5014 PyObject *resultobj;
5015 wxRect *arg1 = (wxRect *) 0 ;
5016 int result;
5017 PyObject * obj0 = 0 ;
5018 char *kwnames[] = {
5019 (char *) "self", NULL
5020 };
5021
5022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetY",kwnames,&obj0)) goto fail;
5023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5024 if (SWIG_arg_fail(1)) SWIG_fail;
5025 {
5026 PyThreadState* __tstate = wxPyBeginAllowThreads();
5027 result = (int)(arg1)->GetY();
5028
5029 wxPyEndAllowThreads(__tstate);
5030 if (PyErr_Occurred()) SWIG_fail;
5031 }
5032 {
5033 resultobj = SWIG_From_int((int)(result));
5034 }
5035 return resultobj;
5036 fail:
5037 return NULL;
5038 }
5039
5040
5041 static PyObject *_wrap_Rect_SetY(PyObject *, PyObject *args, PyObject *kwargs) {
5042 PyObject *resultobj;
5043 wxRect *arg1 = (wxRect *) 0 ;
5044 int arg2 ;
5045 PyObject * obj0 = 0 ;
5046 PyObject * obj1 = 0 ;
5047 char *kwnames[] = {
5048 (char *) "self",(char *) "y", NULL
5049 };
5050
5051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) goto fail;
5052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5053 if (SWIG_arg_fail(1)) SWIG_fail;
5054 {
5055 arg2 = (int)(SWIG_As_int(obj1));
5056 if (SWIG_arg_fail(2)) SWIG_fail;
5057 }
5058 {
5059 PyThreadState* __tstate = wxPyBeginAllowThreads();
5060 (arg1)->SetY(arg2);
5061
5062 wxPyEndAllowThreads(__tstate);
5063 if (PyErr_Occurred()) SWIG_fail;
5064 }
5065 Py_INCREF(Py_None); resultobj = Py_None;
5066 return resultobj;
5067 fail:
5068 return NULL;
5069 }
5070
5071
5072 static PyObject *_wrap_Rect_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5073 PyObject *resultobj;
5074 wxRect *arg1 = (wxRect *) 0 ;
5075 int result;
5076 PyObject * obj0 = 0 ;
5077 char *kwnames[] = {
5078 (char *) "self", NULL
5079 };
5080
5081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetWidth",kwnames,&obj0)) goto fail;
5082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5083 if (SWIG_arg_fail(1)) SWIG_fail;
5084 {
5085 PyThreadState* __tstate = wxPyBeginAllowThreads();
5086 result = (int)((wxRect const *)arg1)->GetWidth();
5087
5088 wxPyEndAllowThreads(__tstate);
5089 if (PyErr_Occurred()) SWIG_fail;
5090 }
5091 {
5092 resultobj = SWIG_From_int((int)(result));
5093 }
5094 return resultobj;
5095 fail:
5096 return NULL;
5097 }
5098
5099
5100 static PyObject *_wrap_Rect_SetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
5101 PyObject *resultobj;
5102 wxRect *arg1 = (wxRect *) 0 ;
5103 int arg2 ;
5104 PyObject * obj0 = 0 ;
5105 PyObject * obj1 = 0 ;
5106 char *kwnames[] = {
5107 (char *) "self",(char *) "w", NULL
5108 };
5109
5110 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) goto fail;
5111 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5112 if (SWIG_arg_fail(1)) SWIG_fail;
5113 {
5114 arg2 = (int)(SWIG_As_int(obj1));
5115 if (SWIG_arg_fail(2)) SWIG_fail;
5116 }
5117 {
5118 PyThreadState* __tstate = wxPyBeginAllowThreads();
5119 (arg1)->SetWidth(arg2);
5120
5121 wxPyEndAllowThreads(__tstate);
5122 if (PyErr_Occurred()) SWIG_fail;
5123 }
5124 Py_INCREF(Py_None); resultobj = Py_None;
5125 return resultobj;
5126 fail:
5127 return NULL;
5128 }
5129
5130
5131 static PyObject *_wrap_Rect_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5132 PyObject *resultobj;
5133 wxRect *arg1 = (wxRect *) 0 ;
5134 int result;
5135 PyObject * obj0 = 0 ;
5136 char *kwnames[] = {
5137 (char *) "self", NULL
5138 };
5139
5140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetHeight",kwnames,&obj0)) goto fail;
5141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5142 if (SWIG_arg_fail(1)) SWIG_fail;
5143 {
5144 PyThreadState* __tstate = wxPyBeginAllowThreads();
5145 result = (int)((wxRect const *)arg1)->GetHeight();
5146
5147 wxPyEndAllowThreads(__tstate);
5148 if (PyErr_Occurred()) SWIG_fail;
5149 }
5150 {
5151 resultobj = SWIG_From_int((int)(result));
5152 }
5153 return resultobj;
5154 fail:
5155 return NULL;
5156 }
5157
5158
5159 static PyObject *_wrap_Rect_SetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
5160 PyObject *resultobj;
5161 wxRect *arg1 = (wxRect *) 0 ;
5162 int arg2 ;
5163 PyObject * obj0 = 0 ;
5164 PyObject * obj1 = 0 ;
5165 char *kwnames[] = {
5166 (char *) "self",(char *) "h", NULL
5167 };
5168
5169 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) goto fail;
5170 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5171 if (SWIG_arg_fail(1)) SWIG_fail;
5172 {
5173 arg2 = (int)(SWIG_As_int(obj1));
5174 if (SWIG_arg_fail(2)) SWIG_fail;
5175 }
5176 {
5177 PyThreadState* __tstate = wxPyBeginAllowThreads();
5178 (arg1)->SetHeight(arg2);
5179
5180 wxPyEndAllowThreads(__tstate);
5181 if (PyErr_Occurred()) SWIG_fail;
5182 }
5183 Py_INCREF(Py_None); resultobj = Py_None;
5184 return resultobj;
5185 fail:
5186 return NULL;
5187 }
5188
5189
5190 static PyObject *_wrap_Rect_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5191 PyObject *resultobj;
5192 wxRect *arg1 = (wxRect *) 0 ;
5193 wxPoint result;
5194 PyObject * obj0 = 0 ;
5195 char *kwnames[] = {
5196 (char *) "self", NULL
5197 };
5198
5199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetPosition",kwnames,&obj0)) goto fail;
5200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5201 if (SWIG_arg_fail(1)) SWIG_fail;
5202 {
5203 PyThreadState* __tstate = wxPyBeginAllowThreads();
5204 result = ((wxRect const *)arg1)->GetPosition();
5205
5206 wxPyEndAllowThreads(__tstate);
5207 if (PyErr_Occurred()) SWIG_fail;
5208 }
5209 {
5210 wxPoint * resultptr;
5211 resultptr = new wxPoint((wxPoint &)(result));
5212 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5213 }
5214 return resultobj;
5215 fail:
5216 return NULL;
5217 }
5218
5219
5220 static PyObject *_wrap_Rect_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
5221 PyObject *resultobj;
5222 wxRect *arg1 = (wxRect *) 0 ;
5223 wxPoint *arg2 = 0 ;
5224 wxPoint temp2 ;
5225 PyObject * obj0 = 0 ;
5226 PyObject * obj1 = 0 ;
5227 char *kwnames[] = {
5228 (char *) "self",(char *) "p", NULL
5229 };
5230
5231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) goto fail;
5232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5233 if (SWIG_arg_fail(1)) SWIG_fail;
5234 {
5235 arg2 = &temp2;
5236 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5237 }
5238 {
5239 PyThreadState* __tstate = wxPyBeginAllowThreads();
5240 (arg1)->SetPosition((wxPoint const &)*arg2);
5241
5242 wxPyEndAllowThreads(__tstate);
5243 if (PyErr_Occurred()) SWIG_fail;
5244 }
5245 Py_INCREF(Py_None); resultobj = Py_None;
5246 return resultobj;
5247 fail:
5248 return NULL;
5249 }
5250
5251
5252 static PyObject *_wrap_Rect_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5253 PyObject *resultobj;
5254 wxRect *arg1 = (wxRect *) 0 ;
5255 wxSize result;
5256 PyObject * obj0 = 0 ;
5257 char *kwnames[] = {
5258 (char *) "self", NULL
5259 };
5260
5261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetSize",kwnames,&obj0)) goto fail;
5262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5263 if (SWIG_arg_fail(1)) SWIG_fail;
5264 {
5265 PyThreadState* __tstate = wxPyBeginAllowThreads();
5266 result = ((wxRect const *)arg1)->GetSize();
5267
5268 wxPyEndAllowThreads(__tstate);
5269 if (PyErr_Occurred()) SWIG_fail;
5270 }
5271 {
5272 wxSize * resultptr;
5273 resultptr = new wxSize((wxSize &)(result));
5274 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
5275 }
5276 return resultobj;
5277 fail:
5278 return NULL;
5279 }
5280
5281
5282 static PyObject *_wrap_Rect_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
5283 PyObject *resultobj;
5284 wxRect *arg1 = (wxRect *) 0 ;
5285 wxSize *arg2 = 0 ;
5286 wxSize temp2 ;
5287 PyObject * obj0 = 0 ;
5288 PyObject * obj1 = 0 ;
5289 char *kwnames[] = {
5290 (char *) "self",(char *) "s", NULL
5291 };
5292
5293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) goto fail;
5294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5295 if (SWIG_arg_fail(1)) SWIG_fail;
5296 {
5297 arg2 = &temp2;
5298 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5299 }
5300 {
5301 PyThreadState* __tstate = wxPyBeginAllowThreads();
5302 (arg1)->SetSize((wxSize const &)*arg2);
5303
5304 wxPyEndAllowThreads(__tstate);
5305 if (PyErr_Occurred()) SWIG_fail;
5306 }
5307 Py_INCREF(Py_None); resultobj = Py_None;
5308 return resultobj;
5309 fail:
5310 return NULL;
5311 }
5312
5313
5314 static PyObject *_wrap_Rect_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
5315 PyObject *resultobj;
5316 wxRect *arg1 = (wxRect *) 0 ;
5317 bool result;
5318 PyObject * obj0 = 0 ;
5319 char *kwnames[] = {
5320 (char *) "self", NULL
5321 };
5322
5323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_IsEmpty",kwnames,&obj0)) goto fail;
5324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5325 if (SWIG_arg_fail(1)) SWIG_fail;
5326 {
5327 PyThreadState* __tstate = wxPyBeginAllowThreads();
5328 result = (bool)((wxRect const *)arg1)->IsEmpty();
5329
5330 wxPyEndAllowThreads(__tstate);
5331 if (PyErr_Occurred()) SWIG_fail;
5332 }
5333 {
5334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5335 }
5336 return resultobj;
5337 fail:
5338 return NULL;
5339 }
5340
5341
5342 static PyObject *_wrap_Rect_GetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5343 PyObject *resultobj;
5344 wxRect *arg1 = (wxRect *) 0 ;
5345 wxPoint result;
5346 PyObject * obj0 = 0 ;
5347 char *kwnames[] = {
5348 (char *) "self", NULL
5349 };
5350
5351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTopLeft",kwnames,&obj0)) goto fail;
5352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5353 if (SWIG_arg_fail(1)) SWIG_fail;
5354 {
5355 PyThreadState* __tstate = wxPyBeginAllowThreads();
5356 result = ((wxRect const *)arg1)->GetTopLeft();
5357
5358 wxPyEndAllowThreads(__tstate);
5359 if (PyErr_Occurred()) SWIG_fail;
5360 }
5361 {
5362 wxPoint * resultptr;
5363 resultptr = new wxPoint((wxPoint &)(result));
5364 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5365 }
5366 return resultobj;
5367 fail:
5368 return NULL;
5369 }
5370
5371
5372 static PyObject *_wrap_Rect_SetTopLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5373 PyObject *resultobj;
5374 wxRect *arg1 = (wxRect *) 0 ;
5375 wxPoint *arg2 = 0 ;
5376 wxPoint temp2 ;
5377 PyObject * obj0 = 0 ;
5378 PyObject * obj1 = 0 ;
5379 char *kwnames[] = {
5380 (char *) "self",(char *) "p", NULL
5381 };
5382
5383 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) goto fail;
5384 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5385 if (SWIG_arg_fail(1)) SWIG_fail;
5386 {
5387 arg2 = &temp2;
5388 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5389 }
5390 {
5391 PyThreadState* __tstate = wxPyBeginAllowThreads();
5392 (arg1)->SetTopLeft((wxPoint const &)*arg2);
5393
5394 wxPyEndAllowThreads(__tstate);
5395 if (PyErr_Occurred()) SWIG_fail;
5396 }
5397 Py_INCREF(Py_None); resultobj = Py_None;
5398 return resultobj;
5399 fail:
5400 return NULL;
5401 }
5402
5403
5404 static PyObject *_wrap_Rect_GetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5405 PyObject *resultobj;
5406 wxRect *arg1 = (wxRect *) 0 ;
5407 wxPoint result;
5408 PyObject * obj0 = 0 ;
5409 char *kwnames[] = {
5410 (char *) "self", NULL
5411 };
5412
5413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottomRight",kwnames,&obj0)) goto fail;
5414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5415 if (SWIG_arg_fail(1)) SWIG_fail;
5416 {
5417 PyThreadState* __tstate = wxPyBeginAllowThreads();
5418 result = ((wxRect const *)arg1)->GetBottomRight();
5419
5420 wxPyEndAllowThreads(__tstate);
5421 if (PyErr_Occurred()) SWIG_fail;
5422 }
5423 {
5424 wxPoint * resultptr;
5425 resultptr = new wxPoint((wxPoint &)(result));
5426 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
5427 }
5428 return resultobj;
5429 fail:
5430 return NULL;
5431 }
5432
5433
5434 static PyObject *_wrap_Rect_SetBottomRight(PyObject *, PyObject *args, PyObject *kwargs) {
5435 PyObject *resultobj;
5436 wxRect *arg1 = (wxRect *) 0 ;
5437 wxPoint *arg2 = 0 ;
5438 wxPoint temp2 ;
5439 PyObject * obj0 = 0 ;
5440 PyObject * obj1 = 0 ;
5441 char *kwnames[] = {
5442 (char *) "self",(char *) "p", NULL
5443 };
5444
5445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) goto fail;
5446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5447 if (SWIG_arg_fail(1)) SWIG_fail;
5448 {
5449 arg2 = &temp2;
5450 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5451 }
5452 {
5453 PyThreadState* __tstate = wxPyBeginAllowThreads();
5454 (arg1)->SetBottomRight((wxPoint const &)*arg2);
5455
5456 wxPyEndAllowThreads(__tstate);
5457 if (PyErr_Occurred()) SWIG_fail;
5458 }
5459 Py_INCREF(Py_None); resultobj = Py_None;
5460 return resultobj;
5461 fail:
5462 return NULL;
5463 }
5464
5465
5466 static PyObject *_wrap_Rect_GetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5467 PyObject *resultobj;
5468 wxRect *arg1 = (wxRect *) 0 ;
5469 int result;
5470 PyObject * obj0 = 0 ;
5471 char *kwnames[] = {
5472 (char *) "self", NULL
5473 };
5474
5475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetLeft",kwnames,&obj0)) goto fail;
5476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5477 if (SWIG_arg_fail(1)) SWIG_fail;
5478 {
5479 PyThreadState* __tstate = wxPyBeginAllowThreads();
5480 result = (int)((wxRect const *)arg1)->GetLeft();
5481
5482 wxPyEndAllowThreads(__tstate);
5483 if (PyErr_Occurred()) SWIG_fail;
5484 }
5485 {
5486 resultobj = SWIG_From_int((int)(result));
5487 }
5488 return resultobj;
5489 fail:
5490 return NULL;
5491 }
5492
5493
5494 static PyObject *_wrap_Rect_GetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5495 PyObject *resultobj;
5496 wxRect *arg1 = (wxRect *) 0 ;
5497 int result;
5498 PyObject * obj0 = 0 ;
5499 char *kwnames[] = {
5500 (char *) "self", NULL
5501 };
5502
5503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetTop",kwnames,&obj0)) goto fail;
5504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5505 if (SWIG_arg_fail(1)) SWIG_fail;
5506 {
5507 PyThreadState* __tstate = wxPyBeginAllowThreads();
5508 result = (int)((wxRect const *)arg1)->GetTop();
5509
5510 wxPyEndAllowThreads(__tstate);
5511 if (PyErr_Occurred()) SWIG_fail;
5512 }
5513 {
5514 resultobj = SWIG_From_int((int)(result));
5515 }
5516 return resultobj;
5517 fail:
5518 return NULL;
5519 }
5520
5521
5522 static PyObject *_wrap_Rect_GetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5523 PyObject *resultobj;
5524 wxRect *arg1 = (wxRect *) 0 ;
5525 int result;
5526 PyObject * obj0 = 0 ;
5527 char *kwnames[] = {
5528 (char *) "self", NULL
5529 };
5530
5531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetBottom",kwnames,&obj0)) goto fail;
5532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5533 if (SWIG_arg_fail(1)) SWIG_fail;
5534 {
5535 PyThreadState* __tstate = wxPyBeginAllowThreads();
5536 result = (int)((wxRect const *)arg1)->GetBottom();
5537
5538 wxPyEndAllowThreads(__tstate);
5539 if (PyErr_Occurred()) SWIG_fail;
5540 }
5541 {
5542 resultobj = SWIG_From_int((int)(result));
5543 }
5544 return resultobj;
5545 fail:
5546 return NULL;
5547 }
5548
5549
5550 static PyObject *_wrap_Rect_GetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5551 PyObject *resultobj;
5552 wxRect *arg1 = (wxRect *) 0 ;
5553 int result;
5554 PyObject * obj0 = 0 ;
5555 char *kwnames[] = {
5556 (char *) "self", NULL
5557 };
5558
5559 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_GetRight",kwnames,&obj0)) goto fail;
5560 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5561 if (SWIG_arg_fail(1)) SWIG_fail;
5562 {
5563 PyThreadState* __tstate = wxPyBeginAllowThreads();
5564 result = (int)((wxRect const *)arg1)->GetRight();
5565
5566 wxPyEndAllowThreads(__tstate);
5567 if (PyErr_Occurred()) SWIG_fail;
5568 }
5569 {
5570 resultobj = SWIG_From_int((int)(result));
5571 }
5572 return resultobj;
5573 fail:
5574 return NULL;
5575 }
5576
5577
5578 static PyObject *_wrap_Rect_SetLeft(PyObject *, PyObject *args, PyObject *kwargs) {
5579 PyObject *resultobj;
5580 wxRect *arg1 = (wxRect *) 0 ;
5581 int arg2 ;
5582 PyObject * obj0 = 0 ;
5583 PyObject * obj1 = 0 ;
5584 char *kwnames[] = {
5585 (char *) "self",(char *) "left", NULL
5586 };
5587
5588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) goto fail;
5589 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5590 if (SWIG_arg_fail(1)) SWIG_fail;
5591 {
5592 arg2 = (int)(SWIG_As_int(obj1));
5593 if (SWIG_arg_fail(2)) SWIG_fail;
5594 }
5595 {
5596 PyThreadState* __tstate = wxPyBeginAllowThreads();
5597 (arg1)->SetLeft(arg2);
5598
5599 wxPyEndAllowThreads(__tstate);
5600 if (PyErr_Occurred()) SWIG_fail;
5601 }
5602 Py_INCREF(Py_None); resultobj = Py_None;
5603 return resultobj;
5604 fail:
5605 return NULL;
5606 }
5607
5608
5609 static PyObject *_wrap_Rect_SetRight(PyObject *, PyObject *args, PyObject *kwargs) {
5610 PyObject *resultobj;
5611 wxRect *arg1 = (wxRect *) 0 ;
5612 int arg2 ;
5613 PyObject * obj0 = 0 ;
5614 PyObject * obj1 = 0 ;
5615 char *kwnames[] = {
5616 (char *) "self",(char *) "right", NULL
5617 };
5618
5619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) goto fail;
5620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5621 if (SWIG_arg_fail(1)) SWIG_fail;
5622 {
5623 arg2 = (int)(SWIG_As_int(obj1));
5624 if (SWIG_arg_fail(2)) SWIG_fail;
5625 }
5626 {
5627 PyThreadState* __tstate = wxPyBeginAllowThreads();
5628 (arg1)->SetRight(arg2);
5629
5630 wxPyEndAllowThreads(__tstate);
5631 if (PyErr_Occurred()) SWIG_fail;
5632 }
5633 Py_INCREF(Py_None); resultobj = Py_None;
5634 return resultobj;
5635 fail:
5636 return NULL;
5637 }
5638
5639
5640 static PyObject *_wrap_Rect_SetTop(PyObject *, PyObject *args, PyObject *kwargs) {
5641 PyObject *resultobj;
5642 wxRect *arg1 = (wxRect *) 0 ;
5643 int arg2 ;
5644 PyObject * obj0 = 0 ;
5645 PyObject * obj1 = 0 ;
5646 char *kwnames[] = {
5647 (char *) "self",(char *) "top", NULL
5648 };
5649
5650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) goto fail;
5651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5652 if (SWIG_arg_fail(1)) SWIG_fail;
5653 {
5654 arg2 = (int)(SWIG_As_int(obj1));
5655 if (SWIG_arg_fail(2)) SWIG_fail;
5656 }
5657 {
5658 PyThreadState* __tstate = wxPyBeginAllowThreads();
5659 (arg1)->SetTop(arg2);
5660
5661 wxPyEndAllowThreads(__tstate);
5662 if (PyErr_Occurred()) SWIG_fail;
5663 }
5664 Py_INCREF(Py_None); resultobj = Py_None;
5665 return resultobj;
5666 fail:
5667 return NULL;
5668 }
5669
5670
5671 static PyObject *_wrap_Rect_SetBottom(PyObject *, PyObject *args, PyObject *kwargs) {
5672 PyObject *resultobj;
5673 wxRect *arg1 = (wxRect *) 0 ;
5674 int arg2 ;
5675 PyObject * obj0 = 0 ;
5676 PyObject * obj1 = 0 ;
5677 char *kwnames[] = {
5678 (char *) "self",(char *) "bottom", NULL
5679 };
5680
5681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) goto fail;
5682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5683 if (SWIG_arg_fail(1)) SWIG_fail;
5684 {
5685 arg2 = (int)(SWIG_As_int(obj1));
5686 if (SWIG_arg_fail(2)) SWIG_fail;
5687 }
5688 {
5689 PyThreadState* __tstate = wxPyBeginAllowThreads();
5690 (arg1)->SetBottom(arg2);
5691
5692 wxPyEndAllowThreads(__tstate);
5693 if (PyErr_Occurred()) SWIG_fail;
5694 }
5695 Py_INCREF(Py_None); resultobj = Py_None;
5696 return resultobj;
5697 fail:
5698 return NULL;
5699 }
5700
5701
5702 static PyObject *_wrap_Rect_Inflate(PyObject *, PyObject *args, PyObject *kwargs) {
5703 PyObject *resultobj;
5704 wxRect *arg1 = (wxRect *) 0 ;
5705 int arg2 ;
5706 int arg3 ;
5707 wxRect *result;
5708 PyObject * obj0 = 0 ;
5709 PyObject * obj1 = 0 ;
5710 PyObject * obj2 = 0 ;
5711 char *kwnames[] = {
5712 (char *) "self",(char *) "dx",(char *) "dy", NULL
5713 };
5714
5715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5717 if (SWIG_arg_fail(1)) SWIG_fail;
5718 {
5719 arg2 = (int)(SWIG_As_int(obj1));
5720 if (SWIG_arg_fail(2)) SWIG_fail;
5721 }
5722 {
5723 arg3 = (int)(SWIG_As_int(obj2));
5724 if (SWIG_arg_fail(3)) SWIG_fail;
5725 }
5726 {
5727 PyThreadState* __tstate = wxPyBeginAllowThreads();
5728 {
5729 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
5730 result = (wxRect *) &_result_ref;
5731 }
5732
5733 wxPyEndAllowThreads(__tstate);
5734 if (PyErr_Occurred()) SWIG_fail;
5735 }
5736 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5737 return resultobj;
5738 fail:
5739 return NULL;
5740 }
5741
5742
5743 static PyObject *_wrap_Rect_Deflate(PyObject *, PyObject *args, PyObject *kwargs) {
5744 PyObject *resultobj;
5745 wxRect *arg1 = (wxRect *) 0 ;
5746 int arg2 ;
5747 int arg3 ;
5748 wxRect *result;
5749 PyObject * obj0 = 0 ;
5750 PyObject * obj1 = 0 ;
5751 PyObject * obj2 = 0 ;
5752 char *kwnames[] = {
5753 (char *) "self",(char *) "dx",(char *) "dy", NULL
5754 };
5755
5756 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) goto fail;
5757 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5758 if (SWIG_arg_fail(1)) SWIG_fail;
5759 {
5760 arg2 = (int)(SWIG_As_int(obj1));
5761 if (SWIG_arg_fail(2)) SWIG_fail;
5762 }
5763 {
5764 arg3 = (int)(SWIG_As_int(obj2));
5765 if (SWIG_arg_fail(3)) SWIG_fail;
5766 }
5767 {
5768 PyThreadState* __tstate = wxPyBeginAllowThreads();
5769 {
5770 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
5771 result = (wxRect *) &_result_ref;
5772 }
5773
5774 wxPyEndAllowThreads(__tstate);
5775 if (PyErr_Occurred()) SWIG_fail;
5776 }
5777 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
5778 return resultobj;
5779 fail:
5780 return NULL;
5781 }
5782
5783
5784 static PyObject *_wrap_Rect_OffsetXY(PyObject *, PyObject *args, PyObject *kwargs) {
5785 PyObject *resultobj;
5786 wxRect *arg1 = (wxRect *) 0 ;
5787 int arg2 ;
5788 int arg3 ;
5789 PyObject * obj0 = 0 ;
5790 PyObject * obj1 = 0 ;
5791 PyObject * obj2 = 0 ;
5792 char *kwnames[] = {
5793 (char *) "self",(char *) "dx",(char *) "dy", NULL
5794 };
5795
5796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
5797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5798 if (SWIG_arg_fail(1)) SWIG_fail;
5799 {
5800 arg2 = (int)(SWIG_As_int(obj1));
5801 if (SWIG_arg_fail(2)) SWIG_fail;
5802 }
5803 {
5804 arg3 = (int)(SWIG_As_int(obj2));
5805 if (SWIG_arg_fail(3)) SWIG_fail;
5806 }
5807 {
5808 PyThreadState* __tstate = wxPyBeginAllowThreads();
5809 (arg1)->Offset(arg2,arg3);
5810
5811 wxPyEndAllowThreads(__tstate);
5812 if (PyErr_Occurred()) SWIG_fail;
5813 }
5814 Py_INCREF(Py_None); resultobj = Py_None;
5815 return resultobj;
5816 fail:
5817 return NULL;
5818 }
5819
5820
5821 static PyObject *_wrap_Rect_Offset(PyObject *, PyObject *args, PyObject *kwargs) {
5822 PyObject *resultobj;
5823 wxRect *arg1 = (wxRect *) 0 ;
5824 wxPoint *arg2 = 0 ;
5825 wxPoint temp2 ;
5826 PyObject * obj0 = 0 ;
5827 PyObject * obj1 = 0 ;
5828 char *kwnames[] = {
5829 (char *) "self",(char *) "pt", NULL
5830 };
5831
5832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) goto fail;
5833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5834 if (SWIG_arg_fail(1)) SWIG_fail;
5835 {
5836 arg2 = &temp2;
5837 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5838 }
5839 {
5840 PyThreadState* __tstate = wxPyBeginAllowThreads();
5841 (arg1)->Offset((wxPoint const &)*arg2);
5842
5843 wxPyEndAllowThreads(__tstate);
5844 if (PyErr_Occurred()) SWIG_fail;
5845 }
5846 Py_INCREF(Py_None); resultobj = Py_None;
5847 return resultobj;
5848 fail:
5849 return NULL;
5850 }
5851
5852
5853 static PyObject *_wrap_Rect_Intersect(PyObject *, PyObject *args, PyObject *kwargs) {
5854 PyObject *resultobj;
5855 wxRect *arg1 = (wxRect *) 0 ;
5856 wxRect *arg2 = 0 ;
5857 wxRect result;
5858 wxRect temp2 ;
5859 PyObject * obj0 = 0 ;
5860 PyObject * obj1 = 0 ;
5861 char *kwnames[] = {
5862 (char *) "self",(char *) "rect", NULL
5863 };
5864
5865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) goto fail;
5866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5867 if (SWIG_arg_fail(1)) SWIG_fail;
5868 {
5869 arg2 = &temp2;
5870 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5871 }
5872 {
5873 PyThreadState* __tstate = wxPyBeginAllowThreads();
5874 result = (arg1)->Intersect((wxRect const &)*arg2);
5875
5876 wxPyEndAllowThreads(__tstate);
5877 if (PyErr_Occurred()) SWIG_fail;
5878 }
5879 {
5880 wxRect * resultptr;
5881 resultptr = new wxRect((wxRect &)(result));
5882 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5883 }
5884 return resultobj;
5885 fail:
5886 return NULL;
5887 }
5888
5889
5890 static PyObject *_wrap_Rect_Union(PyObject *, PyObject *args, PyObject *kwargs) {
5891 PyObject *resultobj;
5892 wxRect *arg1 = (wxRect *) 0 ;
5893 wxRect *arg2 = 0 ;
5894 wxRect result;
5895 wxRect temp2 ;
5896 PyObject * obj0 = 0 ;
5897 PyObject * obj1 = 0 ;
5898 char *kwnames[] = {
5899 (char *) "self",(char *) "rect", NULL
5900 };
5901
5902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) goto fail;
5903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5904 if (SWIG_arg_fail(1)) SWIG_fail;
5905 {
5906 arg2 = &temp2;
5907 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5908 }
5909 {
5910 PyThreadState* __tstate = wxPyBeginAllowThreads();
5911 result = (arg1)->Union((wxRect const &)*arg2);
5912
5913 wxPyEndAllowThreads(__tstate);
5914 if (PyErr_Occurred()) SWIG_fail;
5915 }
5916 {
5917 wxRect * resultptr;
5918 resultptr = new wxRect((wxRect &)(result));
5919 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5920 }
5921 return resultobj;
5922 fail:
5923 return NULL;
5924 }
5925
5926
5927 static PyObject *_wrap_Rect___add__(PyObject *, PyObject *args, PyObject *kwargs) {
5928 PyObject *resultobj;
5929 wxRect *arg1 = (wxRect *) 0 ;
5930 wxRect *arg2 = 0 ;
5931 wxRect result;
5932 wxRect temp2 ;
5933 PyObject * obj0 = 0 ;
5934 PyObject * obj1 = 0 ;
5935 char *kwnames[] = {
5936 (char *) "self",(char *) "rect", NULL
5937 };
5938
5939 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) goto fail;
5940 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
5941 if (SWIG_arg_fail(1)) SWIG_fail;
5942 {
5943 arg2 = &temp2;
5944 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5945 }
5946 {
5947 PyThreadState* __tstate = wxPyBeginAllowThreads();
5948 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
5949
5950 wxPyEndAllowThreads(__tstate);
5951 if (PyErr_Occurred()) SWIG_fail;
5952 }
5953 {
5954 wxRect * resultptr;
5955 resultptr = new wxRect((wxRect &)(result));
5956 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
5957 }
5958 return resultobj;
5959 fail:
5960 return NULL;
5961 }
5962
5963
5964 static PyObject *_wrap_Rect___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
5965 PyObject *resultobj;
5966 wxRect *arg1 = (wxRect *) 0 ;
5967 wxRect *arg2 = 0 ;
5968 wxRect *result;
5969 wxRect temp2 ;
5970 PyObject * obj0 = 0 ;
5971 PyObject * obj1 = 0 ;
5972 char *kwnames[] = {
5973 (char *) "self",(char *) "rect", NULL
5974 };
5975
5976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) goto fail;
5977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
5978 if (SWIG_arg_fail(1)) SWIG_fail;
5979 {
5980 arg2 = &temp2;
5981 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
5982 }
5983 {
5984 PyThreadState* __tstate = wxPyBeginAllowThreads();
5985 {
5986 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
5987 result = (wxRect *) &_result_ref;
5988 }
5989
5990 wxPyEndAllowThreads(__tstate);
5991 if (PyErr_Occurred()) SWIG_fail;
5992 }
5993 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 1);
5994 return resultobj;
5995 fail:
5996 return NULL;
5997 }
5998
5999
6000 static PyObject *_wrap_Rect___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
6001 PyObject *resultobj;
6002 wxRect *arg1 = (wxRect *) 0 ;
6003 wxRect *arg2 = 0 ;
6004 bool result;
6005 wxRect temp2 ;
6006 PyObject * obj0 = 0 ;
6007 PyObject * obj1 = 0 ;
6008 char *kwnames[] = {
6009 (char *) "self",(char *) "rect", NULL
6010 };
6011
6012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) goto fail;
6013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6014 if (SWIG_arg_fail(1)) SWIG_fail;
6015 {
6016 arg2 = &temp2;
6017 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6018 }
6019 {
6020 PyThreadState* __tstate = wxPyBeginAllowThreads();
6021 result = (bool)((wxRect const *)arg1)->operator ==((wxRect const &)*arg2);
6022
6023 wxPyEndAllowThreads(__tstate);
6024 if (PyErr_Occurred()) SWIG_fail;
6025 }
6026 {
6027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6028 }
6029 return resultobj;
6030 fail:
6031 return NULL;
6032 }
6033
6034
6035 static PyObject *_wrap_Rect___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
6036 PyObject *resultobj;
6037 wxRect *arg1 = (wxRect *) 0 ;
6038 wxRect *arg2 = 0 ;
6039 bool result;
6040 wxRect temp2 ;
6041 PyObject * obj0 = 0 ;
6042 PyObject * obj1 = 0 ;
6043 char *kwnames[] = {
6044 (char *) "self",(char *) "rect", NULL
6045 };
6046
6047 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) goto fail;
6048 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6049 if (SWIG_arg_fail(1)) SWIG_fail;
6050 {
6051 arg2 = &temp2;
6052 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6053 }
6054 {
6055 PyThreadState* __tstate = wxPyBeginAllowThreads();
6056 result = (bool)((wxRect const *)arg1)->operator !=((wxRect const &)*arg2);
6057
6058 wxPyEndAllowThreads(__tstate);
6059 if (PyErr_Occurred()) SWIG_fail;
6060 }
6061 {
6062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6063 }
6064 return resultobj;
6065 fail:
6066 return NULL;
6067 }
6068
6069
6070 static PyObject *_wrap_Rect_InsideXY(PyObject *, PyObject *args, PyObject *kwargs) {
6071 PyObject *resultobj;
6072 wxRect *arg1 = (wxRect *) 0 ;
6073 int arg2 ;
6074 int arg3 ;
6075 bool result;
6076 PyObject * obj0 = 0 ;
6077 PyObject * obj1 = 0 ;
6078 PyObject * obj2 = 0 ;
6079 char *kwnames[] = {
6080 (char *) "self",(char *) "x",(char *) "y", NULL
6081 };
6082
6083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
6084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6085 if (SWIG_arg_fail(1)) SWIG_fail;
6086 {
6087 arg2 = (int)(SWIG_As_int(obj1));
6088 if (SWIG_arg_fail(2)) SWIG_fail;
6089 }
6090 {
6091 arg3 = (int)(SWIG_As_int(obj2));
6092 if (SWIG_arg_fail(3)) SWIG_fail;
6093 }
6094 {
6095 PyThreadState* __tstate = wxPyBeginAllowThreads();
6096 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
6097
6098 wxPyEndAllowThreads(__tstate);
6099 if (PyErr_Occurred()) SWIG_fail;
6100 }
6101 {
6102 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6103 }
6104 return resultobj;
6105 fail:
6106 return NULL;
6107 }
6108
6109
6110 static PyObject *_wrap_Rect_Inside(PyObject *, PyObject *args, PyObject *kwargs) {
6111 PyObject *resultobj;
6112 wxRect *arg1 = (wxRect *) 0 ;
6113 wxPoint *arg2 = 0 ;
6114 bool result;
6115 wxPoint temp2 ;
6116 PyObject * obj0 = 0 ;
6117 PyObject * obj1 = 0 ;
6118 char *kwnames[] = {
6119 (char *) "self",(char *) "pt", NULL
6120 };
6121
6122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) goto fail;
6123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6124 if (SWIG_arg_fail(1)) SWIG_fail;
6125 {
6126 arg2 = &temp2;
6127 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6128 }
6129 {
6130 PyThreadState* __tstate = wxPyBeginAllowThreads();
6131 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
6132
6133 wxPyEndAllowThreads(__tstate);
6134 if (PyErr_Occurred()) SWIG_fail;
6135 }
6136 {
6137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6138 }
6139 return resultobj;
6140 fail:
6141 return NULL;
6142 }
6143
6144
6145 static PyObject *_wrap_Rect_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
6146 PyObject *resultobj;
6147 wxRect *arg1 = (wxRect *) 0 ;
6148 wxRect *arg2 = 0 ;
6149 bool result;
6150 wxRect temp2 ;
6151 PyObject * obj0 = 0 ;
6152 PyObject * obj1 = 0 ;
6153 char *kwnames[] = {
6154 (char *) "self",(char *) "rect", NULL
6155 };
6156
6157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) goto fail;
6158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6159 if (SWIG_arg_fail(1)) SWIG_fail;
6160 {
6161 arg2 = &temp2;
6162 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
6163 }
6164 {
6165 PyThreadState* __tstate = wxPyBeginAllowThreads();
6166 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
6167
6168 wxPyEndAllowThreads(__tstate);
6169 if (PyErr_Occurred()) SWIG_fail;
6170 }
6171 {
6172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6173 }
6174 return resultobj;
6175 fail:
6176 return NULL;
6177 }
6178
6179
6180 static PyObject *_wrap_Rect_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
6181 PyObject *resultobj;
6182 wxRect *arg1 = (wxRect *) 0 ;
6183 int arg2 ;
6184 PyObject * obj0 = 0 ;
6185 PyObject * obj1 = 0 ;
6186 char *kwnames[] = {
6187 (char *) "self",(char *) "x", NULL
6188 };
6189
6190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_x_set",kwnames,&obj0,&obj1)) goto fail;
6191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6192 if (SWIG_arg_fail(1)) SWIG_fail;
6193 {
6194 arg2 = (int)(SWIG_As_int(obj1));
6195 if (SWIG_arg_fail(2)) SWIG_fail;
6196 }
6197 if (arg1) (arg1)->x = arg2;
6198
6199 Py_INCREF(Py_None); resultobj = Py_None;
6200 return resultobj;
6201 fail:
6202 return NULL;
6203 }
6204
6205
6206 static PyObject *_wrap_Rect_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
6207 PyObject *resultobj;
6208 wxRect *arg1 = (wxRect *) 0 ;
6209 int result;
6210 PyObject * obj0 = 0 ;
6211 char *kwnames[] = {
6212 (char *) "self", NULL
6213 };
6214
6215 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_x_get",kwnames,&obj0)) goto fail;
6216 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6217 if (SWIG_arg_fail(1)) SWIG_fail;
6218 result = (int) ((arg1)->x);
6219
6220 {
6221 resultobj = SWIG_From_int((int)(result));
6222 }
6223 return resultobj;
6224 fail:
6225 return NULL;
6226 }
6227
6228
6229 static PyObject *_wrap_Rect_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
6230 PyObject *resultobj;
6231 wxRect *arg1 = (wxRect *) 0 ;
6232 int arg2 ;
6233 PyObject * obj0 = 0 ;
6234 PyObject * obj1 = 0 ;
6235 char *kwnames[] = {
6236 (char *) "self",(char *) "y", NULL
6237 };
6238
6239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_y_set",kwnames,&obj0,&obj1)) goto fail;
6240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6241 if (SWIG_arg_fail(1)) SWIG_fail;
6242 {
6243 arg2 = (int)(SWIG_As_int(obj1));
6244 if (SWIG_arg_fail(2)) SWIG_fail;
6245 }
6246 if (arg1) (arg1)->y = arg2;
6247
6248 Py_INCREF(Py_None); resultobj = Py_None;
6249 return resultobj;
6250 fail:
6251 return NULL;
6252 }
6253
6254
6255 static PyObject *_wrap_Rect_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
6256 PyObject *resultobj;
6257 wxRect *arg1 = (wxRect *) 0 ;
6258 int result;
6259 PyObject * obj0 = 0 ;
6260 char *kwnames[] = {
6261 (char *) "self", NULL
6262 };
6263
6264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_y_get",kwnames,&obj0)) goto fail;
6265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6266 if (SWIG_arg_fail(1)) SWIG_fail;
6267 result = (int) ((arg1)->y);
6268
6269 {
6270 resultobj = SWIG_From_int((int)(result));
6271 }
6272 return resultobj;
6273 fail:
6274 return NULL;
6275 }
6276
6277
6278 static PyObject *_wrap_Rect_width_set(PyObject *, PyObject *args, PyObject *kwargs) {
6279 PyObject *resultobj;
6280 wxRect *arg1 = (wxRect *) 0 ;
6281 int arg2 ;
6282 PyObject * obj0 = 0 ;
6283 PyObject * obj1 = 0 ;
6284 char *kwnames[] = {
6285 (char *) "self",(char *) "width", NULL
6286 };
6287
6288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_width_set",kwnames,&obj0,&obj1)) goto fail;
6289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6290 if (SWIG_arg_fail(1)) SWIG_fail;
6291 {
6292 arg2 = (int)(SWIG_As_int(obj1));
6293 if (SWIG_arg_fail(2)) SWIG_fail;
6294 }
6295 if (arg1) (arg1)->width = arg2;
6296
6297 Py_INCREF(Py_None); resultobj = Py_None;
6298 return resultobj;
6299 fail:
6300 return NULL;
6301 }
6302
6303
6304 static PyObject *_wrap_Rect_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
6305 PyObject *resultobj;
6306 wxRect *arg1 = (wxRect *) 0 ;
6307 int result;
6308 PyObject * obj0 = 0 ;
6309 char *kwnames[] = {
6310 (char *) "self", NULL
6311 };
6312
6313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_width_get",kwnames,&obj0)) goto fail;
6314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6315 if (SWIG_arg_fail(1)) SWIG_fail;
6316 result = (int) ((arg1)->width);
6317
6318 {
6319 resultobj = SWIG_From_int((int)(result));
6320 }
6321 return resultobj;
6322 fail:
6323 return NULL;
6324 }
6325
6326
6327 static PyObject *_wrap_Rect_height_set(PyObject *, PyObject *args, PyObject *kwargs) {
6328 PyObject *resultobj;
6329 wxRect *arg1 = (wxRect *) 0 ;
6330 int arg2 ;
6331 PyObject * obj0 = 0 ;
6332 PyObject * obj1 = 0 ;
6333 char *kwnames[] = {
6334 (char *) "self",(char *) "height", NULL
6335 };
6336
6337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_height_set",kwnames,&obj0,&obj1)) goto fail;
6338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6339 if (SWIG_arg_fail(1)) SWIG_fail;
6340 {
6341 arg2 = (int)(SWIG_As_int(obj1));
6342 if (SWIG_arg_fail(2)) SWIG_fail;
6343 }
6344 if (arg1) (arg1)->height = arg2;
6345
6346 Py_INCREF(Py_None); resultobj = Py_None;
6347 return resultobj;
6348 fail:
6349 return NULL;
6350 }
6351
6352
6353 static PyObject *_wrap_Rect_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
6354 PyObject *resultobj;
6355 wxRect *arg1 = (wxRect *) 0 ;
6356 int result;
6357 PyObject * obj0 = 0 ;
6358 char *kwnames[] = {
6359 (char *) "self", NULL
6360 };
6361
6362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_height_get",kwnames,&obj0)) goto fail;
6363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6364 if (SWIG_arg_fail(1)) SWIG_fail;
6365 result = (int) ((arg1)->height);
6366
6367 {
6368 resultobj = SWIG_From_int((int)(result));
6369 }
6370 return resultobj;
6371 fail:
6372 return NULL;
6373 }
6374
6375
6376 static PyObject *_wrap_Rect_Set(PyObject *, PyObject *args, PyObject *kwargs) {
6377 PyObject *resultobj;
6378 wxRect *arg1 = (wxRect *) 0 ;
6379 int arg2 = (int) 0 ;
6380 int arg3 = (int) 0 ;
6381 int arg4 = (int) 0 ;
6382 int arg5 = (int) 0 ;
6383 PyObject * obj0 = 0 ;
6384 PyObject * obj1 = 0 ;
6385 PyObject * obj2 = 0 ;
6386 PyObject * obj3 = 0 ;
6387 PyObject * obj4 = 0 ;
6388 char *kwnames[] = {
6389 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6390 };
6391
6392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
6393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6394 if (SWIG_arg_fail(1)) SWIG_fail;
6395 if (obj1) {
6396 {
6397 arg2 = (int)(SWIG_As_int(obj1));
6398 if (SWIG_arg_fail(2)) SWIG_fail;
6399 }
6400 }
6401 if (obj2) {
6402 {
6403 arg3 = (int)(SWIG_As_int(obj2));
6404 if (SWIG_arg_fail(3)) SWIG_fail;
6405 }
6406 }
6407 if (obj3) {
6408 {
6409 arg4 = (int)(SWIG_As_int(obj3));
6410 if (SWIG_arg_fail(4)) SWIG_fail;
6411 }
6412 }
6413 if (obj4) {
6414 {
6415 arg5 = (int)(SWIG_As_int(obj4));
6416 if (SWIG_arg_fail(5)) SWIG_fail;
6417 }
6418 }
6419 {
6420 PyThreadState* __tstate = wxPyBeginAllowThreads();
6421 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
6422
6423 wxPyEndAllowThreads(__tstate);
6424 if (PyErr_Occurred()) SWIG_fail;
6425 }
6426 Py_INCREF(Py_None); resultobj = Py_None;
6427 return resultobj;
6428 fail:
6429 return NULL;
6430 }
6431
6432
6433 static PyObject *_wrap_Rect_Get(PyObject *, PyObject *args, PyObject *kwargs) {
6434 PyObject *resultobj;
6435 wxRect *arg1 = (wxRect *) 0 ;
6436 PyObject *result;
6437 PyObject * obj0 = 0 ;
6438 char *kwnames[] = {
6439 (char *) "self", NULL
6440 };
6441
6442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Rect_Get",kwnames,&obj0)) goto fail;
6443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6444 if (SWIG_arg_fail(1)) SWIG_fail;
6445 {
6446 PyThreadState* __tstate = wxPyBeginAllowThreads();
6447 result = (PyObject *)wxRect_Get(arg1);
6448
6449 wxPyEndAllowThreads(__tstate);
6450 if (PyErr_Occurred()) SWIG_fail;
6451 }
6452 resultobj = result;
6453 return resultobj;
6454 fail:
6455 return NULL;
6456 }
6457
6458
6459 static PyObject * Rect_swigregister(PyObject *, PyObject *args) {
6460 PyObject *obj;
6461 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
6462 SWIG_TypeClientData(SWIGTYPE_p_wxRect, obj);
6463 Py_INCREF(obj);
6464 return Py_BuildValue((char *)"");
6465 }
6466 static PyObject *_wrap_IntersectRect(PyObject *, PyObject *args, PyObject *kwargs) {
6467 PyObject *resultobj;
6468 wxRect *arg1 = (wxRect *) 0 ;
6469 wxRect *arg2 = (wxRect *) 0 ;
6470 PyObject *result;
6471 PyObject * obj0 = 0 ;
6472 PyObject * obj1 = 0 ;
6473 char *kwnames[] = {
6474 (char *) "r1",(char *) "r2", NULL
6475 };
6476
6477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) goto fail;
6478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6479 if (SWIG_arg_fail(1)) SWIG_fail;
6480 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
6481 if (SWIG_arg_fail(2)) SWIG_fail;
6482 {
6483 if (!wxPyCheckForApp()) SWIG_fail;
6484 PyThreadState* __tstate = wxPyBeginAllowThreads();
6485 result = (PyObject *)wxIntersectRect(arg1,arg2);
6486
6487 wxPyEndAllowThreads(__tstate);
6488 if (PyErr_Occurred()) SWIG_fail;
6489 }
6490 resultobj = result;
6491 return resultobj;
6492 fail:
6493 return NULL;
6494 }
6495
6496
6497 static PyObject *_wrap_new_Point2D(PyObject *, PyObject *args, PyObject *kwargs) {
6498 PyObject *resultobj;
6499 double arg1 = (double) 0.0 ;
6500 double arg2 = (double) 0.0 ;
6501 wxPoint2D *result;
6502 PyObject * obj0 = 0 ;
6503 PyObject * obj1 = 0 ;
6504 char *kwnames[] = {
6505 (char *) "x",(char *) "y", NULL
6506 };
6507
6508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) goto fail;
6509 if (obj0) {
6510 {
6511 arg1 = (double)(SWIG_As_double(obj0));
6512 if (SWIG_arg_fail(1)) SWIG_fail;
6513 }
6514 }
6515 if (obj1) {
6516 {
6517 arg2 = (double)(SWIG_As_double(obj1));
6518 if (SWIG_arg_fail(2)) SWIG_fail;
6519 }
6520 }
6521 {
6522 PyThreadState* __tstate = wxPyBeginAllowThreads();
6523 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
6524
6525 wxPyEndAllowThreads(__tstate);
6526 if (PyErr_Occurred()) SWIG_fail;
6527 }
6528 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6529 return resultobj;
6530 fail:
6531 return NULL;
6532 }
6533
6534
6535 static PyObject *_wrap_new_Point2DCopy(PyObject *, PyObject *args, PyObject *kwargs) {
6536 PyObject *resultobj;
6537 wxPoint2D *arg1 = 0 ;
6538 wxPoint2D *result;
6539 wxPoint2D temp1 ;
6540 PyObject * obj0 = 0 ;
6541 char *kwnames[] = {
6542 (char *) "pt", NULL
6543 };
6544
6545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) goto fail;
6546 {
6547 arg1 = &temp1;
6548 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
6549 }
6550 {
6551 PyThreadState* __tstate = wxPyBeginAllowThreads();
6552 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
6553
6554 wxPyEndAllowThreads(__tstate);
6555 if (PyErr_Occurred()) SWIG_fail;
6556 }
6557 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6558 return resultobj;
6559 fail:
6560 return NULL;
6561 }
6562
6563
6564 static PyObject *_wrap_new_Point2DFromPoint(PyObject *, PyObject *args, PyObject *kwargs) {
6565 PyObject *resultobj;
6566 wxPoint *arg1 = 0 ;
6567 wxPoint2D *result;
6568 wxPoint temp1 ;
6569 PyObject * obj0 = 0 ;
6570 char *kwnames[] = {
6571 (char *) "pt", NULL
6572 };
6573
6574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) goto fail;
6575 {
6576 arg1 = &temp1;
6577 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6578 }
6579 {
6580 PyThreadState* __tstate = wxPyBeginAllowThreads();
6581 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
6582
6583 wxPyEndAllowThreads(__tstate);
6584 if (PyErr_Occurred()) SWIG_fail;
6585 }
6586 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6587 return resultobj;
6588 fail:
6589 return NULL;
6590 }
6591
6592
6593 static PyObject *_wrap_Point2D_GetFloor(PyObject *, PyObject *args, PyObject *kwargs) {
6594 PyObject *resultobj;
6595 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6596 int *arg2 = (int *) 0 ;
6597 int *arg3 = (int *) 0 ;
6598 int temp2 ;
6599 int res2 = 0 ;
6600 int temp3 ;
6601 int res3 = 0 ;
6602 PyObject * obj0 = 0 ;
6603 char *kwnames[] = {
6604 (char *) "self", NULL
6605 };
6606
6607 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6608 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetFloor",kwnames,&obj0)) goto fail;
6610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6611 if (SWIG_arg_fail(1)) SWIG_fail;
6612 {
6613 PyThreadState* __tstate = wxPyBeginAllowThreads();
6614 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
6615
6616 wxPyEndAllowThreads(__tstate);
6617 if (PyErr_Occurred()) SWIG_fail;
6618 }
6619 Py_INCREF(Py_None); resultobj = Py_None;
6620 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6621 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6622 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6623 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6624 return resultobj;
6625 fail:
6626 return NULL;
6627 }
6628
6629
6630 static PyObject *_wrap_Point2D_GetRounded(PyObject *, PyObject *args, PyObject *kwargs) {
6631 PyObject *resultobj;
6632 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6633 int *arg2 = (int *) 0 ;
6634 int *arg3 = (int *) 0 ;
6635 int temp2 ;
6636 int res2 = 0 ;
6637 int temp3 ;
6638 int res3 = 0 ;
6639 PyObject * obj0 = 0 ;
6640 char *kwnames[] = {
6641 (char *) "self", NULL
6642 };
6643
6644 arg2 = &temp2; res2 = SWIG_NEWOBJ;
6645 arg3 = &temp3; res3 = SWIG_NEWOBJ;
6646 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetRounded",kwnames,&obj0)) goto fail;
6647 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6648 if (SWIG_arg_fail(1)) SWIG_fail;
6649 {
6650 PyThreadState* __tstate = wxPyBeginAllowThreads();
6651 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
6652
6653 wxPyEndAllowThreads(__tstate);
6654 if (PyErr_Occurred()) SWIG_fail;
6655 }
6656 Py_INCREF(Py_None); resultobj = Py_None;
6657 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
6658 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
6659 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
6660 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
6661 return resultobj;
6662 fail:
6663 return NULL;
6664 }
6665
6666
6667 static PyObject *_wrap_Point2D_GetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6668 PyObject *resultobj;
6669 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6670 double result;
6671 PyObject * obj0 = 0 ;
6672 char *kwnames[] = {
6673 (char *) "self", NULL
6674 };
6675
6676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorLength",kwnames,&obj0)) goto fail;
6677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6678 if (SWIG_arg_fail(1)) SWIG_fail;
6679 {
6680 PyThreadState* __tstate = wxPyBeginAllowThreads();
6681 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
6682
6683 wxPyEndAllowThreads(__tstate);
6684 if (PyErr_Occurred()) SWIG_fail;
6685 }
6686 {
6687 resultobj = SWIG_From_double((double)(result));
6688 }
6689 return resultobj;
6690 fail:
6691 return NULL;
6692 }
6693
6694
6695 static PyObject *_wrap_Point2D_GetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6696 PyObject *resultobj;
6697 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6698 double result;
6699 PyObject * obj0 = 0 ;
6700 char *kwnames[] = {
6701 (char *) "self", NULL
6702 };
6703
6704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_GetVectorAngle",kwnames,&obj0)) goto fail;
6705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6706 if (SWIG_arg_fail(1)) SWIG_fail;
6707 {
6708 PyThreadState* __tstate = wxPyBeginAllowThreads();
6709 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
6710
6711 wxPyEndAllowThreads(__tstate);
6712 if (PyErr_Occurred()) SWIG_fail;
6713 }
6714 {
6715 resultobj = SWIG_From_double((double)(result));
6716 }
6717 return resultobj;
6718 fail:
6719 return NULL;
6720 }
6721
6722
6723 static PyObject *_wrap_Point2D_SetVectorLength(PyObject *, PyObject *args, PyObject *kwargs) {
6724 PyObject *resultobj;
6725 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6726 double arg2 ;
6727 PyObject * obj0 = 0 ;
6728 PyObject * obj1 = 0 ;
6729 char *kwnames[] = {
6730 (char *) "self",(char *) "length", NULL
6731 };
6732
6733 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) goto fail;
6734 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6735 if (SWIG_arg_fail(1)) SWIG_fail;
6736 {
6737 arg2 = (double)(SWIG_As_double(obj1));
6738 if (SWIG_arg_fail(2)) SWIG_fail;
6739 }
6740 {
6741 PyThreadState* __tstate = wxPyBeginAllowThreads();
6742 (arg1)->SetVectorLength(arg2);
6743
6744 wxPyEndAllowThreads(__tstate);
6745 if (PyErr_Occurred()) SWIG_fail;
6746 }
6747 Py_INCREF(Py_None); resultobj = Py_None;
6748 return resultobj;
6749 fail:
6750 return NULL;
6751 }
6752
6753
6754 static PyObject *_wrap_Point2D_SetVectorAngle(PyObject *, PyObject *args, PyObject *kwargs) {
6755 PyObject *resultobj;
6756 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6757 double arg2 ;
6758 PyObject * obj0 = 0 ;
6759 PyObject * obj1 = 0 ;
6760 char *kwnames[] = {
6761 (char *) "self",(char *) "degrees", NULL
6762 };
6763
6764 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) goto fail;
6765 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6766 if (SWIG_arg_fail(1)) SWIG_fail;
6767 {
6768 arg2 = (double)(SWIG_As_double(obj1));
6769 if (SWIG_arg_fail(2)) SWIG_fail;
6770 }
6771 {
6772 PyThreadState* __tstate = wxPyBeginAllowThreads();
6773 (arg1)->SetVectorAngle(arg2);
6774
6775 wxPyEndAllowThreads(__tstate);
6776 if (PyErr_Occurred()) SWIG_fail;
6777 }
6778 Py_INCREF(Py_None); resultobj = Py_None;
6779 return resultobj;
6780 fail:
6781 return NULL;
6782 }
6783
6784
6785 static PyObject *_wrap_Point2D_GetDistance(PyObject *, PyObject *args, PyObject *kwargs) {
6786 PyObject *resultobj;
6787 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6788 wxPoint2D *arg2 = 0 ;
6789 double result;
6790 wxPoint2D temp2 ;
6791 PyObject * obj0 = 0 ;
6792 PyObject * obj1 = 0 ;
6793 char *kwnames[] = {
6794 (char *) "self",(char *) "pt", NULL
6795 };
6796
6797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) goto fail;
6798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6799 if (SWIG_arg_fail(1)) SWIG_fail;
6800 {
6801 arg2 = &temp2;
6802 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6803 }
6804 {
6805 PyThreadState* __tstate = wxPyBeginAllowThreads();
6806 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
6807
6808 wxPyEndAllowThreads(__tstate);
6809 if (PyErr_Occurred()) SWIG_fail;
6810 }
6811 {
6812 resultobj = SWIG_From_double((double)(result));
6813 }
6814 return resultobj;
6815 fail:
6816 return NULL;
6817 }
6818
6819
6820 static PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *, PyObject *args, PyObject *kwargs) {
6821 PyObject *resultobj;
6822 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6823 wxPoint2D *arg2 = 0 ;
6824 double result;
6825 wxPoint2D temp2 ;
6826 PyObject * obj0 = 0 ;
6827 PyObject * obj1 = 0 ;
6828 char *kwnames[] = {
6829 (char *) "self",(char *) "pt", NULL
6830 };
6831
6832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) goto fail;
6833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6834 if (SWIG_arg_fail(1)) SWIG_fail;
6835 {
6836 arg2 = &temp2;
6837 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6838 }
6839 {
6840 PyThreadState* __tstate = wxPyBeginAllowThreads();
6841 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
6842
6843 wxPyEndAllowThreads(__tstate);
6844 if (PyErr_Occurred()) SWIG_fail;
6845 }
6846 {
6847 resultobj = SWIG_From_double((double)(result));
6848 }
6849 return resultobj;
6850 fail:
6851 return NULL;
6852 }
6853
6854
6855 static PyObject *_wrap_Point2D_GetDotProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6856 PyObject *resultobj;
6857 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6858 wxPoint2D *arg2 = 0 ;
6859 double result;
6860 wxPoint2D temp2 ;
6861 PyObject * obj0 = 0 ;
6862 PyObject * obj1 = 0 ;
6863 char *kwnames[] = {
6864 (char *) "self",(char *) "vec", NULL
6865 };
6866
6867 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) goto fail;
6868 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6869 if (SWIG_arg_fail(1)) SWIG_fail;
6870 {
6871 arg2 = &temp2;
6872 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6873 }
6874 {
6875 PyThreadState* __tstate = wxPyBeginAllowThreads();
6876 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
6877
6878 wxPyEndAllowThreads(__tstate);
6879 if (PyErr_Occurred()) SWIG_fail;
6880 }
6881 {
6882 resultobj = SWIG_From_double((double)(result));
6883 }
6884 return resultobj;
6885 fail:
6886 return NULL;
6887 }
6888
6889
6890 static PyObject *_wrap_Point2D_GetCrossProduct(PyObject *, PyObject *args, PyObject *kwargs) {
6891 PyObject *resultobj;
6892 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6893 wxPoint2D *arg2 = 0 ;
6894 double result;
6895 wxPoint2D temp2 ;
6896 PyObject * obj0 = 0 ;
6897 PyObject * obj1 = 0 ;
6898 char *kwnames[] = {
6899 (char *) "self",(char *) "vec", NULL
6900 };
6901
6902 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) goto fail;
6903 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6904 if (SWIG_arg_fail(1)) SWIG_fail;
6905 {
6906 arg2 = &temp2;
6907 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6908 }
6909 {
6910 PyThreadState* __tstate = wxPyBeginAllowThreads();
6911 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
6912
6913 wxPyEndAllowThreads(__tstate);
6914 if (PyErr_Occurred()) SWIG_fail;
6915 }
6916 {
6917 resultobj = SWIG_From_double((double)(result));
6918 }
6919 return resultobj;
6920 fail:
6921 return NULL;
6922 }
6923
6924
6925 static PyObject *_wrap_Point2D___neg__(PyObject *, PyObject *args, PyObject *kwargs) {
6926 PyObject *resultobj;
6927 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6928 wxPoint2D result;
6929 PyObject * obj0 = 0 ;
6930 char *kwnames[] = {
6931 (char *) "self", NULL
6932 };
6933
6934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D___neg__",kwnames,&obj0)) goto fail;
6935 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
6936 if (SWIG_arg_fail(1)) SWIG_fail;
6937 {
6938 PyThreadState* __tstate = wxPyBeginAllowThreads();
6939 result = (arg1)->operator -();
6940
6941 wxPyEndAllowThreads(__tstate);
6942 if (PyErr_Occurred()) SWIG_fail;
6943 }
6944 {
6945 wxPoint2D * resultptr;
6946 resultptr = new wxPoint2D((wxPoint2D &)(result));
6947 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint2D, 1);
6948 }
6949 return resultobj;
6950 fail:
6951 return NULL;
6952 }
6953
6954
6955 static PyObject *_wrap_Point2D___iadd__(PyObject *, PyObject *args, PyObject *kwargs) {
6956 PyObject *resultobj;
6957 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6958 wxPoint2D *arg2 = 0 ;
6959 wxPoint2D *result;
6960 wxPoint2D temp2 ;
6961 PyObject * obj0 = 0 ;
6962 PyObject * obj1 = 0 ;
6963 char *kwnames[] = {
6964 (char *) "self",(char *) "pt", NULL
6965 };
6966
6967 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) goto fail;
6968 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
6969 if (SWIG_arg_fail(1)) SWIG_fail;
6970 {
6971 arg2 = &temp2;
6972 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
6973 }
6974 {
6975 PyThreadState* __tstate = wxPyBeginAllowThreads();
6976 {
6977 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
6978 result = (wxPoint2D *) &_result_ref;
6979 }
6980
6981 wxPyEndAllowThreads(__tstate);
6982 if (PyErr_Occurred()) SWIG_fail;
6983 }
6984 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
6985 return resultobj;
6986 fail:
6987 return NULL;
6988 }
6989
6990
6991 static PyObject *_wrap_Point2D___isub__(PyObject *, PyObject *args, PyObject *kwargs) {
6992 PyObject *resultobj;
6993 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
6994 wxPoint2D *arg2 = 0 ;
6995 wxPoint2D *result;
6996 wxPoint2D temp2 ;
6997 PyObject * obj0 = 0 ;
6998 PyObject * obj1 = 0 ;
6999 char *kwnames[] = {
7000 (char *) "self",(char *) "pt", NULL
7001 };
7002
7003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) goto fail;
7004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7005 if (SWIG_arg_fail(1)) SWIG_fail;
7006 {
7007 arg2 = &temp2;
7008 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7009 }
7010 {
7011 PyThreadState* __tstate = wxPyBeginAllowThreads();
7012 {
7013 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
7014 result = (wxPoint2D *) &_result_ref;
7015 }
7016
7017 wxPyEndAllowThreads(__tstate);
7018 if (PyErr_Occurred()) SWIG_fail;
7019 }
7020 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7021 return resultobj;
7022 fail:
7023 return NULL;
7024 }
7025
7026
7027 static PyObject *_wrap_Point2D___imul__(PyObject *, PyObject *args, PyObject *kwargs) {
7028 PyObject *resultobj;
7029 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7030 wxPoint2D *arg2 = 0 ;
7031 wxPoint2D *result;
7032 wxPoint2D temp2 ;
7033 PyObject * obj0 = 0 ;
7034 PyObject * obj1 = 0 ;
7035 char *kwnames[] = {
7036 (char *) "self",(char *) "pt", NULL
7037 };
7038
7039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) goto fail;
7040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7041 if (SWIG_arg_fail(1)) SWIG_fail;
7042 {
7043 arg2 = &temp2;
7044 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7045 }
7046 {
7047 PyThreadState* __tstate = wxPyBeginAllowThreads();
7048 {
7049 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
7050 result = (wxPoint2D *) &_result_ref;
7051 }
7052
7053 wxPyEndAllowThreads(__tstate);
7054 if (PyErr_Occurred()) SWIG_fail;
7055 }
7056 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7057 return resultobj;
7058 fail:
7059 return NULL;
7060 }
7061
7062
7063 static PyObject *_wrap_Point2D___idiv__(PyObject *, PyObject *args, PyObject *kwargs) {
7064 PyObject *resultobj;
7065 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7066 wxPoint2D *arg2 = 0 ;
7067 wxPoint2D *result;
7068 wxPoint2D temp2 ;
7069 PyObject * obj0 = 0 ;
7070 PyObject * obj1 = 0 ;
7071 char *kwnames[] = {
7072 (char *) "self",(char *) "pt", NULL
7073 };
7074
7075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) goto fail;
7076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
7077 if (SWIG_arg_fail(1)) SWIG_fail;
7078 {
7079 arg2 = &temp2;
7080 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7081 }
7082 {
7083 PyThreadState* __tstate = wxPyBeginAllowThreads();
7084 {
7085 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
7086 result = (wxPoint2D *) &_result_ref;
7087 }
7088
7089 wxPyEndAllowThreads(__tstate);
7090 if (PyErr_Occurred()) SWIG_fail;
7091 }
7092 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint2D, 1);
7093 return resultobj;
7094 fail:
7095 return NULL;
7096 }
7097
7098
7099 static PyObject *_wrap_Point2D___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
7100 PyObject *resultobj;
7101 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7102 wxPoint2D *arg2 = 0 ;
7103 bool result;
7104 wxPoint2D temp2 ;
7105 PyObject * obj0 = 0 ;
7106 PyObject * obj1 = 0 ;
7107 char *kwnames[] = {
7108 (char *) "self",(char *) "pt", NULL
7109 };
7110
7111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) goto fail;
7112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7113 if (SWIG_arg_fail(1)) SWIG_fail;
7114 {
7115 arg2 = &temp2;
7116 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7117 }
7118 {
7119 PyThreadState* __tstate = wxPyBeginAllowThreads();
7120 result = (bool)((wxPoint2D const *)arg1)->operator ==((wxPoint2D const &)*arg2);
7121
7122 wxPyEndAllowThreads(__tstate);
7123 if (PyErr_Occurred()) SWIG_fail;
7124 }
7125 {
7126 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7127 }
7128 return resultobj;
7129 fail:
7130 return NULL;
7131 }
7132
7133
7134 static PyObject *_wrap_Point2D___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
7135 PyObject *resultobj;
7136 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7137 wxPoint2D *arg2 = 0 ;
7138 bool result;
7139 wxPoint2D temp2 ;
7140 PyObject * obj0 = 0 ;
7141 PyObject * obj1 = 0 ;
7142 char *kwnames[] = {
7143 (char *) "self",(char *) "pt", NULL
7144 };
7145
7146 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) goto fail;
7147 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7148 if (SWIG_arg_fail(1)) SWIG_fail;
7149 {
7150 arg2 = &temp2;
7151 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
7152 }
7153 {
7154 PyThreadState* __tstate = wxPyBeginAllowThreads();
7155 result = (bool)((wxPoint2D const *)arg1)->operator !=((wxPoint2D const &)*arg2);
7156
7157 wxPyEndAllowThreads(__tstate);
7158 if (PyErr_Occurred()) SWIG_fail;
7159 }
7160 {
7161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7162 }
7163 return resultobj;
7164 fail:
7165 return NULL;
7166 }
7167
7168
7169 static PyObject *_wrap_Point2D_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
7170 PyObject *resultobj;
7171 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7172 double arg2 ;
7173 PyObject * obj0 = 0 ;
7174 PyObject * obj1 = 0 ;
7175 char *kwnames[] = {
7176 (char *) "self",(char *) "m_x", NULL
7177 };
7178
7179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_x_set",kwnames,&obj0,&obj1)) goto fail;
7180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7181 if (SWIG_arg_fail(1)) SWIG_fail;
7182 {
7183 arg2 = (double)(SWIG_As_double(obj1));
7184 if (SWIG_arg_fail(2)) SWIG_fail;
7185 }
7186 if (arg1) (arg1)->m_x = arg2;
7187
7188 Py_INCREF(Py_None); resultobj = Py_None;
7189 return resultobj;
7190 fail:
7191 return NULL;
7192 }
7193
7194
7195 static PyObject *_wrap_Point2D_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
7196 PyObject *resultobj;
7197 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7198 double result;
7199 PyObject * obj0 = 0 ;
7200 char *kwnames[] = {
7201 (char *) "self", NULL
7202 };
7203
7204 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_x_get",kwnames,&obj0)) goto fail;
7205 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7206 if (SWIG_arg_fail(1)) SWIG_fail;
7207 result = (double) ((arg1)->m_x);
7208
7209 {
7210 resultobj = SWIG_From_double((double)(result));
7211 }
7212 return resultobj;
7213 fail:
7214 return NULL;
7215 }
7216
7217
7218 static PyObject *_wrap_Point2D_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
7219 PyObject *resultobj;
7220 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7221 double arg2 ;
7222 PyObject * obj0 = 0 ;
7223 PyObject * obj1 = 0 ;
7224 char *kwnames[] = {
7225 (char *) "self",(char *) "m_y", NULL
7226 };
7227
7228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_y_set",kwnames,&obj0,&obj1)) goto fail;
7229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7230 if (SWIG_arg_fail(1)) SWIG_fail;
7231 {
7232 arg2 = (double)(SWIG_As_double(obj1));
7233 if (SWIG_arg_fail(2)) SWIG_fail;
7234 }
7235 if (arg1) (arg1)->m_y = arg2;
7236
7237 Py_INCREF(Py_None); resultobj = Py_None;
7238 return resultobj;
7239 fail:
7240 return NULL;
7241 }
7242
7243
7244 static PyObject *_wrap_Point2D_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
7245 PyObject *resultobj;
7246 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7247 double result;
7248 PyObject * obj0 = 0 ;
7249 char *kwnames[] = {
7250 (char *) "self", NULL
7251 };
7252
7253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_y_get",kwnames,&obj0)) goto fail;
7254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7255 if (SWIG_arg_fail(1)) SWIG_fail;
7256 result = (double) ((arg1)->m_y);
7257
7258 {
7259 resultobj = SWIG_From_double((double)(result));
7260 }
7261 return resultobj;
7262 fail:
7263 return NULL;
7264 }
7265
7266
7267 static PyObject *_wrap_Point2D_Set(PyObject *, PyObject *args, PyObject *kwargs) {
7268 PyObject *resultobj;
7269 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7270 double arg2 = (double) 0 ;
7271 double arg3 = (double) 0 ;
7272 PyObject * obj0 = 0 ;
7273 PyObject * obj1 = 0 ;
7274 PyObject * obj2 = 0 ;
7275 char *kwnames[] = {
7276 (char *) "self",(char *) "x",(char *) "y", NULL
7277 };
7278
7279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
7280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7281 if (SWIG_arg_fail(1)) SWIG_fail;
7282 if (obj1) {
7283 {
7284 arg2 = (double)(SWIG_As_double(obj1));
7285 if (SWIG_arg_fail(2)) SWIG_fail;
7286 }
7287 }
7288 if (obj2) {
7289 {
7290 arg3 = (double)(SWIG_As_double(obj2));
7291 if (SWIG_arg_fail(3)) SWIG_fail;
7292 }
7293 }
7294 {
7295 PyThreadState* __tstate = wxPyBeginAllowThreads();
7296 wxPoint2D_Set(arg1,arg2,arg3);
7297
7298 wxPyEndAllowThreads(__tstate);
7299 if (PyErr_Occurred()) SWIG_fail;
7300 }
7301 Py_INCREF(Py_None); resultobj = Py_None;
7302 return resultobj;
7303 fail:
7304 return NULL;
7305 }
7306
7307
7308 static PyObject *_wrap_Point2D_Get(PyObject *, PyObject *args, PyObject *kwargs) {
7309 PyObject *resultobj;
7310 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
7311 PyObject *result;
7312 PyObject * obj0 = 0 ;
7313 char *kwnames[] = {
7314 (char *) "self", NULL
7315 };
7316
7317 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Point2D_Get",kwnames,&obj0)) goto fail;
7318 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPoint2D, SWIG_POINTER_EXCEPTION | 0);
7319 if (SWIG_arg_fail(1)) SWIG_fail;
7320 {
7321 PyThreadState* __tstate = wxPyBeginAllowThreads();
7322 result = (PyObject *)wxPoint2D_Get(arg1);
7323
7324 wxPyEndAllowThreads(__tstate);
7325 if (PyErr_Occurred()) SWIG_fail;
7326 }
7327 resultobj = result;
7328 return resultobj;
7329 fail:
7330 return NULL;
7331 }
7332
7333
7334 static PyObject * Point2D_swigregister(PyObject *, PyObject *args) {
7335 PyObject *obj;
7336 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7337 SWIG_TypeClientData(SWIGTYPE_p_wxPoint2D, obj);
7338 Py_INCREF(obj);
7339 return Py_BuildValue((char *)"");
7340 }
7341 static int _wrap_DefaultPosition_set(PyObject *) {
7342 PyErr_SetString(PyExc_TypeError,"Variable DefaultPosition is read-only.");
7343 return 1;
7344 }
7345
7346
7347 static PyObject *_wrap_DefaultPosition_get(void) {
7348 PyObject *pyobj;
7349
7350 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0);
7351 return pyobj;
7352 }
7353
7354
7355 static int _wrap_DefaultSize_set(PyObject *) {
7356 PyErr_SetString(PyExc_TypeError,"Variable DefaultSize is read-only.");
7357 return 1;
7358 }
7359
7360
7361 static PyObject *_wrap_DefaultSize_get(void) {
7362 PyObject *pyobj;
7363
7364 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSize), SWIGTYPE_p_wxSize, 0);
7365 return pyobj;
7366 }
7367
7368
7369 static PyObject *_wrap_new_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7370 PyObject *resultobj;
7371 PyObject *arg1 = (PyObject *) 0 ;
7372 wxPyInputStream *result;
7373 PyObject * obj0 = 0 ;
7374 char *kwnames[] = {
7375 (char *) "p", NULL
7376 };
7377
7378 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) goto fail;
7379 arg1 = obj0;
7380 {
7381 PyThreadState* __tstate = wxPyBeginAllowThreads();
7382 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
7383
7384 wxPyEndAllowThreads(__tstate);
7385 if (PyErr_Occurred()) SWIG_fail;
7386 }
7387 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyInputStream, 1);
7388 return resultobj;
7389 fail:
7390 return NULL;
7391 }
7392
7393
7394 static PyObject *_wrap_delete_InputStream(PyObject *, PyObject *args, PyObject *kwargs) {
7395 PyObject *resultobj;
7396 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7397 PyObject * obj0 = 0 ;
7398 char *kwnames[] = {
7399 (char *) "self", NULL
7400 };
7401
7402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_InputStream",kwnames,&obj0)) goto fail;
7403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7404 if (SWIG_arg_fail(1)) SWIG_fail;
7405 {
7406 PyThreadState* __tstate = wxPyBeginAllowThreads();
7407 delete arg1;
7408
7409 wxPyEndAllowThreads(__tstate);
7410 if (PyErr_Occurred()) SWIG_fail;
7411 }
7412 Py_INCREF(Py_None); resultobj = Py_None;
7413 return resultobj;
7414 fail:
7415 return NULL;
7416 }
7417
7418
7419 static PyObject *_wrap_InputStream_close(PyObject *, PyObject *args, PyObject *kwargs) {
7420 PyObject *resultobj;
7421 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7422 PyObject * obj0 = 0 ;
7423 char *kwnames[] = {
7424 (char *) "self", NULL
7425 };
7426
7427 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_close",kwnames,&obj0)) goto fail;
7428 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7429 if (SWIG_arg_fail(1)) SWIG_fail;
7430 {
7431 PyThreadState* __tstate = wxPyBeginAllowThreads();
7432 (arg1)->close();
7433
7434 wxPyEndAllowThreads(__tstate);
7435 if (PyErr_Occurred()) SWIG_fail;
7436 }
7437 Py_INCREF(Py_None); resultobj = Py_None;
7438 return resultobj;
7439 fail:
7440 return NULL;
7441 }
7442
7443
7444 static PyObject *_wrap_InputStream_flush(PyObject *, PyObject *args, PyObject *kwargs) {
7445 PyObject *resultobj;
7446 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7447 PyObject * obj0 = 0 ;
7448 char *kwnames[] = {
7449 (char *) "self", NULL
7450 };
7451
7452 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_flush",kwnames,&obj0)) goto fail;
7453 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7454 if (SWIG_arg_fail(1)) SWIG_fail;
7455 {
7456 PyThreadState* __tstate = wxPyBeginAllowThreads();
7457 (arg1)->flush();
7458
7459 wxPyEndAllowThreads(__tstate);
7460 if (PyErr_Occurred()) SWIG_fail;
7461 }
7462 Py_INCREF(Py_None); resultobj = Py_None;
7463 return resultobj;
7464 fail:
7465 return NULL;
7466 }
7467
7468
7469 static PyObject *_wrap_InputStream_eof(PyObject *, PyObject *args, PyObject *kwargs) {
7470 PyObject *resultobj;
7471 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7472 bool result;
7473 PyObject * obj0 = 0 ;
7474 char *kwnames[] = {
7475 (char *) "self", NULL
7476 };
7477
7478 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_eof",kwnames,&obj0)) goto fail;
7479 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7480 if (SWIG_arg_fail(1)) SWIG_fail;
7481 {
7482 PyThreadState* __tstate = wxPyBeginAllowThreads();
7483 result = (bool)(arg1)->eof();
7484
7485 wxPyEndAllowThreads(__tstate);
7486 if (PyErr_Occurred()) SWIG_fail;
7487 }
7488 {
7489 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7490 }
7491 return resultobj;
7492 fail:
7493 return NULL;
7494 }
7495
7496
7497 static PyObject *_wrap_InputStream_read(PyObject *, PyObject *args, PyObject *kwargs) {
7498 PyObject *resultobj;
7499 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7500 int arg2 = (int) -1 ;
7501 PyObject *result;
7502 PyObject * obj0 = 0 ;
7503 PyObject * obj1 = 0 ;
7504 char *kwnames[] = {
7505 (char *) "self",(char *) "size", NULL
7506 };
7507
7508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) goto fail;
7509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7510 if (SWIG_arg_fail(1)) SWIG_fail;
7511 if (obj1) {
7512 {
7513 arg2 = (int)(SWIG_As_int(obj1));
7514 if (SWIG_arg_fail(2)) SWIG_fail;
7515 }
7516 }
7517 {
7518 PyThreadState* __tstate = wxPyBeginAllowThreads();
7519 result = (PyObject *)(arg1)->read(arg2);
7520
7521 wxPyEndAllowThreads(__tstate);
7522 if (PyErr_Occurred()) SWIG_fail;
7523 }
7524 resultobj = result;
7525 return resultobj;
7526 fail:
7527 return NULL;
7528 }
7529
7530
7531 static PyObject *_wrap_InputStream_readline(PyObject *, PyObject *args, PyObject *kwargs) {
7532 PyObject *resultobj;
7533 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7534 int arg2 = (int) -1 ;
7535 PyObject *result;
7536 PyObject * obj0 = 0 ;
7537 PyObject * obj1 = 0 ;
7538 char *kwnames[] = {
7539 (char *) "self",(char *) "size", NULL
7540 };
7541
7542 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) goto fail;
7543 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7544 if (SWIG_arg_fail(1)) SWIG_fail;
7545 if (obj1) {
7546 {
7547 arg2 = (int)(SWIG_As_int(obj1));
7548 if (SWIG_arg_fail(2)) SWIG_fail;
7549 }
7550 }
7551 {
7552 PyThreadState* __tstate = wxPyBeginAllowThreads();
7553 result = (PyObject *)(arg1)->readline(arg2);
7554
7555 wxPyEndAllowThreads(__tstate);
7556 if (PyErr_Occurred()) SWIG_fail;
7557 }
7558 resultobj = result;
7559 return resultobj;
7560 fail:
7561 return NULL;
7562 }
7563
7564
7565 static PyObject *_wrap_InputStream_readlines(PyObject *, PyObject *args, PyObject *kwargs) {
7566 PyObject *resultobj;
7567 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7568 int arg2 = (int) -1 ;
7569 PyObject *result;
7570 PyObject * obj0 = 0 ;
7571 PyObject * obj1 = 0 ;
7572 char *kwnames[] = {
7573 (char *) "self",(char *) "sizehint", NULL
7574 };
7575
7576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) goto fail;
7577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7578 if (SWIG_arg_fail(1)) SWIG_fail;
7579 if (obj1) {
7580 {
7581 arg2 = (int)(SWIG_As_int(obj1));
7582 if (SWIG_arg_fail(2)) SWIG_fail;
7583 }
7584 }
7585 {
7586 PyThreadState* __tstate = wxPyBeginAllowThreads();
7587 result = (PyObject *)(arg1)->readlines(arg2);
7588
7589 wxPyEndAllowThreads(__tstate);
7590 if (PyErr_Occurred()) SWIG_fail;
7591 }
7592 resultobj = result;
7593 return resultobj;
7594 fail:
7595 return NULL;
7596 }
7597
7598
7599 static PyObject *_wrap_InputStream_seek(PyObject *, PyObject *args, PyObject *kwargs) {
7600 PyObject *resultobj;
7601 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7602 int arg2 ;
7603 int arg3 = (int) 0 ;
7604 PyObject * obj0 = 0 ;
7605 PyObject * obj1 = 0 ;
7606 PyObject * obj2 = 0 ;
7607 char *kwnames[] = {
7608 (char *) "self",(char *) "offset",(char *) "whence", NULL
7609 };
7610
7611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) goto fail;
7612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7613 if (SWIG_arg_fail(1)) SWIG_fail;
7614 {
7615 arg2 = (int)(SWIG_As_int(obj1));
7616 if (SWIG_arg_fail(2)) SWIG_fail;
7617 }
7618 if (obj2) {
7619 {
7620 arg3 = (int)(SWIG_As_int(obj2));
7621 if (SWIG_arg_fail(3)) SWIG_fail;
7622 }
7623 }
7624 {
7625 PyThreadState* __tstate = wxPyBeginAllowThreads();
7626 (arg1)->seek(arg2,arg3);
7627
7628 wxPyEndAllowThreads(__tstate);
7629 if (PyErr_Occurred()) SWIG_fail;
7630 }
7631 Py_INCREF(Py_None); resultobj = Py_None;
7632 return resultobj;
7633 fail:
7634 return NULL;
7635 }
7636
7637
7638 static PyObject *_wrap_InputStream_tell(PyObject *, PyObject *args, PyObject *kwargs) {
7639 PyObject *resultobj;
7640 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7641 int result;
7642 PyObject * obj0 = 0 ;
7643 char *kwnames[] = {
7644 (char *) "self", NULL
7645 };
7646
7647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_tell",kwnames,&obj0)) goto fail;
7648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7649 if (SWIG_arg_fail(1)) SWIG_fail;
7650 {
7651 PyThreadState* __tstate = wxPyBeginAllowThreads();
7652 result = (int)(arg1)->tell();
7653
7654 wxPyEndAllowThreads(__tstate);
7655 if (PyErr_Occurred()) SWIG_fail;
7656 }
7657 {
7658 resultobj = SWIG_From_int((int)(result));
7659 }
7660 return resultobj;
7661 fail:
7662 return NULL;
7663 }
7664
7665
7666 static PyObject *_wrap_InputStream_Peek(PyObject *, PyObject *args, PyObject *kwargs) {
7667 PyObject *resultobj;
7668 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7669 char result;
7670 PyObject * obj0 = 0 ;
7671 char *kwnames[] = {
7672 (char *) "self", NULL
7673 };
7674
7675 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Peek",kwnames,&obj0)) goto fail;
7676 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7677 if (SWIG_arg_fail(1)) SWIG_fail;
7678 {
7679 PyThreadState* __tstate = wxPyBeginAllowThreads();
7680 result = (char)(arg1)->Peek();
7681
7682 wxPyEndAllowThreads(__tstate);
7683 if (PyErr_Occurred()) SWIG_fail;
7684 }
7685 {
7686 resultobj = SWIG_From_char((char)(result));
7687 }
7688 return resultobj;
7689 fail:
7690 return NULL;
7691 }
7692
7693
7694 static PyObject *_wrap_InputStream_GetC(PyObject *, PyObject *args, PyObject *kwargs) {
7695 PyObject *resultobj;
7696 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7697 char result;
7698 PyObject * obj0 = 0 ;
7699 char *kwnames[] = {
7700 (char *) "self", NULL
7701 };
7702
7703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_GetC",kwnames,&obj0)) goto fail;
7704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7705 if (SWIG_arg_fail(1)) SWIG_fail;
7706 {
7707 PyThreadState* __tstate = wxPyBeginAllowThreads();
7708 result = (char)(arg1)->GetC();
7709
7710 wxPyEndAllowThreads(__tstate);
7711 if (PyErr_Occurred()) SWIG_fail;
7712 }
7713 {
7714 resultobj = SWIG_From_char((char)(result));
7715 }
7716 return resultobj;
7717 fail:
7718 return NULL;
7719 }
7720
7721
7722 static PyObject *_wrap_InputStream_LastRead(PyObject *, PyObject *args, PyObject *kwargs) {
7723 PyObject *resultobj;
7724 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7725 size_t result;
7726 PyObject * obj0 = 0 ;
7727 char *kwnames[] = {
7728 (char *) "self", NULL
7729 };
7730
7731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_LastRead",kwnames,&obj0)) goto fail;
7732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7733 if (SWIG_arg_fail(1)) SWIG_fail;
7734 {
7735 PyThreadState* __tstate = wxPyBeginAllowThreads();
7736 result = (size_t)(arg1)->LastRead();
7737
7738 wxPyEndAllowThreads(__tstate);
7739 if (PyErr_Occurred()) SWIG_fail;
7740 }
7741 {
7742 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
7743 }
7744 return resultobj;
7745 fail:
7746 return NULL;
7747 }
7748
7749
7750 static PyObject *_wrap_InputStream_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
7751 PyObject *resultobj;
7752 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7753 bool result;
7754 PyObject * obj0 = 0 ;
7755 char *kwnames[] = {
7756 (char *) "self", NULL
7757 };
7758
7759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_CanRead",kwnames,&obj0)) goto fail;
7760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7761 if (SWIG_arg_fail(1)) SWIG_fail;
7762 {
7763 PyThreadState* __tstate = wxPyBeginAllowThreads();
7764 result = (bool)(arg1)->CanRead();
7765
7766 wxPyEndAllowThreads(__tstate);
7767 if (PyErr_Occurred()) SWIG_fail;
7768 }
7769 {
7770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7771 }
7772 return resultobj;
7773 fail:
7774 return NULL;
7775 }
7776
7777
7778 static PyObject *_wrap_InputStream_Eof(PyObject *, PyObject *args, PyObject *kwargs) {
7779 PyObject *resultobj;
7780 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7781 bool result;
7782 PyObject * obj0 = 0 ;
7783 char *kwnames[] = {
7784 (char *) "self", NULL
7785 };
7786
7787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_Eof",kwnames,&obj0)) goto fail;
7788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7789 if (SWIG_arg_fail(1)) SWIG_fail;
7790 {
7791 PyThreadState* __tstate = wxPyBeginAllowThreads();
7792 result = (bool)(arg1)->Eof();
7793
7794 wxPyEndAllowThreads(__tstate);
7795 if (PyErr_Occurred()) SWIG_fail;
7796 }
7797 {
7798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7799 }
7800 return resultobj;
7801 fail:
7802 return NULL;
7803 }
7804
7805
7806 static PyObject *_wrap_InputStream_Ungetch(PyObject *, PyObject *args, PyObject *kwargs) {
7807 PyObject *resultobj;
7808 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7809 char arg2 ;
7810 bool result;
7811 PyObject * obj0 = 0 ;
7812 PyObject * obj1 = 0 ;
7813 char *kwnames[] = {
7814 (char *) "self",(char *) "c", NULL
7815 };
7816
7817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) goto fail;
7818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7819 if (SWIG_arg_fail(1)) SWIG_fail;
7820 {
7821 arg2 = (char)(SWIG_As_char(obj1));
7822 if (SWIG_arg_fail(2)) SWIG_fail;
7823 }
7824 {
7825 PyThreadState* __tstate = wxPyBeginAllowThreads();
7826 result = (bool)(arg1)->Ungetch(arg2);
7827
7828 wxPyEndAllowThreads(__tstate);
7829 if (PyErr_Occurred()) SWIG_fail;
7830 }
7831 {
7832 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7833 }
7834 return resultobj;
7835 fail:
7836 return NULL;
7837 }
7838
7839
7840 static PyObject *_wrap_InputStream_SeekI(PyObject *, PyObject *args, PyObject *kwargs) {
7841 PyObject *resultobj;
7842 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7843 long arg2 ;
7844 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
7845 long result;
7846 PyObject * obj0 = 0 ;
7847 PyObject * obj1 = 0 ;
7848 PyObject * obj2 = 0 ;
7849 char *kwnames[] = {
7850 (char *) "self",(char *) "pos",(char *) "mode", NULL
7851 };
7852
7853 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) goto fail;
7854 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7855 if (SWIG_arg_fail(1)) SWIG_fail;
7856 {
7857 arg2 = (long)(SWIG_As_long(obj1));
7858 if (SWIG_arg_fail(2)) SWIG_fail;
7859 }
7860 if (obj2) {
7861 {
7862 arg3 = (wxSeekMode)(SWIG_As_int(obj2));
7863 if (SWIG_arg_fail(3)) SWIG_fail;
7864 }
7865 }
7866 {
7867 PyThreadState* __tstate = wxPyBeginAllowThreads();
7868 result = (long)(arg1)->SeekI(arg2,(wxSeekMode )arg3);
7869
7870 wxPyEndAllowThreads(__tstate);
7871 if (PyErr_Occurred()) SWIG_fail;
7872 }
7873 {
7874 resultobj = SWIG_From_long((long)(result));
7875 }
7876 return resultobj;
7877 fail:
7878 return NULL;
7879 }
7880
7881
7882 static PyObject *_wrap_InputStream_TellI(PyObject *, PyObject *args, PyObject *kwargs) {
7883 PyObject *resultobj;
7884 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
7885 long result;
7886 PyObject * obj0 = 0 ;
7887 char *kwnames[] = {
7888 (char *) "self", NULL
7889 };
7890
7891 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:InputStream_TellI",kwnames,&obj0)) goto fail;
7892 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_EXCEPTION | 0);
7893 if (SWIG_arg_fail(1)) SWIG_fail;
7894 {
7895 PyThreadState* __tstate = wxPyBeginAllowThreads();
7896 result = (long)(arg1)->TellI();
7897
7898 wxPyEndAllowThreads(__tstate);
7899 if (PyErr_Occurred()) SWIG_fail;
7900 }
7901 {
7902 resultobj = SWIG_From_long((long)(result));
7903 }
7904 return resultobj;
7905 fail:
7906 return NULL;
7907 }
7908
7909
7910 static PyObject * InputStream_swigregister(PyObject *, PyObject *args) {
7911 PyObject *obj;
7912 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7913 SWIG_TypeClientData(SWIGTYPE_p_wxPyInputStream, obj);
7914 Py_INCREF(obj);
7915 return Py_BuildValue((char *)"");
7916 }
7917 static PyObject *_wrap_OutputStream_write(PyObject *, PyObject *args, PyObject *kwargs) {
7918 PyObject *resultobj;
7919 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
7920 PyObject *arg2 = (PyObject *) 0 ;
7921 PyObject * obj0 = 0 ;
7922 PyObject * obj1 = 0 ;
7923 char *kwnames[] = {
7924 (char *) "self",(char *) "obj", NULL
7925 };
7926
7927 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) goto fail;
7928 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxOutputStream, SWIG_POINTER_EXCEPTION | 0);
7929 if (SWIG_arg_fail(1)) SWIG_fail;
7930 arg2 = obj1;
7931 {
7932 PyThreadState* __tstate = wxPyBeginAllowThreads();
7933 wxOutputStream_write(arg1,arg2);
7934
7935 wxPyEndAllowThreads(__tstate);
7936 if (PyErr_Occurred()) SWIG_fail;
7937 }
7938 Py_INCREF(Py_None); resultobj = Py_None;
7939 return resultobj;
7940 fail:
7941 return NULL;
7942 }
7943
7944
7945 static PyObject * OutputStream_swigregister(PyObject *, PyObject *args) {
7946 PyObject *obj;
7947 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
7948 SWIG_TypeClientData(SWIGTYPE_p_wxOutputStream, obj);
7949 Py_INCREF(obj);
7950 return Py_BuildValue((char *)"");
7951 }
7952 static PyObject *_wrap_new_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
7953 PyObject *resultobj;
7954 wxInputStream *arg1 = (wxInputStream *) 0 ;
7955 wxString *arg2 = 0 ;
7956 wxString *arg3 = 0 ;
7957 wxString *arg4 = 0 ;
7958 wxDateTime arg5 ;
7959 wxFSFile *result;
7960 wxPyInputStream *temp1 ;
7961 bool temp2 = false ;
7962 bool temp3 = false ;
7963 bool temp4 = false ;
7964 PyObject * obj0 = 0 ;
7965 PyObject * obj1 = 0 ;
7966 PyObject * obj2 = 0 ;
7967 PyObject * obj3 = 0 ;
7968 PyObject * obj4 = 0 ;
7969 char *kwnames[] = {
7970 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
7971 };
7972
7973 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
7974 {
7975 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
7976 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
7977 } else {
7978 PyErr_Clear(); // clear the failure of the wxPyConvert above
7979 arg1 = wxPyCBInputStream_create(obj0, true);
7980 if (arg1 == NULL) {
7981 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
7982 SWIG_fail;
7983 }
7984 }
7985 }
7986 {
7987 arg2 = wxString_in_helper(obj1);
7988 if (arg2 == NULL) SWIG_fail;
7989 temp2 = true;
7990 }
7991 {
7992 arg3 = wxString_in_helper(obj2);
7993 if (arg3 == NULL) SWIG_fail;
7994 temp3 = true;
7995 }
7996 {
7997 arg4 = wxString_in_helper(obj3);
7998 if (arg4 == NULL) SWIG_fail;
7999 temp4 = true;
8000 }
8001 {
8002 wxDateTime * argp;
8003 SWIG_Python_ConvertPtr(obj4, (void **)&argp, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION);
8004 if (SWIG_arg_fail(5)) SWIG_fail;
8005 if (argp == NULL) {
8006 SWIG_null_ref("wxDateTime");
8007 }
8008 if (SWIG_arg_fail(5)) SWIG_fail;
8009 arg5 = *argp;
8010 }
8011 {
8012 PyThreadState* __tstate = wxPyBeginAllowThreads();
8013 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
8014
8015 wxPyEndAllowThreads(__tstate);
8016 if (PyErr_Occurred()) SWIG_fail;
8017 }
8018 {
8019 resultobj = wxPyMake_wxObject(result, 1);
8020 }
8021 {
8022 if (temp2)
8023 delete arg2;
8024 }
8025 {
8026 if (temp3)
8027 delete arg3;
8028 }
8029 {
8030 if (temp4)
8031 delete arg4;
8032 }
8033 return resultobj;
8034 fail:
8035 {
8036 if (temp2)
8037 delete arg2;
8038 }
8039 {
8040 if (temp3)
8041 delete arg3;
8042 }
8043 {
8044 if (temp4)
8045 delete arg4;
8046 }
8047 return NULL;
8048 }
8049
8050
8051 static PyObject *_wrap_delete_FSFile(PyObject *, PyObject *args, PyObject *kwargs) {
8052 PyObject *resultobj;
8053 wxFSFile *arg1 = (wxFSFile *) 0 ;
8054 PyObject * obj0 = 0 ;
8055 char *kwnames[] = {
8056 (char *) "self", NULL
8057 };
8058
8059 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FSFile",kwnames,&obj0)) goto fail;
8060 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8061 if (SWIG_arg_fail(1)) SWIG_fail;
8062 {
8063 PyThreadState* __tstate = wxPyBeginAllowThreads();
8064 delete arg1;
8065
8066 wxPyEndAllowThreads(__tstate);
8067 if (PyErr_Occurred()) SWIG_fail;
8068 }
8069 Py_INCREF(Py_None); resultobj = Py_None;
8070 return resultobj;
8071 fail:
8072 return NULL;
8073 }
8074
8075
8076 static PyObject *_wrap_FSFile_GetStream(PyObject *, PyObject *args, PyObject *kwargs) {
8077 PyObject *resultobj;
8078 wxFSFile *arg1 = (wxFSFile *) 0 ;
8079 wxInputStream *result;
8080 PyObject * obj0 = 0 ;
8081 char *kwnames[] = {
8082 (char *) "self", NULL
8083 };
8084
8085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetStream",kwnames,&obj0)) goto fail;
8086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8087 if (SWIG_arg_fail(1)) SWIG_fail;
8088 {
8089 PyThreadState* __tstate = wxPyBeginAllowThreads();
8090 result = (wxInputStream *)(arg1)->GetStream();
8091
8092 wxPyEndAllowThreads(__tstate);
8093 if (PyErr_Occurred()) SWIG_fail;
8094 }
8095 {
8096 wxPyInputStream * _ptr = NULL;
8097
8098 if (result) {
8099 _ptr = new wxPyInputStream(result);
8100 }
8101 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
8102 }
8103 return resultobj;
8104 fail:
8105 return NULL;
8106 }
8107
8108
8109 static PyObject *_wrap_FSFile_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
8110 PyObject *resultobj;
8111 wxFSFile *arg1 = (wxFSFile *) 0 ;
8112 wxString *result;
8113 PyObject * obj0 = 0 ;
8114 char *kwnames[] = {
8115 (char *) "self", NULL
8116 };
8117
8118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetMimeType",kwnames,&obj0)) goto fail;
8119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8120 if (SWIG_arg_fail(1)) SWIG_fail;
8121 {
8122 PyThreadState* __tstate = wxPyBeginAllowThreads();
8123 {
8124 wxString const &_result_ref = (arg1)->GetMimeType();
8125 result = (wxString *) &_result_ref;
8126 }
8127
8128 wxPyEndAllowThreads(__tstate);
8129 if (PyErr_Occurred()) SWIG_fail;
8130 }
8131 {
8132 #if wxUSE_UNICODE
8133 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8134 #else
8135 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8136 #endif
8137 }
8138 return resultobj;
8139 fail:
8140 return NULL;
8141 }
8142
8143
8144 static PyObject *_wrap_FSFile_GetLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8145 PyObject *resultobj;
8146 wxFSFile *arg1 = (wxFSFile *) 0 ;
8147 wxString *result;
8148 PyObject * obj0 = 0 ;
8149 char *kwnames[] = {
8150 (char *) "self", NULL
8151 };
8152
8153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetLocation",kwnames,&obj0)) goto fail;
8154 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8155 if (SWIG_arg_fail(1)) SWIG_fail;
8156 {
8157 PyThreadState* __tstate = wxPyBeginAllowThreads();
8158 {
8159 wxString const &_result_ref = (arg1)->GetLocation();
8160 result = (wxString *) &_result_ref;
8161 }
8162
8163 wxPyEndAllowThreads(__tstate);
8164 if (PyErr_Occurred()) SWIG_fail;
8165 }
8166 {
8167 #if wxUSE_UNICODE
8168 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8169 #else
8170 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8171 #endif
8172 }
8173 return resultobj;
8174 fail:
8175 return NULL;
8176 }
8177
8178
8179 static PyObject *_wrap_FSFile_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8180 PyObject *resultobj;
8181 wxFSFile *arg1 = (wxFSFile *) 0 ;
8182 wxString *result;
8183 PyObject * obj0 = 0 ;
8184 char *kwnames[] = {
8185 (char *) "self", NULL
8186 };
8187
8188 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetAnchor",kwnames,&obj0)) goto fail;
8189 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8190 if (SWIG_arg_fail(1)) SWIG_fail;
8191 {
8192 PyThreadState* __tstate = wxPyBeginAllowThreads();
8193 {
8194 wxString const &_result_ref = (arg1)->GetAnchor();
8195 result = (wxString *) &_result_ref;
8196 }
8197
8198 wxPyEndAllowThreads(__tstate);
8199 if (PyErr_Occurred()) SWIG_fail;
8200 }
8201 {
8202 #if wxUSE_UNICODE
8203 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
8204 #else
8205 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
8206 #endif
8207 }
8208 return resultobj;
8209 fail:
8210 return NULL;
8211 }
8212
8213
8214 static PyObject *_wrap_FSFile_GetModificationTime(PyObject *, PyObject *args, PyObject *kwargs) {
8215 PyObject *resultobj;
8216 wxFSFile *arg1 = (wxFSFile *) 0 ;
8217 wxDateTime result;
8218 PyObject * obj0 = 0 ;
8219 char *kwnames[] = {
8220 (char *) "self", NULL
8221 };
8222
8223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FSFile_GetModificationTime",kwnames,&obj0)) goto fail;
8224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFSFile, SWIG_POINTER_EXCEPTION | 0);
8225 if (SWIG_arg_fail(1)) SWIG_fail;
8226 {
8227 PyThreadState* __tstate = wxPyBeginAllowThreads();
8228 result = (arg1)->GetModificationTime();
8229
8230 wxPyEndAllowThreads(__tstate);
8231 if (PyErr_Occurred()) SWIG_fail;
8232 }
8233 {
8234 wxDateTime * resultptr;
8235 resultptr = new wxDateTime((wxDateTime &)(result));
8236 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxDateTime, 1);
8237 }
8238 return resultobj;
8239 fail:
8240 return NULL;
8241 }
8242
8243
8244 static PyObject * FSFile_swigregister(PyObject *, PyObject *args) {
8245 PyObject *obj;
8246 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8247 SWIG_TypeClientData(SWIGTYPE_p_wxFSFile, obj);
8248 Py_INCREF(obj);
8249 return Py_BuildValue((char *)"");
8250 }
8251 static PyObject * CPPFileSystemHandler_swigregister(PyObject *, PyObject *args) {
8252 PyObject *obj;
8253 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8254 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystemHandler, obj);
8255 Py_INCREF(obj);
8256 return Py_BuildValue((char *)"");
8257 }
8258 static PyObject *_wrap_new_FileSystemHandler(PyObject *, PyObject *args, PyObject *kwargs) {
8259 PyObject *resultobj;
8260 wxPyFileSystemHandler *result;
8261 char *kwnames[] = {
8262 NULL
8263 };
8264
8265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystemHandler",kwnames)) goto fail;
8266 {
8267 PyThreadState* __tstate = wxPyBeginAllowThreads();
8268 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
8269
8270 wxPyEndAllowThreads(__tstate);
8271 if (PyErr_Occurred()) SWIG_fail;
8272 }
8273 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyFileSystemHandler, 1);
8274 return resultobj;
8275 fail:
8276 return NULL;
8277 }
8278
8279
8280 static PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
8281 PyObject *resultobj;
8282 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8283 PyObject *arg2 = (PyObject *) 0 ;
8284 PyObject *arg3 = (PyObject *) 0 ;
8285 PyObject * obj0 = 0 ;
8286 PyObject * obj1 = 0 ;
8287 PyObject * obj2 = 0 ;
8288 char *kwnames[] = {
8289 (char *) "self",(char *) "self",(char *) "_class", NULL
8290 };
8291
8292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8294 if (SWIG_arg_fail(1)) SWIG_fail;
8295 arg2 = obj1;
8296 arg3 = obj2;
8297 {
8298 PyThreadState* __tstate = wxPyBeginAllowThreads();
8299 (arg1)->_setCallbackInfo(arg2,arg3);
8300
8301 wxPyEndAllowThreads(__tstate);
8302 if (PyErr_Occurred()) SWIG_fail;
8303 }
8304 Py_INCREF(Py_None); resultobj = Py_None;
8305 return resultobj;
8306 fail:
8307 return NULL;
8308 }
8309
8310
8311 static PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
8312 PyObject *resultobj;
8313 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8314 wxString *arg2 = 0 ;
8315 bool result;
8316 bool temp2 = false ;
8317 PyObject * obj0 = 0 ;
8318 PyObject * obj1 = 0 ;
8319 char *kwnames[] = {
8320 (char *) "self",(char *) "location", NULL
8321 };
8322
8323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
8324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8325 if (SWIG_arg_fail(1)) SWIG_fail;
8326 {
8327 arg2 = wxString_in_helper(obj1);
8328 if (arg2 == NULL) SWIG_fail;
8329 temp2 = true;
8330 }
8331 {
8332 PyThreadState* __tstate = wxPyBeginAllowThreads();
8333 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
8334
8335 wxPyEndAllowThreads(__tstate);
8336 if (PyErr_Occurred()) SWIG_fail;
8337 }
8338 {
8339 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8340 }
8341 {
8342 if (temp2)
8343 delete arg2;
8344 }
8345 return resultobj;
8346 fail:
8347 {
8348 if (temp2)
8349 delete arg2;
8350 }
8351 return NULL;
8352 }
8353
8354
8355 static PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8356 PyObject *resultobj;
8357 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8358 wxFileSystem *arg2 = 0 ;
8359 wxString *arg3 = 0 ;
8360 wxFSFile *result;
8361 bool temp3 = false ;
8362 PyObject * obj0 = 0 ;
8363 PyObject * obj1 = 0 ;
8364 PyObject * obj2 = 0 ;
8365 char *kwnames[] = {
8366 (char *) "self",(char *) "fs",(char *) "location", NULL
8367 };
8368
8369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
8370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8371 if (SWIG_arg_fail(1)) SWIG_fail;
8372 {
8373 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8374 if (SWIG_arg_fail(2)) SWIG_fail;
8375 if (arg2 == NULL) {
8376 SWIG_null_ref("wxFileSystem");
8377 }
8378 if (SWIG_arg_fail(2)) SWIG_fail;
8379 }
8380 {
8381 arg3 = wxString_in_helper(obj2);
8382 if (arg3 == NULL) SWIG_fail;
8383 temp3 = true;
8384 }
8385 {
8386 PyThreadState* __tstate = wxPyBeginAllowThreads();
8387 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
8388
8389 wxPyEndAllowThreads(__tstate);
8390 if (PyErr_Occurred()) SWIG_fail;
8391 }
8392 {
8393 resultobj = wxPyMake_wxObject(result, 1);
8394 }
8395 {
8396 if (temp3)
8397 delete arg3;
8398 }
8399 return resultobj;
8400 fail:
8401 {
8402 if (temp3)
8403 delete arg3;
8404 }
8405 return NULL;
8406 }
8407
8408
8409 static PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8410 PyObject *resultobj;
8411 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8412 wxString *arg2 = 0 ;
8413 int arg3 = (int) 0 ;
8414 wxString result;
8415 bool temp2 = false ;
8416 PyObject * obj0 = 0 ;
8417 PyObject * obj1 = 0 ;
8418 PyObject * obj2 = 0 ;
8419 char *kwnames[] = {
8420 (char *) "self",(char *) "spec",(char *) "flags", NULL
8421 };
8422
8423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8425 if (SWIG_arg_fail(1)) SWIG_fail;
8426 {
8427 arg2 = wxString_in_helper(obj1);
8428 if (arg2 == NULL) SWIG_fail;
8429 temp2 = true;
8430 }
8431 if (obj2) {
8432 {
8433 arg3 = (int)(SWIG_As_int(obj2));
8434 if (SWIG_arg_fail(3)) SWIG_fail;
8435 }
8436 }
8437 {
8438 PyThreadState* __tstate = wxPyBeginAllowThreads();
8439 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8440
8441 wxPyEndAllowThreads(__tstate);
8442 if (PyErr_Occurred()) SWIG_fail;
8443 }
8444 {
8445 #if wxUSE_UNICODE
8446 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8447 #else
8448 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8449 #endif
8450 }
8451 {
8452 if (temp2)
8453 delete arg2;
8454 }
8455 return resultobj;
8456 fail:
8457 {
8458 if (temp2)
8459 delete arg2;
8460 }
8461 return NULL;
8462 }
8463
8464
8465 static PyObject *_wrap_FileSystemHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8466 PyObject *resultobj;
8467 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8468 wxString result;
8469 PyObject * obj0 = 0 ;
8470 char *kwnames[] = {
8471 (char *) "self", NULL
8472 };
8473
8474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystemHandler_FindNext",kwnames,&obj0)) goto fail;
8475 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8476 if (SWIG_arg_fail(1)) SWIG_fail;
8477 {
8478 PyThreadState* __tstate = wxPyBeginAllowThreads();
8479 result = (arg1)->FindNext();
8480
8481 wxPyEndAllowThreads(__tstate);
8482 if (PyErr_Occurred()) SWIG_fail;
8483 }
8484 {
8485 #if wxUSE_UNICODE
8486 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8487 #else
8488 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8489 #endif
8490 }
8491 return resultobj;
8492 fail:
8493 return NULL;
8494 }
8495
8496
8497 static PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *, PyObject *args, PyObject *kwargs) {
8498 PyObject *resultobj;
8499 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8500 wxString *arg2 = 0 ;
8501 wxString result;
8502 bool temp2 = false ;
8503 PyObject * obj0 = 0 ;
8504 PyObject * obj1 = 0 ;
8505 char *kwnames[] = {
8506 (char *) "self",(char *) "location", NULL
8507 };
8508
8509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) goto fail;
8510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8511 if (SWIG_arg_fail(1)) SWIG_fail;
8512 {
8513 arg2 = wxString_in_helper(obj1);
8514 if (arg2 == NULL) SWIG_fail;
8515 temp2 = true;
8516 }
8517 {
8518 PyThreadState* __tstate = wxPyBeginAllowThreads();
8519 result = (arg1)->GetProtocol((wxString const &)*arg2);
8520
8521 wxPyEndAllowThreads(__tstate);
8522 if (PyErr_Occurred()) SWIG_fail;
8523 }
8524 {
8525 #if wxUSE_UNICODE
8526 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8527 #else
8528 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8529 #endif
8530 }
8531 {
8532 if (temp2)
8533 delete arg2;
8534 }
8535 return resultobj;
8536 fail:
8537 {
8538 if (temp2)
8539 delete arg2;
8540 }
8541 return NULL;
8542 }
8543
8544
8545 static PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8546 PyObject *resultobj;
8547 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8548 wxString *arg2 = 0 ;
8549 wxString result;
8550 bool temp2 = false ;
8551 PyObject * obj0 = 0 ;
8552 PyObject * obj1 = 0 ;
8553 char *kwnames[] = {
8554 (char *) "self",(char *) "location", NULL
8555 };
8556
8557 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) goto fail;
8558 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8559 if (SWIG_arg_fail(1)) SWIG_fail;
8560 {
8561 arg2 = wxString_in_helper(obj1);
8562 if (arg2 == NULL) SWIG_fail;
8563 temp2 = true;
8564 }
8565 {
8566 PyThreadState* __tstate = wxPyBeginAllowThreads();
8567 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
8568
8569 wxPyEndAllowThreads(__tstate);
8570 if (PyErr_Occurred()) SWIG_fail;
8571 }
8572 {
8573 #if wxUSE_UNICODE
8574 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8575 #else
8576 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8577 #endif
8578 }
8579 {
8580 if (temp2)
8581 delete arg2;
8582 }
8583 return resultobj;
8584 fail:
8585 {
8586 if (temp2)
8587 delete arg2;
8588 }
8589 return NULL;
8590 }
8591
8592
8593 static PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *, PyObject *args, PyObject *kwargs) {
8594 PyObject *resultobj;
8595 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8596 wxString *arg2 = 0 ;
8597 wxString result;
8598 bool temp2 = false ;
8599 PyObject * obj0 = 0 ;
8600 PyObject * obj1 = 0 ;
8601 char *kwnames[] = {
8602 (char *) "self",(char *) "location", NULL
8603 };
8604
8605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) goto fail;
8606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8607 if (SWIG_arg_fail(1)) SWIG_fail;
8608 {
8609 arg2 = wxString_in_helper(obj1);
8610 if (arg2 == NULL) SWIG_fail;
8611 temp2 = true;
8612 }
8613 {
8614 PyThreadState* __tstate = wxPyBeginAllowThreads();
8615 result = (arg1)->GetAnchor((wxString const &)*arg2);
8616
8617 wxPyEndAllowThreads(__tstate);
8618 if (PyErr_Occurred()) SWIG_fail;
8619 }
8620 {
8621 #if wxUSE_UNICODE
8622 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8623 #else
8624 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8625 #endif
8626 }
8627 {
8628 if (temp2)
8629 delete arg2;
8630 }
8631 return resultobj;
8632 fail:
8633 {
8634 if (temp2)
8635 delete arg2;
8636 }
8637 return NULL;
8638 }
8639
8640
8641 static PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *, PyObject *args, PyObject *kwargs) {
8642 PyObject *resultobj;
8643 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8644 wxString *arg2 = 0 ;
8645 wxString result;
8646 bool temp2 = false ;
8647 PyObject * obj0 = 0 ;
8648 PyObject * obj1 = 0 ;
8649 char *kwnames[] = {
8650 (char *) "self",(char *) "location", NULL
8651 };
8652
8653 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) goto fail;
8654 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8655 if (SWIG_arg_fail(1)) SWIG_fail;
8656 {
8657 arg2 = wxString_in_helper(obj1);
8658 if (arg2 == NULL) SWIG_fail;
8659 temp2 = true;
8660 }
8661 {
8662 PyThreadState* __tstate = wxPyBeginAllowThreads();
8663 result = (arg1)->GetRightLocation((wxString const &)*arg2);
8664
8665 wxPyEndAllowThreads(__tstate);
8666 if (PyErr_Occurred()) SWIG_fail;
8667 }
8668 {
8669 #if wxUSE_UNICODE
8670 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8671 #else
8672 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8673 #endif
8674 }
8675 {
8676 if (temp2)
8677 delete arg2;
8678 }
8679 return resultobj;
8680 fail:
8681 {
8682 if (temp2)
8683 delete arg2;
8684 }
8685 return NULL;
8686 }
8687
8688
8689 static PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *, PyObject *args, PyObject *kwargs) {
8690 PyObject *resultobj;
8691 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
8692 wxString *arg2 = 0 ;
8693 wxString result;
8694 bool temp2 = false ;
8695 PyObject * obj0 = 0 ;
8696 PyObject * obj1 = 0 ;
8697 char *kwnames[] = {
8698 (char *) "self",(char *) "location", NULL
8699 };
8700
8701 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) goto fail;
8702 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
8703 if (SWIG_arg_fail(1)) SWIG_fail;
8704 {
8705 arg2 = wxString_in_helper(obj1);
8706 if (arg2 == NULL) SWIG_fail;
8707 temp2 = true;
8708 }
8709 {
8710 PyThreadState* __tstate = wxPyBeginAllowThreads();
8711 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
8712
8713 wxPyEndAllowThreads(__tstate);
8714 if (PyErr_Occurred()) SWIG_fail;
8715 }
8716 {
8717 #if wxUSE_UNICODE
8718 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8719 #else
8720 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8721 #endif
8722 }
8723 {
8724 if (temp2)
8725 delete arg2;
8726 }
8727 return resultobj;
8728 fail:
8729 {
8730 if (temp2)
8731 delete arg2;
8732 }
8733 return NULL;
8734 }
8735
8736
8737 static PyObject * FileSystemHandler_swigregister(PyObject *, PyObject *args) {
8738 PyObject *obj;
8739 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
8740 SWIG_TypeClientData(SWIGTYPE_p_wxPyFileSystemHandler, obj);
8741 Py_INCREF(obj);
8742 return Py_BuildValue((char *)"");
8743 }
8744 static PyObject *_wrap_new_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8745 PyObject *resultobj;
8746 wxFileSystem *result;
8747 char *kwnames[] = {
8748 NULL
8749 };
8750
8751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_FileSystem",kwnames)) goto fail;
8752 {
8753 PyThreadState* __tstate = wxPyBeginAllowThreads();
8754 result = (wxFileSystem *)new wxFileSystem();
8755
8756 wxPyEndAllowThreads(__tstate);
8757 if (PyErr_Occurred()) SWIG_fail;
8758 }
8759 {
8760 resultobj = wxPyMake_wxObject(result, 1);
8761 }
8762 return resultobj;
8763 fail:
8764 return NULL;
8765 }
8766
8767
8768 static PyObject *_wrap_delete_FileSystem(PyObject *, PyObject *args, PyObject *kwargs) {
8769 PyObject *resultobj;
8770 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8771 PyObject * obj0 = 0 ;
8772 char *kwnames[] = {
8773 (char *) "self", NULL
8774 };
8775
8776 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_FileSystem",kwnames,&obj0)) goto fail;
8777 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8778 if (SWIG_arg_fail(1)) SWIG_fail;
8779 {
8780 PyThreadState* __tstate = wxPyBeginAllowThreads();
8781 delete arg1;
8782
8783 wxPyEndAllowThreads(__tstate);
8784 if (PyErr_Occurred()) SWIG_fail;
8785 }
8786 Py_INCREF(Py_None); resultobj = Py_None;
8787 return resultobj;
8788 fail:
8789 return NULL;
8790 }
8791
8792
8793 static PyObject *_wrap_FileSystem_ChangePathTo(PyObject *, PyObject *args, PyObject *kwargs) {
8794 PyObject *resultobj;
8795 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8796 wxString *arg2 = 0 ;
8797 bool arg3 = (bool) false ;
8798 bool temp2 = false ;
8799 PyObject * obj0 = 0 ;
8800 PyObject * obj1 = 0 ;
8801 PyObject * obj2 = 0 ;
8802 char *kwnames[] = {
8803 (char *) "self",(char *) "location",(char *) "is_dir", NULL
8804 };
8805
8806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) goto fail;
8807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8808 if (SWIG_arg_fail(1)) SWIG_fail;
8809 {
8810 arg2 = wxString_in_helper(obj1);
8811 if (arg2 == NULL) SWIG_fail;
8812 temp2 = true;
8813 }
8814 if (obj2) {
8815 {
8816 arg3 = (bool)(SWIG_As_bool(obj2));
8817 if (SWIG_arg_fail(3)) SWIG_fail;
8818 }
8819 }
8820 {
8821 PyThreadState* __tstate = wxPyBeginAllowThreads();
8822 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
8823
8824 wxPyEndAllowThreads(__tstate);
8825 if (PyErr_Occurred()) SWIG_fail;
8826 }
8827 Py_INCREF(Py_None); resultobj = Py_None;
8828 {
8829 if (temp2)
8830 delete arg2;
8831 }
8832 return resultobj;
8833 fail:
8834 {
8835 if (temp2)
8836 delete arg2;
8837 }
8838 return NULL;
8839 }
8840
8841
8842 static PyObject *_wrap_FileSystem_GetPath(PyObject *, PyObject *args, PyObject *kwargs) {
8843 PyObject *resultobj;
8844 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8845 wxString result;
8846 PyObject * obj0 = 0 ;
8847 char *kwnames[] = {
8848 (char *) "self", NULL
8849 };
8850
8851 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_GetPath",kwnames,&obj0)) goto fail;
8852 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8853 if (SWIG_arg_fail(1)) SWIG_fail;
8854 {
8855 PyThreadState* __tstate = wxPyBeginAllowThreads();
8856 result = (arg1)->GetPath();
8857
8858 wxPyEndAllowThreads(__tstate);
8859 if (PyErr_Occurred()) SWIG_fail;
8860 }
8861 {
8862 #if wxUSE_UNICODE
8863 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8864 #else
8865 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8866 #endif
8867 }
8868 return resultobj;
8869 fail:
8870 return NULL;
8871 }
8872
8873
8874 static PyObject *_wrap_FileSystem_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
8875 PyObject *resultobj;
8876 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8877 wxString *arg2 = 0 ;
8878 wxFSFile *result;
8879 bool temp2 = false ;
8880 PyObject * obj0 = 0 ;
8881 PyObject * obj1 = 0 ;
8882 char *kwnames[] = {
8883 (char *) "self",(char *) "location", NULL
8884 };
8885
8886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) goto fail;
8887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8888 if (SWIG_arg_fail(1)) SWIG_fail;
8889 {
8890 arg2 = wxString_in_helper(obj1);
8891 if (arg2 == NULL) SWIG_fail;
8892 temp2 = true;
8893 }
8894 {
8895 PyThreadState* __tstate = wxPyBeginAllowThreads();
8896 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
8897
8898 wxPyEndAllowThreads(__tstate);
8899 if (PyErr_Occurred()) SWIG_fail;
8900 }
8901 {
8902 resultobj = wxPyMake_wxObject(result, 1);
8903 }
8904 {
8905 if (temp2)
8906 delete arg2;
8907 }
8908 return resultobj;
8909 fail:
8910 {
8911 if (temp2)
8912 delete arg2;
8913 }
8914 return NULL;
8915 }
8916
8917
8918 static PyObject *_wrap_FileSystem_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
8919 PyObject *resultobj;
8920 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8921 wxString *arg2 = 0 ;
8922 int arg3 = (int) 0 ;
8923 wxString result;
8924 bool temp2 = false ;
8925 PyObject * obj0 = 0 ;
8926 PyObject * obj1 = 0 ;
8927 PyObject * obj2 = 0 ;
8928 char *kwnames[] = {
8929 (char *) "self",(char *) "spec",(char *) "flags", NULL
8930 };
8931
8932 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
8933 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8934 if (SWIG_arg_fail(1)) SWIG_fail;
8935 {
8936 arg2 = wxString_in_helper(obj1);
8937 if (arg2 == NULL) SWIG_fail;
8938 temp2 = true;
8939 }
8940 if (obj2) {
8941 {
8942 arg3 = (int)(SWIG_As_int(obj2));
8943 if (SWIG_arg_fail(3)) SWIG_fail;
8944 }
8945 }
8946 {
8947 PyThreadState* __tstate = wxPyBeginAllowThreads();
8948 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
8949
8950 wxPyEndAllowThreads(__tstate);
8951 if (PyErr_Occurred()) SWIG_fail;
8952 }
8953 {
8954 #if wxUSE_UNICODE
8955 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8956 #else
8957 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8958 #endif
8959 }
8960 {
8961 if (temp2)
8962 delete arg2;
8963 }
8964 return resultobj;
8965 fail:
8966 {
8967 if (temp2)
8968 delete arg2;
8969 }
8970 return NULL;
8971 }
8972
8973
8974 static PyObject *_wrap_FileSystem_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
8975 PyObject *resultobj;
8976 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
8977 wxString result;
8978 PyObject * obj0 = 0 ;
8979 char *kwnames[] = {
8980 (char *) "self", NULL
8981 };
8982
8983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FindNext",kwnames,&obj0)) goto fail;
8984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
8985 if (SWIG_arg_fail(1)) SWIG_fail;
8986 {
8987 PyThreadState* __tstate = wxPyBeginAllowThreads();
8988 result = (arg1)->FindNext();
8989
8990 wxPyEndAllowThreads(__tstate);
8991 if (PyErr_Occurred()) SWIG_fail;
8992 }
8993 {
8994 #if wxUSE_UNICODE
8995 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
8996 #else
8997 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
8998 #endif
8999 }
9000 return resultobj;
9001 fail:
9002 return NULL;
9003 }
9004
9005
9006 static PyObject *_wrap_FileSystem_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9007 PyObject *resultobj;
9008 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9009 PyObject * obj0 = 0 ;
9010 char *kwnames[] = {
9011 (char *) "handler", NULL
9012 };
9013
9014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) goto fail;
9015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_EXCEPTION | 0);
9016 if (SWIG_arg_fail(1)) SWIG_fail;
9017 {
9018 PyThreadState* __tstate = wxPyBeginAllowThreads();
9019 wxFileSystem::AddHandler(arg1);
9020
9021 wxPyEndAllowThreads(__tstate);
9022 if (PyErr_Occurred()) SWIG_fail;
9023 }
9024 Py_INCREF(Py_None); resultobj = Py_None;
9025 return resultobj;
9026 fail:
9027 return NULL;
9028 }
9029
9030
9031 static PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *, PyObject *args, PyObject *kwargs) {
9032 PyObject *resultobj;
9033 char *kwnames[] = {
9034 NULL
9035 };
9036
9037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":FileSystem_CleanUpHandlers",kwnames)) goto fail;
9038 {
9039 PyThreadState* __tstate = wxPyBeginAllowThreads();
9040 wxFileSystem::CleanUpHandlers();
9041
9042 wxPyEndAllowThreads(__tstate);
9043 if (PyErr_Occurred()) SWIG_fail;
9044 }
9045 Py_INCREF(Py_None); resultobj = Py_None;
9046 return resultobj;
9047 fail:
9048 return NULL;
9049 }
9050
9051
9052 static PyObject *_wrap_FileSystem_FileNameToURL(PyObject *, PyObject *args, PyObject *kwargs) {
9053 PyObject *resultobj;
9054 wxString *arg1 = 0 ;
9055 wxString result;
9056 bool temp1 = false ;
9057 PyObject * obj0 = 0 ;
9058 char *kwnames[] = {
9059 (char *) "filename", NULL
9060 };
9061
9062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) goto fail;
9063 {
9064 arg1 = wxString_in_helper(obj0);
9065 if (arg1 == NULL) SWIG_fail;
9066 temp1 = true;
9067 }
9068 {
9069 PyThreadState* __tstate = wxPyBeginAllowThreads();
9070 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
9071
9072 wxPyEndAllowThreads(__tstate);
9073 if (PyErr_Occurred()) SWIG_fail;
9074 }
9075 {
9076 #if wxUSE_UNICODE
9077 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9078 #else
9079 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9080 #endif
9081 }
9082 {
9083 if (temp1)
9084 delete arg1;
9085 }
9086 return resultobj;
9087 fail:
9088 {
9089 if (temp1)
9090 delete arg1;
9091 }
9092 return NULL;
9093 }
9094
9095
9096 static PyObject *_wrap_FileSystem_URLToFileName(PyObject *, PyObject *args, PyObject *kwargs) {
9097 PyObject *resultobj;
9098 wxString *arg1 = 0 ;
9099 wxString result;
9100 bool temp1 = false ;
9101 PyObject * obj0 = 0 ;
9102 char *kwnames[] = {
9103 (char *) "url", NULL
9104 };
9105
9106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) goto fail;
9107 {
9108 arg1 = wxString_in_helper(obj0);
9109 if (arg1 == NULL) SWIG_fail;
9110 temp1 = true;
9111 }
9112 {
9113 PyThreadState* __tstate = wxPyBeginAllowThreads();
9114 result = FileSystem_URLToFileName((wxString const &)*arg1);
9115
9116 wxPyEndAllowThreads(__tstate);
9117 if (PyErr_Occurred()) SWIG_fail;
9118 }
9119 {
9120 #if wxUSE_UNICODE
9121 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9122 #else
9123 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9124 #endif
9125 }
9126 {
9127 if (temp1)
9128 delete arg1;
9129 }
9130 return resultobj;
9131 fail:
9132 {
9133 if (temp1)
9134 delete arg1;
9135 }
9136 return NULL;
9137 }
9138
9139
9140 static PyObject * FileSystem_swigregister(PyObject *, PyObject *args) {
9141 PyObject *obj;
9142 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9143 SWIG_TypeClientData(SWIGTYPE_p_wxFileSystem, obj);
9144 Py_INCREF(obj);
9145 return Py_BuildValue((char *)"");
9146 }
9147 static PyObject *_wrap_new_InternetFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9148 PyObject *resultobj;
9149 wxInternetFSHandler *result;
9150 char *kwnames[] = {
9151 NULL
9152 };
9153
9154 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_InternetFSHandler",kwnames)) goto fail;
9155 {
9156 PyThreadState* __tstate = wxPyBeginAllowThreads();
9157 result = (wxInternetFSHandler *)new wxInternetFSHandler();
9158
9159 wxPyEndAllowThreads(__tstate);
9160 if (PyErr_Occurred()) SWIG_fail;
9161 }
9162 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInternetFSHandler, 1);
9163 return resultobj;
9164 fail:
9165 return NULL;
9166 }
9167
9168
9169 static PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9170 PyObject *resultobj;
9171 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9172 wxString *arg2 = 0 ;
9173 bool result;
9174 bool temp2 = false ;
9175 PyObject * obj0 = 0 ;
9176 PyObject * obj1 = 0 ;
9177 char *kwnames[] = {
9178 (char *) "self",(char *) "location", NULL
9179 };
9180
9181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9183 if (SWIG_arg_fail(1)) SWIG_fail;
9184 {
9185 arg2 = wxString_in_helper(obj1);
9186 if (arg2 == NULL) SWIG_fail;
9187 temp2 = true;
9188 }
9189 {
9190 PyThreadState* __tstate = wxPyBeginAllowThreads();
9191 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9192
9193 wxPyEndAllowThreads(__tstate);
9194 if (PyErr_Occurred()) SWIG_fail;
9195 }
9196 {
9197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9198 }
9199 {
9200 if (temp2)
9201 delete arg2;
9202 }
9203 return resultobj;
9204 fail:
9205 {
9206 if (temp2)
9207 delete arg2;
9208 }
9209 return NULL;
9210 }
9211
9212
9213 static PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9214 PyObject *resultobj;
9215 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
9216 wxFileSystem *arg2 = 0 ;
9217 wxString *arg3 = 0 ;
9218 wxFSFile *result;
9219 bool temp3 = false ;
9220 PyObject * obj0 = 0 ;
9221 PyObject * obj1 = 0 ;
9222 PyObject * obj2 = 0 ;
9223 char *kwnames[] = {
9224 (char *) "self",(char *) "fs",(char *) "location", NULL
9225 };
9226
9227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_EXCEPTION | 0);
9229 if (SWIG_arg_fail(1)) SWIG_fail;
9230 {
9231 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9232 if (SWIG_arg_fail(2)) SWIG_fail;
9233 if (arg2 == NULL) {
9234 SWIG_null_ref("wxFileSystem");
9235 }
9236 if (SWIG_arg_fail(2)) SWIG_fail;
9237 }
9238 {
9239 arg3 = wxString_in_helper(obj2);
9240 if (arg3 == NULL) SWIG_fail;
9241 temp3 = true;
9242 }
9243 {
9244 PyThreadState* __tstate = wxPyBeginAllowThreads();
9245 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9246
9247 wxPyEndAllowThreads(__tstate);
9248 if (PyErr_Occurred()) SWIG_fail;
9249 }
9250 {
9251 resultobj = wxPyMake_wxObject(result, 1);
9252 }
9253 {
9254 if (temp3)
9255 delete arg3;
9256 }
9257 return resultobj;
9258 fail:
9259 {
9260 if (temp3)
9261 delete arg3;
9262 }
9263 return NULL;
9264 }
9265
9266
9267 static PyObject * InternetFSHandler_swigregister(PyObject *, PyObject *args) {
9268 PyObject *obj;
9269 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9270 SWIG_TypeClientData(SWIGTYPE_p_wxInternetFSHandler, obj);
9271 Py_INCREF(obj);
9272 return Py_BuildValue((char *)"");
9273 }
9274 static PyObject *_wrap_new_ZipFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9275 PyObject *resultobj;
9276 wxZipFSHandler *result;
9277 char *kwnames[] = {
9278 NULL
9279 };
9280
9281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ZipFSHandler",kwnames)) goto fail;
9282 {
9283 PyThreadState* __tstate = wxPyBeginAllowThreads();
9284 result = (wxZipFSHandler *)new wxZipFSHandler();
9285
9286 wxPyEndAllowThreads(__tstate);
9287 if (PyErr_Occurred()) SWIG_fail;
9288 }
9289 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxZipFSHandler, 1);
9290 return resultobj;
9291 fail:
9292 return NULL;
9293 }
9294
9295
9296 static PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9297 PyObject *resultobj;
9298 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9299 wxString *arg2 = 0 ;
9300 bool result;
9301 bool temp2 = false ;
9302 PyObject * obj0 = 0 ;
9303 PyObject * obj1 = 0 ;
9304 char *kwnames[] = {
9305 (char *) "self",(char *) "location", NULL
9306 };
9307
9308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9310 if (SWIG_arg_fail(1)) SWIG_fail;
9311 {
9312 arg2 = wxString_in_helper(obj1);
9313 if (arg2 == NULL) SWIG_fail;
9314 temp2 = true;
9315 }
9316 {
9317 PyThreadState* __tstate = wxPyBeginAllowThreads();
9318 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9319
9320 wxPyEndAllowThreads(__tstate);
9321 if (PyErr_Occurred()) SWIG_fail;
9322 }
9323 {
9324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9325 }
9326 {
9327 if (temp2)
9328 delete arg2;
9329 }
9330 return resultobj;
9331 fail:
9332 {
9333 if (temp2)
9334 delete arg2;
9335 }
9336 return NULL;
9337 }
9338
9339
9340 static PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9341 PyObject *resultobj;
9342 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9343 wxFileSystem *arg2 = 0 ;
9344 wxString *arg3 = 0 ;
9345 wxFSFile *result;
9346 bool temp3 = false ;
9347 PyObject * obj0 = 0 ;
9348 PyObject * obj1 = 0 ;
9349 PyObject * obj2 = 0 ;
9350 char *kwnames[] = {
9351 (char *) "self",(char *) "fs",(char *) "location", NULL
9352 };
9353
9354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9356 if (SWIG_arg_fail(1)) SWIG_fail;
9357 {
9358 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9359 if (SWIG_arg_fail(2)) SWIG_fail;
9360 if (arg2 == NULL) {
9361 SWIG_null_ref("wxFileSystem");
9362 }
9363 if (SWIG_arg_fail(2)) SWIG_fail;
9364 }
9365 {
9366 arg3 = wxString_in_helper(obj2);
9367 if (arg3 == NULL) SWIG_fail;
9368 temp3 = true;
9369 }
9370 {
9371 PyThreadState* __tstate = wxPyBeginAllowThreads();
9372 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9373
9374 wxPyEndAllowThreads(__tstate);
9375 if (PyErr_Occurred()) SWIG_fail;
9376 }
9377 {
9378 resultobj = wxPyMake_wxObject(result, 1);
9379 }
9380 {
9381 if (temp3)
9382 delete arg3;
9383 }
9384 return resultobj;
9385 fail:
9386 {
9387 if (temp3)
9388 delete arg3;
9389 }
9390 return NULL;
9391 }
9392
9393
9394 static PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9395 PyObject *resultobj;
9396 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9397 wxString *arg2 = 0 ;
9398 int arg3 = (int) 0 ;
9399 wxString result;
9400 bool temp2 = false ;
9401 PyObject * obj0 = 0 ;
9402 PyObject * obj1 = 0 ;
9403 PyObject * obj2 = 0 ;
9404 char *kwnames[] = {
9405 (char *) "self",(char *) "spec",(char *) "flags", NULL
9406 };
9407
9408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9410 if (SWIG_arg_fail(1)) SWIG_fail;
9411 {
9412 arg2 = wxString_in_helper(obj1);
9413 if (arg2 == NULL) SWIG_fail;
9414 temp2 = true;
9415 }
9416 if (obj2) {
9417 {
9418 arg3 = (int)(SWIG_As_int(obj2));
9419 if (SWIG_arg_fail(3)) SWIG_fail;
9420 }
9421 }
9422 {
9423 PyThreadState* __tstate = wxPyBeginAllowThreads();
9424 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9425
9426 wxPyEndAllowThreads(__tstate);
9427 if (PyErr_Occurred()) SWIG_fail;
9428 }
9429 {
9430 #if wxUSE_UNICODE
9431 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9432 #else
9433 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9434 #endif
9435 }
9436 {
9437 if (temp2)
9438 delete arg2;
9439 }
9440 return resultobj;
9441 fail:
9442 {
9443 if (temp2)
9444 delete arg2;
9445 }
9446 return NULL;
9447 }
9448
9449
9450 static PyObject *_wrap_ZipFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9451 PyObject *resultobj;
9452 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
9453 wxString result;
9454 PyObject * obj0 = 0 ;
9455 char *kwnames[] = {
9456 (char *) "self", NULL
9457 };
9458
9459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ZipFSHandler_FindNext",kwnames,&obj0)) goto fail;
9460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_EXCEPTION | 0);
9461 if (SWIG_arg_fail(1)) SWIG_fail;
9462 {
9463 PyThreadState* __tstate = wxPyBeginAllowThreads();
9464 result = (arg1)->FindNext();
9465
9466 wxPyEndAllowThreads(__tstate);
9467 if (PyErr_Occurred()) SWIG_fail;
9468 }
9469 {
9470 #if wxUSE_UNICODE
9471 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9472 #else
9473 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9474 #endif
9475 }
9476 return resultobj;
9477 fail:
9478 return NULL;
9479 }
9480
9481
9482 static PyObject * ZipFSHandler_swigregister(PyObject *, PyObject *args) {
9483 PyObject *obj;
9484 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9485 SWIG_TypeClientData(SWIGTYPE_p_wxZipFSHandler, obj);
9486 Py_INCREF(obj);
9487 return Py_BuildValue((char *)"");
9488 }
9489 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *, PyObject *args, PyObject *kwargs) {
9490 PyObject *resultobj;
9491 wxString *arg1 = 0 ;
9492 wxImage *arg2 = 0 ;
9493 long arg3 ;
9494 bool temp1 = false ;
9495 PyObject * obj0 = 0 ;
9496 PyObject * obj1 = 0 ;
9497 PyObject * obj2 = 0 ;
9498 char *kwnames[] = {
9499 (char *) "filename",(char *) "image",(char *) "type", NULL
9500 };
9501
9502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
9503 {
9504 arg1 = wxString_in_helper(obj0);
9505 if (arg1 == NULL) SWIG_fail;
9506 temp1 = true;
9507 }
9508 {
9509 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
9510 if (SWIG_arg_fail(2)) SWIG_fail;
9511 if (arg2 == NULL) {
9512 SWIG_null_ref("wxImage");
9513 }
9514 if (SWIG_arg_fail(2)) SWIG_fail;
9515 }
9516 {
9517 arg3 = (long)(SWIG_As_long(obj2));
9518 if (SWIG_arg_fail(3)) SWIG_fail;
9519 }
9520 {
9521 PyThreadState* __tstate = wxPyBeginAllowThreads();
9522 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
9523
9524 wxPyEndAllowThreads(__tstate);
9525 if (PyErr_Occurred()) SWIG_fail;
9526 }
9527 Py_INCREF(Py_None); resultobj = Py_None;
9528 {
9529 if (temp1)
9530 delete arg1;
9531 }
9532 return resultobj;
9533 fail:
9534 {
9535 if (temp1)
9536 delete arg1;
9537 }
9538 return NULL;
9539 }
9540
9541
9542 static PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
9543 PyObject *resultobj;
9544 wxString *arg1 = 0 ;
9545 wxBitmap *arg2 = 0 ;
9546 long arg3 ;
9547 bool temp1 = false ;
9548 PyObject * obj0 = 0 ;
9549 PyObject * obj1 = 0 ;
9550 PyObject * obj2 = 0 ;
9551 char *kwnames[] = {
9552 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
9553 };
9554
9555 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) goto fail;
9556 {
9557 arg1 = wxString_in_helper(obj0);
9558 if (arg1 == NULL) SWIG_fail;
9559 temp1 = true;
9560 }
9561 {
9562 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
9563 if (SWIG_arg_fail(2)) SWIG_fail;
9564 if (arg2 == NULL) {
9565 SWIG_null_ref("wxBitmap");
9566 }
9567 if (SWIG_arg_fail(2)) SWIG_fail;
9568 }
9569 {
9570 arg3 = (long)(SWIG_As_long(obj2));
9571 if (SWIG_arg_fail(3)) SWIG_fail;
9572 }
9573 {
9574 PyThreadState* __tstate = wxPyBeginAllowThreads();
9575 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
9576
9577 wxPyEndAllowThreads(__tstate);
9578 if (PyErr_Occurred()) SWIG_fail;
9579 }
9580 Py_INCREF(Py_None); resultobj = Py_None;
9581 {
9582 if (temp1)
9583 delete arg1;
9584 }
9585 return resultobj;
9586 fail:
9587 {
9588 if (temp1)
9589 delete arg1;
9590 }
9591 return NULL;
9592 }
9593
9594
9595 static PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *, PyObject *args, PyObject *kwargs) {
9596 PyObject *resultobj;
9597 wxString *arg1 = 0 ;
9598 PyObject *arg2 = (PyObject *) 0 ;
9599 bool temp1 = false ;
9600 PyObject * obj0 = 0 ;
9601 PyObject * obj1 = 0 ;
9602 char *kwnames[] = {
9603 (char *) "filename",(char *) "data", NULL
9604 };
9605
9606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) goto fail;
9607 {
9608 arg1 = wxString_in_helper(obj0);
9609 if (arg1 == NULL) SWIG_fail;
9610 temp1 = true;
9611 }
9612 arg2 = obj1;
9613 {
9614 PyThreadState* __tstate = wxPyBeginAllowThreads();
9615 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
9616
9617 wxPyEndAllowThreads(__tstate);
9618 if (PyErr_Occurred()) SWIG_fail;
9619 }
9620 Py_INCREF(Py_None); resultobj = Py_None;
9621 {
9622 if (temp1)
9623 delete arg1;
9624 }
9625 return resultobj;
9626 fail:
9627 {
9628 if (temp1)
9629 delete arg1;
9630 }
9631 return NULL;
9632 }
9633
9634
9635 static PyObject *_wrap_new_MemoryFSHandler(PyObject *, PyObject *args, PyObject *kwargs) {
9636 PyObject *resultobj;
9637 wxMemoryFSHandler *result;
9638 char *kwnames[] = {
9639 NULL
9640 };
9641
9642 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_MemoryFSHandler",kwnames)) goto fail;
9643 {
9644 PyThreadState* __tstate = wxPyBeginAllowThreads();
9645 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
9646
9647 wxPyEndAllowThreads(__tstate);
9648 if (PyErr_Occurred()) SWIG_fail;
9649 }
9650 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMemoryFSHandler, 1);
9651 return resultobj;
9652 fail:
9653 return NULL;
9654 }
9655
9656
9657 static PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *, PyObject *args, PyObject *kwargs) {
9658 PyObject *resultobj;
9659 wxString *arg1 = 0 ;
9660 bool temp1 = false ;
9661 PyObject * obj0 = 0 ;
9662 char *kwnames[] = {
9663 (char *) "filename", NULL
9664 };
9665
9666 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) goto fail;
9667 {
9668 arg1 = wxString_in_helper(obj0);
9669 if (arg1 == NULL) SWIG_fail;
9670 temp1 = true;
9671 }
9672 {
9673 PyThreadState* __tstate = wxPyBeginAllowThreads();
9674 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
9675
9676 wxPyEndAllowThreads(__tstate);
9677 if (PyErr_Occurred()) SWIG_fail;
9678 }
9679 Py_INCREF(Py_None); resultobj = Py_None;
9680 {
9681 if (temp1)
9682 delete arg1;
9683 }
9684 return resultobj;
9685 fail:
9686 {
9687 if (temp1)
9688 delete arg1;
9689 }
9690 return NULL;
9691 }
9692
9693
9694 static PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *, PyObject *args, PyObject *kwargs) {
9695 PyObject *resultobj;
9696 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9697 wxString *arg2 = 0 ;
9698 bool result;
9699 bool temp2 = false ;
9700 PyObject * obj0 = 0 ;
9701 PyObject * obj1 = 0 ;
9702 char *kwnames[] = {
9703 (char *) "self",(char *) "location", NULL
9704 };
9705
9706 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) goto fail;
9707 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9708 if (SWIG_arg_fail(1)) SWIG_fail;
9709 {
9710 arg2 = wxString_in_helper(obj1);
9711 if (arg2 == NULL) SWIG_fail;
9712 temp2 = true;
9713 }
9714 {
9715 PyThreadState* __tstate = wxPyBeginAllowThreads();
9716 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
9717
9718 wxPyEndAllowThreads(__tstate);
9719 if (PyErr_Occurred()) SWIG_fail;
9720 }
9721 {
9722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9723 }
9724 {
9725 if (temp2)
9726 delete arg2;
9727 }
9728 return resultobj;
9729 fail:
9730 {
9731 if (temp2)
9732 delete arg2;
9733 }
9734 return NULL;
9735 }
9736
9737
9738 static PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *, PyObject *args, PyObject *kwargs) {
9739 PyObject *resultobj;
9740 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9741 wxFileSystem *arg2 = 0 ;
9742 wxString *arg3 = 0 ;
9743 wxFSFile *result;
9744 bool temp3 = false ;
9745 PyObject * obj0 = 0 ;
9746 PyObject * obj1 = 0 ;
9747 PyObject * obj2 = 0 ;
9748 char *kwnames[] = {
9749 (char *) "self",(char *) "fs",(char *) "location", NULL
9750 };
9751
9752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
9753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9754 if (SWIG_arg_fail(1)) SWIG_fail;
9755 {
9756 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFileSystem, SWIG_POINTER_EXCEPTION | 0);
9757 if (SWIG_arg_fail(2)) SWIG_fail;
9758 if (arg2 == NULL) {
9759 SWIG_null_ref("wxFileSystem");
9760 }
9761 if (SWIG_arg_fail(2)) SWIG_fail;
9762 }
9763 {
9764 arg3 = wxString_in_helper(obj2);
9765 if (arg3 == NULL) SWIG_fail;
9766 temp3 = true;
9767 }
9768 {
9769 PyThreadState* __tstate = wxPyBeginAllowThreads();
9770 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
9771
9772 wxPyEndAllowThreads(__tstate);
9773 if (PyErr_Occurred()) SWIG_fail;
9774 }
9775 {
9776 resultobj = wxPyMake_wxObject(result, 1);
9777 }
9778 {
9779 if (temp3)
9780 delete arg3;
9781 }
9782 return resultobj;
9783 fail:
9784 {
9785 if (temp3)
9786 delete arg3;
9787 }
9788 return NULL;
9789 }
9790
9791
9792 static PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *, PyObject *args, PyObject *kwargs) {
9793 PyObject *resultobj;
9794 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9795 wxString *arg2 = 0 ;
9796 int arg3 = (int) 0 ;
9797 wxString result;
9798 bool temp2 = false ;
9799 PyObject * obj0 = 0 ;
9800 PyObject * obj1 = 0 ;
9801 PyObject * obj2 = 0 ;
9802 char *kwnames[] = {
9803 (char *) "self",(char *) "spec",(char *) "flags", NULL
9804 };
9805
9806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) goto fail;
9807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9808 if (SWIG_arg_fail(1)) SWIG_fail;
9809 {
9810 arg2 = wxString_in_helper(obj1);
9811 if (arg2 == NULL) SWIG_fail;
9812 temp2 = true;
9813 }
9814 if (obj2) {
9815 {
9816 arg3 = (int)(SWIG_As_int(obj2));
9817 if (SWIG_arg_fail(3)) SWIG_fail;
9818 }
9819 }
9820 {
9821 PyThreadState* __tstate = wxPyBeginAllowThreads();
9822 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
9823
9824 wxPyEndAllowThreads(__tstate);
9825 if (PyErr_Occurred()) SWIG_fail;
9826 }
9827 {
9828 #if wxUSE_UNICODE
9829 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9830 #else
9831 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9832 #endif
9833 }
9834 {
9835 if (temp2)
9836 delete arg2;
9837 }
9838 return resultobj;
9839 fail:
9840 {
9841 if (temp2)
9842 delete arg2;
9843 }
9844 return NULL;
9845 }
9846
9847
9848 static PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *, PyObject *args, PyObject *kwargs) {
9849 PyObject *resultobj;
9850 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
9851 wxString result;
9852 PyObject * obj0 = 0 ;
9853 char *kwnames[] = {
9854 (char *) "self", NULL
9855 };
9856
9857 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_FindNext",kwnames,&obj0)) goto fail;
9858 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_EXCEPTION | 0);
9859 if (SWIG_arg_fail(1)) SWIG_fail;
9860 {
9861 PyThreadState* __tstate = wxPyBeginAllowThreads();
9862 result = (arg1)->FindNext();
9863
9864 wxPyEndAllowThreads(__tstate);
9865 if (PyErr_Occurred()) SWIG_fail;
9866 }
9867 {
9868 #if wxUSE_UNICODE
9869 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9870 #else
9871 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9872 #endif
9873 }
9874 return resultobj;
9875 fail:
9876 return NULL;
9877 }
9878
9879
9880 static PyObject * MemoryFSHandler_swigregister(PyObject *, PyObject *args) {
9881 PyObject *obj;
9882 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
9883 SWIG_TypeClientData(SWIGTYPE_p_wxMemoryFSHandler, obj);
9884 Py_INCREF(obj);
9885 return Py_BuildValue((char *)"");
9886 }
9887 static PyObject *_wrap_ImageHandler_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
9888 PyObject *resultobj;
9889 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9890 wxString result;
9891 PyObject * obj0 = 0 ;
9892 char *kwnames[] = {
9893 (char *) "self", NULL
9894 };
9895
9896 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetName",kwnames,&obj0)) goto fail;
9897 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9898 if (SWIG_arg_fail(1)) SWIG_fail;
9899 {
9900 PyThreadState* __tstate = wxPyBeginAllowThreads();
9901 result = (arg1)->GetName();
9902
9903 wxPyEndAllowThreads(__tstate);
9904 if (PyErr_Occurred()) SWIG_fail;
9905 }
9906 {
9907 #if wxUSE_UNICODE
9908 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9909 #else
9910 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9911 #endif
9912 }
9913 return resultobj;
9914 fail:
9915 return NULL;
9916 }
9917
9918
9919 static PyObject *_wrap_ImageHandler_GetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
9920 PyObject *resultobj;
9921 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9922 wxString result;
9923 PyObject * obj0 = 0 ;
9924 char *kwnames[] = {
9925 (char *) "self", NULL
9926 };
9927
9928 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetExtension",kwnames,&obj0)) goto fail;
9929 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9930 if (SWIG_arg_fail(1)) SWIG_fail;
9931 {
9932 PyThreadState* __tstate = wxPyBeginAllowThreads();
9933 result = (arg1)->GetExtension();
9934
9935 wxPyEndAllowThreads(__tstate);
9936 if (PyErr_Occurred()) SWIG_fail;
9937 }
9938 {
9939 #if wxUSE_UNICODE
9940 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
9941 #else
9942 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
9943 #endif
9944 }
9945 return resultobj;
9946 fail:
9947 return NULL;
9948 }
9949
9950
9951 static PyObject *_wrap_ImageHandler_GetType(PyObject *, PyObject *args, PyObject *kwargs) {
9952 PyObject *resultobj;
9953 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9954 long result;
9955 PyObject * obj0 = 0 ;
9956 char *kwnames[] = {
9957 (char *) "self", NULL
9958 };
9959
9960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetType",kwnames,&obj0)) goto fail;
9961 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9962 if (SWIG_arg_fail(1)) SWIG_fail;
9963 {
9964 PyThreadState* __tstate = wxPyBeginAllowThreads();
9965 result = (long)(arg1)->GetType();
9966
9967 wxPyEndAllowThreads(__tstate);
9968 if (PyErr_Occurred()) SWIG_fail;
9969 }
9970 {
9971 resultobj = SWIG_From_long((long)(result));
9972 }
9973 return resultobj;
9974 fail:
9975 return NULL;
9976 }
9977
9978
9979 static PyObject *_wrap_ImageHandler_GetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
9980 PyObject *resultobj;
9981 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
9982 wxString result;
9983 PyObject * obj0 = 0 ;
9984 char *kwnames[] = {
9985 (char *) "self", NULL
9986 };
9987
9988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ImageHandler_GetMimeType",kwnames,&obj0)) goto fail;
9989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
9990 if (SWIG_arg_fail(1)) SWIG_fail;
9991 {
9992 PyThreadState* __tstate = wxPyBeginAllowThreads();
9993 result = (arg1)->GetMimeType();
9994
9995 wxPyEndAllowThreads(__tstate);
9996 if (PyErr_Occurred()) SWIG_fail;
9997 }
9998 {
9999 #if wxUSE_UNICODE
10000 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10001 #else
10002 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10003 #endif
10004 }
10005 return resultobj;
10006 fail:
10007 return NULL;
10008 }
10009
10010
10011 static PyObject *_wrap_ImageHandler_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
10012 PyObject *resultobj;
10013 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10014 wxString *arg2 = 0 ;
10015 bool result;
10016 bool temp2 = false ;
10017 PyObject * obj0 = 0 ;
10018 PyObject * obj1 = 0 ;
10019 char *kwnames[] = {
10020 (char *) "self",(char *) "name", NULL
10021 };
10022
10023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) goto fail;
10024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10025 if (SWIG_arg_fail(1)) SWIG_fail;
10026 {
10027 arg2 = wxString_in_helper(obj1);
10028 if (arg2 == NULL) SWIG_fail;
10029 temp2 = true;
10030 }
10031 {
10032 PyThreadState* __tstate = wxPyBeginAllowThreads();
10033 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
10034
10035 wxPyEndAllowThreads(__tstate);
10036 if (PyErr_Occurred()) SWIG_fail;
10037 }
10038 {
10039 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10040 }
10041 {
10042 if (temp2)
10043 delete arg2;
10044 }
10045 return resultobj;
10046 fail:
10047 {
10048 if (temp2)
10049 delete arg2;
10050 }
10051 return NULL;
10052 }
10053
10054
10055 static PyObject *_wrap_ImageHandler_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
10056 PyObject *resultobj;
10057 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10058 wxString *arg2 = 0 ;
10059 bool temp2 = false ;
10060 PyObject * obj0 = 0 ;
10061 PyObject * obj1 = 0 ;
10062 char *kwnames[] = {
10063 (char *) "self",(char *) "name", NULL
10064 };
10065
10066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) goto fail;
10067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10068 if (SWIG_arg_fail(1)) SWIG_fail;
10069 {
10070 arg2 = wxString_in_helper(obj1);
10071 if (arg2 == NULL) SWIG_fail;
10072 temp2 = true;
10073 }
10074 {
10075 PyThreadState* __tstate = wxPyBeginAllowThreads();
10076 (arg1)->SetName((wxString const &)*arg2);
10077
10078 wxPyEndAllowThreads(__tstate);
10079 if (PyErr_Occurred()) SWIG_fail;
10080 }
10081 Py_INCREF(Py_None); resultobj = Py_None;
10082 {
10083 if (temp2)
10084 delete arg2;
10085 }
10086 return resultobj;
10087 fail:
10088 {
10089 if (temp2)
10090 delete arg2;
10091 }
10092 return NULL;
10093 }
10094
10095
10096 static PyObject *_wrap_ImageHandler_SetExtension(PyObject *, PyObject *args, PyObject *kwargs) {
10097 PyObject *resultobj;
10098 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10099 wxString *arg2 = 0 ;
10100 bool temp2 = false ;
10101 PyObject * obj0 = 0 ;
10102 PyObject * obj1 = 0 ;
10103 char *kwnames[] = {
10104 (char *) "self",(char *) "extension", NULL
10105 };
10106
10107 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) goto fail;
10108 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10109 if (SWIG_arg_fail(1)) SWIG_fail;
10110 {
10111 arg2 = wxString_in_helper(obj1);
10112 if (arg2 == NULL) SWIG_fail;
10113 temp2 = true;
10114 }
10115 {
10116 PyThreadState* __tstate = wxPyBeginAllowThreads();
10117 (arg1)->SetExtension((wxString const &)*arg2);
10118
10119 wxPyEndAllowThreads(__tstate);
10120 if (PyErr_Occurred()) SWIG_fail;
10121 }
10122 Py_INCREF(Py_None); resultobj = Py_None;
10123 {
10124 if (temp2)
10125 delete arg2;
10126 }
10127 return resultobj;
10128 fail:
10129 {
10130 if (temp2)
10131 delete arg2;
10132 }
10133 return NULL;
10134 }
10135
10136
10137 static PyObject *_wrap_ImageHandler_SetType(PyObject *, PyObject *args, PyObject *kwargs) {
10138 PyObject *resultobj;
10139 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10140 long arg2 ;
10141 PyObject * obj0 = 0 ;
10142 PyObject * obj1 = 0 ;
10143 char *kwnames[] = {
10144 (char *) "self",(char *) "type", NULL
10145 };
10146
10147 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) goto fail;
10148 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10149 if (SWIG_arg_fail(1)) SWIG_fail;
10150 {
10151 arg2 = (long)(SWIG_As_long(obj1));
10152 if (SWIG_arg_fail(2)) SWIG_fail;
10153 }
10154 {
10155 PyThreadState* __tstate = wxPyBeginAllowThreads();
10156 (arg1)->SetType(arg2);
10157
10158 wxPyEndAllowThreads(__tstate);
10159 if (PyErr_Occurred()) SWIG_fail;
10160 }
10161 Py_INCREF(Py_None); resultobj = Py_None;
10162 return resultobj;
10163 fail:
10164 return NULL;
10165 }
10166
10167
10168 static PyObject *_wrap_ImageHandler_SetMimeType(PyObject *, PyObject *args, PyObject *kwargs) {
10169 PyObject *resultobj;
10170 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
10171 wxString *arg2 = 0 ;
10172 bool temp2 = false ;
10173 PyObject * obj0 = 0 ;
10174 PyObject * obj1 = 0 ;
10175 char *kwnames[] = {
10176 (char *) "self",(char *) "mimetype", NULL
10177 };
10178
10179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) goto fail;
10180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
10181 if (SWIG_arg_fail(1)) SWIG_fail;
10182 {
10183 arg2 = wxString_in_helper(obj1);
10184 if (arg2 == NULL) SWIG_fail;
10185 temp2 = true;
10186 }
10187 {
10188 PyThreadState* __tstate = wxPyBeginAllowThreads();
10189 (arg1)->SetMimeType((wxString const &)*arg2);
10190
10191 wxPyEndAllowThreads(__tstate);
10192 if (PyErr_Occurred()) SWIG_fail;
10193 }
10194 Py_INCREF(Py_None); resultobj = Py_None;
10195 {
10196 if (temp2)
10197 delete arg2;
10198 }
10199 return resultobj;
10200 fail:
10201 {
10202 if (temp2)
10203 delete arg2;
10204 }
10205 return NULL;
10206 }
10207
10208
10209 static PyObject * ImageHandler_swigregister(PyObject *, PyObject *args) {
10210 PyObject *obj;
10211 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10212 SWIG_TypeClientData(SWIGTYPE_p_wxImageHandler, obj);
10213 Py_INCREF(obj);
10214 return Py_BuildValue((char *)"");
10215 }
10216 static PyObject *_wrap_new_ImageHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
10217 PyObject *resultobj;
10218 wxImageHistogram *result;
10219 char *kwnames[] = {
10220 NULL
10221 };
10222
10223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ImageHistogram",kwnames)) goto fail;
10224 {
10225 PyThreadState* __tstate = wxPyBeginAllowThreads();
10226 result = (wxImageHistogram *)new wxImageHistogram();
10227
10228 wxPyEndAllowThreads(__tstate);
10229 if (PyErr_Occurred()) SWIG_fail;
10230 }
10231 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImageHistogram, 1);
10232 return resultobj;
10233 fail:
10234 return NULL;
10235 }
10236
10237
10238 static PyObject *_wrap_ImageHistogram_MakeKey(PyObject *, PyObject *args, PyObject *kwargs) {
10239 PyObject *resultobj;
10240 unsigned char arg1 ;
10241 unsigned char arg2 ;
10242 unsigned char arg3 ;
10243 unsigned long result;
10244 PyObject * obj0 = 0 ;
10245 PyObject * obj1 = 0 ;
10246 PyObject * obj2 = 0 ;
10247 char *kwnames[] = {
10248 (char *) "r",(char *) "g",(char *) "b", NULL
10249 };
10250
10251 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) goto fail;
10252 {
10253 arg1 = (unsigned char)(SWIG_As_unsigned_SS_char(obj0));
10254 if (SWIG_arg_fail(1)) SWIG_fail;
10255 }
10256 {
10257 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10258 if (SWIG_arg_fail(2)) SWIG_fail;
10259 }
10260 {
10261 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10262 if (SWIG_arg_fail(3)) SWIG_fail;
10263 }
10264 {
10265 PyThreadState* __tstate = wxPyBeginAllowThreads();
10266 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
10267
10268 wxPyEndAllowThreads(__tstate);
10269 if (PyErr_Occurred()) SWIG_fail;
10270 }
10271 {
10272 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10273 }
10274 return resultobj;
10275 fail:
10276 return NULL;
10277 }
10278
10279
10280 static PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
10281 PyObject *resultobj;
10282 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10283 unsigned char *arg2 = (unsigned char *) 0 ;
10284 unsigned char *arg3 = (unsigned char *) 0 ;
10285 unsigned char *arg4 = (unsigned char *) 0 ;
10286 unsigned char arg5 = (unsigned char) 1 ;
10287 unsigned char arg6 = (unsigned char) 0 ;
10288 unsigned char arg7 = (unsigned char) 0 ;
10289 bool result;
10290 unsigned char temp2 ;
10291 int res2 = 0 ;
10292 unsigned char temp3 ;
10293 int res3 = 0 ;
10294 unsigned char temp4 ;
10295 int res4 = 0 ;
10296 PyObject * obj0 = 0 ;
10297 PyObject * obj1 = 0 ;
10298 PyObject * obj2 = 0 ;
10299 PyObject * obj3 = 0 ;
10300 char *kwnames[] = {
10301 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
10302 };
10303
10304 arg2 = &temp2; res2 = SWIG_NEWOBJ;
10305 arg3 = &temp3; res3 = SWIG_NEWOBJ;
10306 arg4 = &temp4; res4 = SWIG_NEWOBJ;
10307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10309 if (SWIG_arg_fail(1)) SWIG_fail;
10310 if (obj1) {
10311 {
10312 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10313 if (SWIG_arg_fail(5)) SWIG_fail;
10314 }
10315 }
10316 if (obj2) {
10317 {
10318 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10319 if (SWIG_arg_fail(6)) SWIG_fail;
10320 }
10321 }
10322 if (obj3) {
10323 {
10324 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10325 if (SWIG_arg_fail(7)) SWIG_fail;
10326 }
10327 }
10328 {
10329 PyThreadState* __tstate = wxPyBeginAllowThreads();
10330 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
10331
10332 wxPyEndAllowThreads(__tstate);
10333 if (PyErr_Occurred()) SWIG_fail;
10334 }
10335 {
10336 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10337 }
10338 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
10339 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
10340 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
10341 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
10342 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
10343 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
10344 return resultobj;
10345 fail:
10346 return NULL;
10347 }
10348
10349
10350 static PyObject *_wrap_ImageHistogram_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
10351 PyObject *resultobj;
10352 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10353 unsigned long arg2 ;
10354 unsigned long result;
10355 PyObject * obj0 = 0 ;
10356 PyObject * obj1 = 0 ;
10357 char *kwnames[] = {
10358 (char *) "self",(char *) "key", NULL
10359 };
10360
10361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) goto fail;
10362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10363 if (SWIG_arg_fail(1)) SWIG_fail;
10364 {
10365 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
10366 if (SWIG_arg_fail(2)) SWIG_fail;
10367 }
10368 {
10369 PyThreadState* __tstate = wxPyBeginAllowThreads();
10370 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
10371
10372 wxPyEndAllowThreads(__tstate);
10373 if (PyErr_Occurred()) SWIG_fail;
10374 }
10375 {
10376 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10377 }
10378 return resultobj;
10379 fail:
10380 return NULL;
10381 }
10382
10383
10384 static PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *, PyObject *args, PyObject *kwargs) {
10385 PyObject *resultobj;
10386 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10387 unsigned char arg2 ;
10388 unsigned char arg3 ;
10389 unsigned char arg4 ;
10390 unsigned long result;
10391 PyObject * obj0 = 0 ;
10392 PyObject * obj1 = 0 ;
10393 PyObject * obj2 = 0 ;
10394 PyObject * obj3 = 0 ;
10395 char *kwnames[] = {
10396 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
10397 };
10398
10399 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10400 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10401 if (SWIG_arg_fail(1)) SWIG_fail;
10402 {
10403 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
10404 if (SWIG_arg_fail(2)) SWIG_fail;
10405 }
10406 {
10407 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
10408 if (SWIG_arg_fail(3)) SWIG_fail;
10409 }
10410 {
10411 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
10412 if (SWIG_arg_fail(4)) SWIG_fail;
10413 }
10414 {
10415 PyThreadState* __tstate = wxPyBeginAllowThreads();
10416 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
10417
10418 wxPyEndAllowThreads(__tstate);
10419 if (PyErr_Occurred()) SWIG_fail;
10420 }
10421 {
10422 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10423 }
10424 return resultobj;
10425 fail:
10426 return NULL;
10427 }
10428
10429
10430 static PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *, PyObject *args, PyObject *kwargs) {
10431 PyObject *resultobj;
10432 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
10433 wxColour *arg2 = 0 ;
10434 unsigned long result;
10435 wxColour temp2 ;
10436 PyObject * obj0 = 0 ;
10437 PyObject * obj1 = 0 ;
10438 char *kwnames[] = {
10439 (char *) "self",(char *) "colour", NULL
10440 };
10441
10442 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) goto fail;
10443 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
10444 if (SWIG_arg_fail(1)) SWIG_fail;
10445 {
10446 arg2 = &temp2;
10447 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
10448 }
10449 {
10450 PyThreadState* __tstate = wxPyBeginAllowThreads();
10451 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
10452
10453 wxPyEndAllowThreads(__tstate);
10454 if (PyErr_Occurred()) SWIG_fail;
10455 }
10456 {
10457 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
10458 }
10459 return resultobj;
10460 fail:
10461 return NULL;
10462 }
10463
10464
10465 static PyObject * ImageHistogram_swigregister(PyObject *, PyObject *args) {
10466 PyObject *obj;
10467 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
10468 SWIG_TypeClientData(SWIGTYPE_p_wxImageHistogram, obj);
10469 Py_INCREF(obj);
10470 return Py_BuildValue((char *)"");
10471 }
10472 static PyObject *_wrap_new_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10473 PyObject *resultobj;
10474 wxString *arg1 = 0 ;
10475 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10476 int arg3 = (int) -1 ;
10477 wxImage *result;
10478 bool temp1 = false ;
10479 PyObject * obj0 = 0 ;
10480 PyObject * obj1 = 0 ;
10481 PyObject * obj2 = 0 ;
10482 char *kwnames[] = {
10483 (char *) "name",(char *) "type",(char *) "index", NULL
10484 };
10485
10486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) goto fail;
10487 {
10488 arg1 = wxString_in_helper(obj0);
10489 if (arg1 == NULL) SWIG_fail;
10490 temp1 = true;
10491 }
10492 if (obj1) {
10493 {
10494 arg2 = (long)(SWIG_As_long(obj1));
10495 if (SWIG_arg_fail(2)) SWIG_fail;
10496 }
10497 }
10498 if (obj2) {
10499 {
10500 arg3 = (int)(SWIG_As_int(obj2));
10501 if (SWIG_arg_fail(3)) SWIG_fail;
10502 }
10503 }
10504 {
10505 PyThreadState* __tstate = wxPyBeginAllowThreads();
10506 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
10507
10508 wxPyEndAllowThreads(__tstate);
10509 if (PyErr_Occurred()) SWIG_fail;
10510 }
10511 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10512 {
10513 if (temp1)
10514 delete arg1;
10515 }
10516 return resultobj;
10517 fail:
10518 {
10519 if (temp1)
10520 delete arg1;
10521 }
10522 return NULL;
10523 }
10524
10525
10526 static PyObject *_wrap_delete_Image(PyObject *, PyObject *args, PyObject *kwargs) {
10527 PyObject *resultobj;
10528 wxImage *arg1 = (wxImage *) 0 ;
10529 PyObject * obj0 = 0 ;
10530 char *kwnames[] = {
10531 (char *) "self", NULL
10532 };
10533
10534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Image",kwnames,&obj0)) goto fail;
10535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10536 if (SWIG_arg_fail(1)) SWIG_fail;
10537 {
10538 PyThreadState* __tstate = wxPyBeginAllowThreads();
10539 delete arg1;
10540
10541 wxPyEndAllowThreads(__tstate);
10542 if (PyErr_Occurred()) SWIG_fail;
10543 }
10544 Py_INCREF(Py_None); resultobj = Py_None;
10545 return resultobj;
10546 fail:
10547 return NULL;
10548 }
10549
10550
10551 static PyObject *_wrap_new_ImageFromMime(PyObject *, PyObject *args, PyObject *kwargs) {
10552 PyObject *resultobj;
10553 wxString *arg1 = 0 ;
10554 wxString *arg2 = 0 ;
10555 int arg3 = (int) -1 ;
10556 wxImage *result;
10557 bool temp1 = false ;
10558 bool temp2 = false ;
10559 PyObject * obj0 = 0 ;
10560 PyObject * obj1 = 0 ;
10561 PyObject * obj2 = 0 ;
10562 char *kwnames[] = {
10563 (char *) "name",(char *) "mimetype",(char *) "index", NULL
10564 };
10565
10566 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10567 {
10568 arg1 = wxString_in_helper(obj0);
10569 if (arg1 == NULL) SWIG_fail;
10570 temp1 = true;
10571 }
10572 {
10573 arg2 = wxString_in_helper(obj1);
10574 if (arg2 == NULL) SWIG_fail;
10575 temp2 = true;
10576 }
10577 if (obj2) {
10578 {
10579 arg3 = (int)(SWIG_As_int(obj2));
10580 if (SWIG_arg_fail(3)) SWIG_fail;
10581 }
10582 }
10583 {
10584 PyThreadState* __tstate = wxPyBeginAllowThreads();
10585 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
10586
10587 wxPyEndAllowThreads(__tstate);
10588 if (PyErr_Occurred()) SWIG_fail;
10589 }
10590 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10591 {
10592 if (temp1)
10593 delete arg1;
10594 }
10595 {
10596 if (temp2)
10597 delete arg2;
10598 }
10599 return resultobj;
10600 fail:
10601 {
10602 if (temp1)
10603 delete arg1;
10604 }
10605 {
10606 if (temp2)
10607 delete arg2;
10608 }
10609 return NULL;
10610 }
10611
10612
10613 static PyObject *_wrap_new_ImageFromStream(PyObject *, PyObject *args, PyObject *kwargs) {
10614 PyObject *resultobj;
10615 wxInputStream *arg1 = 0 ;
10616 long arg2 = (long) wxBITMAP_TYPE_ANY ;
10617 int arg3 = (int) -1 ;
10618 wxImage *result;
10619 wxPyInputStream *temp1 ;
10620 bool created1 ;
10621 PyObject * obj0 = 0 ;
10622 PyObject * obj1 = 0 ;
10623 PyObject * obj2 = 0 ;
10624 char *kwnames[] = {
10625 (char *) "stream",(char *) "type",(char *) "index", NULL
10626 };
10627
10628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) goto fail;
10629 {
10630 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10631 arg1 = temp1->m_wxis;
10632 created1 = false;
10633 } else {
10634 PyErr_Clear(); // clear the failure of the wxPyConvert above
10635 arg1 = wxPyCBInputStream_create(obj0, false);
10636 if (arg1 == NULL) {
10637 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10638 SWIG_fail;
10639 }
10640 created1 = true;
10641 }
10642 }
10643 if (obj1) {
10644 {
10645 arg2 = (long)(SWIG_As_long(obj1));
10646 if (SWIG_arg_fail(2)) SWIG_fail;
10647 }
10648 }
10649 if (obj2) {
10650 {
10651 arg3 = (int)(SWIG_As_int(obj2));
10652 if (SWIG_arg_fail(3)) SWIG_fail;
10653 }
10654 }
10655 {
10656 PyThreadState* __tstate = wxPyBeginAllowThreads();
10657 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
10658
10659 wxPyEndAllowThreads(__tstate);
10660 if (PyErr_Occurred()) SWIG_fail;
10661 }
10662 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10663 {
10664 if (created1) delete arg1;
10665 }
10666 return resultobj;
10667 fail:
10668 {
10669 if (created1) delete arg1;
10670 }
10671 return NULL;
10672 }
10673
10674
10675 static PyObject *_wrap_new_ImageFromStreamMime(PyObject *, PyObject *args, PyObject *kwargs) {
10676 PyObject *resultobj;
10677 wxInputStream *arg1 = 0 ;
10678 wxString *arg2 = 0 ;
10679 int arg3 = (int) -1 ;
10680 wxImage *result;
10681 wxPyInputStream *temp1 ;
10682 bool created1 ;
10683 bool temp2 = false ;
10684 PyObject * obj0 = 0 ;
10685 PyObject * obj1 = 0 ;
10686 PyObject * obj2 = 0 ;
10687 char *kwnames[] = {
10688 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
10689 };
10690
10691 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) goto fail;
10692 {
10693 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
10694 arg1 = temp1->m_wxis;
10695 created1 = false;
10696 } else {
10697 PyErr_Clear(); // clear the failure of the wxPyConvert above
10698 arg1 = wxPyCBInputStream_create(obj0, false);
10699 if (arg1 == NULL) {
10700 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
10701 SWIG_fail;
10702 }
10703 created1 = true;
10704 }
10705 }
10706 {
10707 arg2 = wxString_in_helper(obj1);
10708 if (arg2 == NULL) SWIG_fail;
10709 temp2 = true;
10710 }
10711 if (obj2) {
10712 {
10713 arg3 = (int)(SWIG_As_int(obj2));
10714 if (SWIG_arg_fail(3)) SWIG_fail;
10715 }
10716 }
10717 {
10718 PyThreadState* __tstate = wxPyBeginAllowThreads();
10719 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
10720
10721 wxPyEndAllowThreads(__tstate);
10722 if (PyErr_Occurred()) SWIG_fail;
10723 }
10724 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10725 {
10726 if (created1) delete arg1;
10727 }
10728 {
10729 if (temp2)
10730 delete arg2;
10731 }
10732 return resultobj;
10733 fail:
10734 {
10735 if (created1) delete arg1;
10736 }
10737 {
10738 if (temp2)
10739 delete arg2;
10740 }
10741 return NULL;
10742 }
10743
10744
10745 static PyObject *_wrap_new_EmptyImage(PyObject *, PyObject *args, PyObject *kwargs) {
10746 PyObject *resultobj;
10747 int arg1 = (int) 0 ;
10748 int arg2 = (int) 0 ;
10749 bool arg3 = (bool) true ;
10750 wxImage *result;
10751 PyObject * obj0 = 0 ;
10752 PyObject * obj1 = 0 ;
10753 PyObject * obj2 = 0 ;
10754 char *kwnames[] = {
10755 (char *) "width",(char *) "height",(char *) "clear", NULL
10756 };
10757
10758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) goto fail;
10759 if (obj0) {
10760 {
10761 arg1 = (int)(SWIG_As_int(obj0));
10762 if (SWIG_arg_fail(1)) SWIG_fail;
10763 }
10764 }
10765 if (obj1) {
10766 {
10767 arg2 = (int)(SWIG_As_int(obj1));
10768 if (SWIG_arg_fail(2)) SWIG_fail;
10769 }
10770 }
10771 if (obj2) {
10772 {
10773 arg3 = (bool)(SWIG_As_bool(obj2));
10774 if (SWIG_arg_fail(3)) SWIG_fail;
10775 }
10776 }
10777 {
10778 PyThreadState* __tstate = wxPyBeginAllowThreads();
10779 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
10780
10781 wxPyEndAllowThreads(__tstate);
10782 if (PyErr_Occurred()) SWIG_fail;
10783 }
10784 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10785 return resultobj;
10786 fail:
10787 return NULL;
10788 }
10789
10790
10791 static PyObject *_wrap_new_ImageFromBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
10792 PyObject *resultobj;
10793 wxBitmap *arg1 = 0 ;
10794 wxImage *result;
10795 PyObject * obj0 = 0 ;
10796 char *kwnames[] = {
10797 (char *) "bitmap", NULL
10798 };
10799
10800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) goto fail;
10801 {
10802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
10803 if (SWIG_arg_fail(1)) SWIG_fail;
10804 if (arg1 == NULL) {
10805 SWIG_null_ref("wxBitmap");
10806 }
10807 if (SWIG_arg_fail(1)) SWIG_fail;
10808 }
10809 {
10810 if (!wxPyCheckForApp()) SWIG_fail;
10811 PyThreadState* __tstate = wxPyBeginAllowThreads();
10812 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
10813
10814 wxPyEndAllowThreads(__tstate);
10815 if (PyErr_Occurred()) SWIG_fail;
10816 }
10817 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10818 return resultobj;
10819 fail:
10820 return NULL;
10821 }
10822
10823
10824 static PyObject *_wrap_new_ImageFromData(PyObject *, PyObject *args, PyObject *kwargs) {
10825 PyObject *resultobj;
10826 int arg1 ;
10827 int arg2 ;
10828 buffer arg3 ;
10829 int arg4 ;
10830 wxImage *result;
10831 PyObject * obj0 = 0 ;
10832 PyObject * obj1 = 0 ;
10833 PyObject * obj2 = 0 ;
10834 char *kwnames[] = {
10835 (char *) "width",(char *) "height",(char *) "data", NULL
10836 };
10837
10838 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) goto fail;
10839 {
10840 arg1 = (int)(SWIG_As_int(obj0));
10841 if (SWIG_arg_fail(1)) SWIG_fail;
10842 }
10843 {
10844 arg2 = (int)(SWIG_As_int(obj1));
10845 if (SWIG_arg_fail(2)) SWIG_fail;
10846 }
10847 {
10848 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10849 }
10850 {
10851 PyThreadState* __tstate = wxPyBeginAllowThreads();
10852 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
10853
10854 wxPyEndAllowThreads(__tstate);
10855 if (PyErr_Occurred()) SWIG_fail;
10856 }
10857 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10858 return resultobj;
10859 fail:
10860 return NULL;
10861 }
10862
10863
10864 static PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
10865 PyObject *resultobj;
10866 int arg1 ;
10867 int arg2 ;
10868 buffer arg3 ;
10869 int arg4 ;
10870 buffer arg5 ;
10871 int arg6 ;
10872 wxImage *result;
10873 PyObject * obj0 = 0 ;
10874 PyObject * obj1 = 0 ;
10875 PyObject * obj2 = 0 ;
10876 PyObject * obj3 = 0 ;
10877 char *kwnames[] = {
10878 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
10879 };
10880
10881 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
10882 {
10883 arg1 = (int)(SWIG_As_int(obj0));
10884 if (SWIG_arg_fail(1)) SWIG_fail;
10885 }
10886 {
10887 arg2 = (int)(SWIG_As_int(obj1));
10888 if (SWIG_arg_fail(2)) SWIG_fail;
10889 }
10890 {
10891 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
10892 }
10893 {
10894 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
10895 }
10896 {
10897 PyThreadState* __tstate = wxPyBeginAllowThreads();
10898 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
10899
10900 wxPyEndAllowThreads(__tstate);
10901 if (PyErr_Occurred()) SWIG_fail;
10902 }
10903 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 1);
10904 return resultobj;
10905 fail:
10906 return NULL;
10907 }
10908
10909
10910 static PyObject *_wrap_Image_Create(PyObject *, PyObject *args, PyObject *kwargs) {
10911 PyObject *resultobj;
10912 wxImage *arg1 = (wxImage *) 0 ;
10913 int arg2 ;
10914 int arg3 ;
10915 PyObject * obj0 = 0 ;
10916 PyObject * obj1 = 0 ;
10917 PyObject * obj2 = 0 ;
10918 char *kwnames[] = {
10919 (char *) "self",(char *) "width",(char *) "height", NULL
10920 };
10921
10922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Create",kwnames,&obj0,&obj1,&obj2)) goto fail;
10923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10924 if (SWIG_arg_fail(1)) SWIG_fail;
10925 {
10926 arg2 = (int)(SWIG_As_int(obj1));
10927 if (SWIG_arg_fail(2)) SWIG_fail;
10928 }
10929 {
10930 arg3 = (int)(SWIG_As_int(obj2));
10931 if (SWIG_arg_fail(3)) SWIG_fail;
10932 }
10933 {
10934 PyThreadState* __tstate = wxPyBeginAllowThreads();
10935 (arg1)->Create(arg2,arg3);
10936
10937 wxPyEndAllowThreads(__tstate);
10938 if (PyErr_Occurred()) SWIG_fail;
10939 }
10940 Py_INCREF(Py_None); resultobj = Py_None;
10941 return resultobj;
10942 fail:
10943 return NULL;
10944 }
10945
10946
10947 static PyObject *_wrap_Image_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
10948 PyObject *resultobj;
10949 wxImage *arg1 = (wxImage *) 0 ;
10950 PyObject * obj0 = 0 ;
10951 char *kwnames[] = {
10952 (char *) "self", NULL
10953 };
10954
10955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Destroy",kwnames,&obj0)) goto fail;
10956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10957 if (SWIG_arg_fail(1)) SWIG_fail;
10958 {
10959 PyThreadState* __tstate = wxPyBeginAllowThreads();
10960 (arg1)->Destroy();
10961
10962 wxPyEndAllowThreads(__tstate);
10963 if (PyErr_Occurred()) SWIG_fail;
10964 }
10965 Py_INCREF(Py_None); resultobj = Py_None;
10966 return resultobj;
10967 fail:
10968 return NULL;
10969 }
10970
10971
10972 static PyObject *_wrap_Image_Scale(PyObject *, PyObject *args, PyObject *kwargs) {
10973 PyObject *resultobj;
10974 wxImage *arg1 = (wxImage *) 0 ;
10975 int arg2 ;
10976 int arg3 ;
10977 SwigValueWrapper<wxImage > result;
10978 PyObject * obj0 = 0 ;
10979 PyObject * obj1 = 0 ;
10980 PyObject * obj2 = 0 ;
10981 char *kwnames[] = {
10982 (char *) "self",(char *) "width",(char *) "height", NULL
10983 };
10984
10985 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) goto fail;
10986 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
10987 if (SWIG_arg_fail(1)) SWIG_fail;
10988 {
10989 arg2 = (int)(SWIG_As_int(obj1));
10990 if (SWIG_arg_fail(2)) SWIG_fail;
10991 }
10992 {
10993 arg3 = (int)(SWIG_As_int(obj2));
10994 if (SWIG_arg_fail(3)) SWIG_fail;
10995 }
10996 {
10997 PyThreadState* __tstate = wxPyBeginAllowThreads();
10998 result = (arg1)->Scale(arg2,arg3);
10999
11000 wxPyEndAllowThreads(__tstate);
11001 if (PyErr_Occurred()) SWIG_fail;
11002 }
11003 {
11004 wxImage * resultptr;
11005 resultptr = new wxImage((wxImage &)(result));
11006 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11007 }
11008 return resultobj;
11009 fail:
11010 return NULL;
11011 }
11012
11013
11014 static PyObject *_wrap_Image_ShrinkBy(PyObject *, PyObject *args, PyObject *kwargs) {
11015 PyObject *resultobj;
11016 wxImage *arg1 = (wxImage *) 0 ;
11017 int arg2 ;
11018 int arg3 ;
11019 SwigValueWrapper<wxImage > result;
11020 PyObject * obj0 = 0 ;
11021 PyObject * obj1 = 0 ;
11022 PyObject * obj2 = 0 ;
11023 char *kwnames[] = {
11024 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
11025 };
11026
11027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) goto fail;
11028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11029 if (SWIG_arg_fail(1)) SWIG_fail;
11030 {
11031 arg2 = (int)(SWIG_As_int(obj1));
11032 if (SWIG_arg_fail(2)) SWIG_fail;
11033 }
11034 {
11035 arg3 = (int)(SWIG_As_int(obj2));
11036 if (SWIG_arg_fail(3)) SWIG_fail;
11037 }
11038 {
11039 PyThreadState* __tstate = wxPyBeginAllowThreads();
11040 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
11041
11042 wxPyEndAllowThreads(__tstate);
11043 if (PyErr_Occurred()) SWIG_fail;
11044 }
11045 {
11046 wxImage * resultptr;
11047 resultptr = new wxImage((wxImage &)(result));
11048 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
11049 }
11050 return resultobj;
11051 fail:
11052 return NULL;
11053 }
11054
11055
11056 static PyObject *_wrap_Image_Rescale(PyObject *, PyObject *args, PyObject *kwargs) {
11057 PyObject *resultobj;
11058 wxImage *arg1 = (wxImage *) 0 ;
11059 int arg2 ;
11060 int arg3 ;
11061 wxImage *result;
11062 PyObject * obj0 = 0 ;
11063 PyObject * obj1 = 0 ;
11064 PyObject * obj2 = 0 ;
11065 char *kwnames[] = {
11066 (char *) "self",(char *) "width",(char *) "height", NULL
11067 };
11068
11069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) goto fail;
11070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11071 if (SWIG_arg_fail(1)) SWIG_fail;
11072 {
11073 arg2 = (int)(SWIG_As_int(obj1));
11074 if (SWIG_arg_fail(2)) SWIG_fail;
11075 }
11076 {
11077 arg3 = (int)(SWIG_As_int(obj2));
11078 if (SWIG_arg_fail(3)) SWIG_fail;
11079 }
11080 {
11081 PyThreadState* __tstate = wxPyBeginAllowThreads();
11082 {
11083 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
11084 result = (wxImage *) &_result_ref;
11085 }
11086
11087 wxPyEndAllowThreads(__tstate);
11088 if (PyErr_Occurred()) SWIG_fail;
11089 }
11090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11091 return resultobj;
11092 fail:
11093 return NULL;
11094 }
11095
11096
11097 static PyObject *_wrap_Image_Resize(PyObject *, PyObject *args, PyObject *kwargs) {
11098 PyObject *resultobj;
11099 wxImage *arg1 = (wxImage *) 0 ;
11100 wxSize *arg2 = 0 ;
11101 wxPoint *arg3 = 0 ;
11102 int arg4 = (int) -1 ;
11103 int arg5 = (int) -1 ;
11104 int arg6 = (int) -1 ;
11105 wxImage *result;
11106 wxSize temp2 ;
11107 wxPoint temp3 ;
11108 PyObject * obj0 = 0 ;
11109 PyObject * obj1 = 0 ;
11110 PyObject * obj2 = 0 ;
11111 PyObject * obj3 = 0 ;
11112 PyObject * obj4 = 0 ;
11113 PyObject * obj5 = 0 ;
11114 char *kwnames[] = {
11115 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
11116 };
11117
11118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11120 if (SWIG_arg_fail(1)) SWIG_fail;
11121 {
11122 arg2 = &temp2;
11123 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
11124 }
11125 {
11126 arg3 = &temp3;
11127 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
11128 }
11129 if (obj3) {
11130 {
11131 arg4 = (int)(SWIG_As_int(obj3));
11132 if (SWIG_arg_fail(4)) SWIG_fail;
11133 }
11134 }
11135 if (obj4) {
11136 {
11137 arg5 = (int)(SWIG_As_int(obj4));
11138 if (SWIG_arg_fail(5)) SWIG_fail;
11139 }
11140 }
11141 if (obj5) {
11142 {
11143 arg6 = (int)(SWIG_As_int(obj5));
11144 if (SWIG_arg_fail(6)) SWIG_fail;
11145 }
11146 }
11147 {
11148 PyThreadState* __tstate = wxPyBeginAllowThreads();
11149 {
11150 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
11151 result = (wxImage *) &_result_ref;
11152 }
11153
11154 wxPyEndAllowThreads(__tstate);
11155 if (PyErr_Occurred()) SWIG_fail;
11156 }
11157 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxImage, 0);
11158 return resultobj;
11159 fail:
11160 return NULL;
11161 }
11162
11163
11164 static PyObject *_wrap_Image_SetRGB(PyObject *, PyObject *args, PyObject *kwargs) {
11165 PyObject *resultobj;
11166 wxImage *arg1 = (wxImage *) 0 ;
11167 int arg2 ;
11168 int arg3 ;
11169 unsigned char arg4 ;
11170 unsigned char arg5 ;
11171 unsigned char arg6 ;
11172 PyObject * obj0 = 0 ;
11173 PyObject * obj1 = 0 ;
11174 PyObject * obj2 = 0 ;
11175 PyObject * obj3 = 0 ;
11176 PyObject * obj4 = 0 ;
11177 PyObject * obj5 = 0 ;
11178 char *kwnames[] = {
11179 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
11180 };
11181
11182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
11183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11184 if (SWIG_arg_fail(1)) SWIG_fail;
11185 {
11186 arg2 = (int)(SWIG_As_int(obj1));
11187 if (SWIG_arg_fail(2)) SWIG_fail;
11188 }
11189 {
11190 arg3 = (int)(SWIG_As_int(obj2));
11191 if (SWIG_arg_fail(3)) SWIG_fail;
11192 }
11193 {
11194 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11195 if (SWIG_arg_fail(4)) SWIG_fail;
11196 }
11197 {
11198 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11199 if (SWIG_arg_fail(5)) SWIG_fail;
11200 }
11201 {
11202 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
11203 if (SWIG_arg_fail(6)) SWIG_fail;
11204 }
11205 {
11206 PyThreadState* __tstate = wxPyBeginAllowThreads();
11207 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
11208
11209 wxPyEndAllowThreads(__tstate);
11210 if (PyErr_Occurred()) SWIG_fail;
11211 }
11212 Py_INCREF(Py_None); resultobj = Py_None;
11213 return resultobj;
11214 fail:
11215 return NULL;
11216 }
11217
11218
11219 static PyObject *_wrap_Image_SetRGBRect(PyObject *, PyObject *args, PyObject *kwargs) {
11220 PyObject *resultobj;
11221 wxImage *arg1 = (wxImage *) 0 ;
11222 wxRect *arg2 = 0 ;
11223 unsigned char arg3 ;
11224 unsigned char arg4 ;
11225 unsigned char arg5 ;
11226 wxRect temp2 ;
11227 PyObject * obj0 = 0 ;
11228 PyObject * obj1 = 0 ;
11229 PyObject * obj2 = 0 ;
11230 PyObject * obj3 = 0 ;
11231 PyObject * obj4 = 0 ;
11232 char *kwnames[] = {
11233 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
11234 };
11235
11236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11238 if (SWIG_arg_fail(1)) SWIG_fail;
11239 {
11240 arg2 = &temp2;
11241 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
11242 }
11243 {
11244 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11245 if (SWIG_arg_fail(3)) SWIG_fail;
11246 }
11247 {
11248 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11249 if (SWIG_arg_fail(4)) SWIG_fail;
11250 }
11251 {
11252 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
11253 if (SWIG_arg_fail(5)) SWIG_fail;
11254 }
11255 {
11256 PyThreadState* __tstate = wxPyBeginAllowThreads();
11257 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
11258
11259 wxPyEndAllowThreads(__tstate);
11260 if (PyErr_Occurred()) SWIG_fail;
11261 }
11262 Py_INCREF(Py_None); resultobj = Py_None;
11263 return resultobj;
11264 fail:
11265 return NULL;
11266 }
11267
11268
11269 static PyObject *_wrap_Image_GetRed(PyObject *, PyObject *args, PyObject *kwargs) {
11270 PyObject *resultobj;
11271 wxImage *arg1 = (wxImage *) 0 ;
11272 int arg2 ;
11273 int arg3 ;
11274 unsigned char result;
11275 PyObject * obj0 = 0 ;
11276 PyObject * obj1 = 0 ;
11277 PyObject * obj2 = 0 ;
11278 char *kwnames[] = {
11279 (char *) "self",(char *) "x",(char *) "y", NULL
11280 };
11281
11282 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) goto fail;
11283 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11284 if (SWIG_arg_fail(1)) SWIG_fail;
11285 {
11286 arg2 = (int)(SWIG_As_int(obj1));
11287 if (SWIG_arg_fail(2)) SWIG_fail;
11288 }
11289 {
11290 arg3 = (int)(SWIG_As_int(obj2));
11291 if (SWIG_arg_fail(3)) SWIG_fail;
11292 }
11293 {
11294 PyThreadState* __tstate = wxPyBeginAllowThreads();
11295 result = (unsigned char)(arg1)->GetRed(arg2,arg3);
11296
11297 wxPyEndAllowThreads(__tstate);
11298 if (PyErr_Occurred()) SWIG_fail;
11299 }
11300 {
11301 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11302 }
11303 return resultobj;
11304 fail:
11305 return NULL;
11306 }
11307
11308
11309 static PyObject *_wrap_Image_GetGreen(PyObject *, PyObject *args, PyObject *kwargs) {
11310 PyObject *resultobj;
11311 wxImage *arg1 = (wxImage *) 0 ;
11312 int arg2 ;
11313 int arg3 ;
11314 unsigned char result;
11315 PyObject * obj0 = 0 ;
11316 PyObject * obj1 = 0 ;
11317 PyObject * obj2 = 0 ;
11318 char *kwnames[] = {
11319 (char *) "self",(char *) "x",(char *) "y", NULL
11320 };
11321
11322 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) goto fail;
11323 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11324 if (SWIG_arg_fail(1)) SWIG_fail;
11325 {
11326 arg2 = (int)(SWIG_As_int(obj1));
11327 if (SWIG_arg_fail(2)) SWIG_fail;
11328 }
11329 {
11330 arg3 = (int)(SWIG_As_int(obj2));
11331 if (SWIG_arg_fail(3)) SWIG_fail;
11332 }
11333 {
11334 PyThreadState* __tstate = wxPyBeginAllowThreads();
11335 result = (unsigned char)(arg1)->GetGreen(arg2,arg3);
11336
11337 wxPyEndAllowThreads(__tstate);
11338 if (PyErr_Occurred()) SWIG_fail;
11339 }
11340 {
11341 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11342 }
11343 return resultobj;
11344 fail:
11345 return NULL;
11346 }
11347
11348
11349 static PyObject *_wrap_Image_GetBlue(PyObject *, PyObject *args, PyObject *kwargs) {
11350 PyObject *resultobj;
11351 wxImage *arg1 = (wxImage *) 0 ;
11352 int arg2 ;
11353 int arg3 ;
11354 unsigned char result;
11355 PyObject * obj0 = 0 ;
11356 PyObject * obj1 = 0 ;
11357 PyObject * obj2 = 0 ;
11358 char *kwnames[] = {
11359 (char *) "self",(char *) "x",(char *) "y", NULL
11360 };
11361
11362 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) goto fail;
11363 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11364 if (SWIG_arg_fail(1)) SWIG_fail;
11365 {
11366 arg2 = (int)(SWIG_As_int(obj1));
11367 if (SWIG_arg_fail(2)) SWIG_fail;
11368 }
11369 {
11370 arg3 = (int)(SWIG_As_int(obj2));
11371 if (SWIG_arg_fail(3)) SWIG_fail;
11372 }
11373 {
11374 PyThreadState* __tstate = wxPyBeginAllowThreads();
11375 result = (unsigned char)(arg1)->GetBlue(arg2,arg3);
11376
11377 wxPyEndAllowThreads(__tstate);
11378 if (PyErr_Occurred()) SWIG_fail;
11379 }
11380 {
11381 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11382 }
11383 return resultobj;
11384 fail:
11385 return NULL;
11386 }
11387
11388
11389 static PyObject *_wrap_Image_SetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11390 PyObject *resultobj;
11391 wxImage *arg1 = (wxImage *) 0 ;
11392 int arg2 ;
11393 int arg3 ;
11394 unsigned char arg4 ;
11395 PyObject * obj0 = 0 ;
11396 PyObject * obj1 = 0 ;
11397 PyObject * obj2 = 0 ;
11398 PyObject * obj3 = 0 ;
11399 char *kwnames[] = {
11400 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
11401 };
11402
11403 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11404 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11405 if (SWIG_arg_fail(1)) SWIG_fail;
11406 {
11407 arg2 = (int)(SWIG_As_int(obj1));
11408 if (SWIG_arg_fail(2)) SWIG_fail;
11409 }
11410 {
11411 arg3 = (int)(SWIG_As_int(obj2));
11412 if (SWIG_arg_fail(3)) SWIG_fail;
11413 }
11414 {
11415 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11416 if (SWIG_arg_fail(4)) SWIG_fail;
11417 }
11418 {
11419 PyThreadState* __tstate = wxPyBeginAllowThreads();
11420 (arg1)->SetAlpha(arg2,arg3,arg4);
11421
11422 wxPyEndAllowThreads(__tstate);
11423 if (PyErr_Occurred()) SWIG_fail;
11424 }
11425 Py_INCREF(Py_None); resultobj = Py_None;
11426 return resultobj;
11427 fail:
11428 return NULL;
11429 }
11430
11431
11432 static PyObject *_wrap_Image_GetAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11433 PyObject *resultobj;
11434 wxImage *arg1 = (wxImage *) 0 ;
11435 int arg2 ;
11436 int arg3 ;
11437 unsigned char result;
11438 PyObject * obj0 = 0 ;
11439 PyObject * obj1 = 0 ;
11440 PyObject * obj2 = 0 ;
11441 char *kwnames[] = {
11442 (char *) "self",(char *) "x",(char *) "y", NULL
11443 };
11444
11445 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) goto fail;
11446 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11447 if (SWIG_arg_fail(1)) SWIG_fail;
11448 {
11449 arg2 = (int)(SWIG_As_int(obj1));
11450 if (SWIG_arg_fail(2)) SWIG_fail;
11451 }
11452 {
11453 arg3 = (int)(SWIG_As_int(obj2));
11454 if (SWIG_arg_fail(3)) SWIG_fail;
11455 }
11456 {
11457 PyThreadState* __tstate = wxPyBeginAllowThreads();
11458 result = (unsigned char)(arg1)->GetAlpha(arg2,arg3);
11459
11460 wxPyEndAllowThreads(__tstate);
11461 if (PyErr_Occurred()) SWIG_fail;
11462 }
11463 {
11464 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
11465 }
11466 return resultobj;
11467 fail:
11468 return NULL;
11469 }
11470
11471
11472 static PyObject *_wrap_Image_HasAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11473 PyObject *resultobj;
11474 wxImage *arg1 = (wxImage *) 0 ;
11475 bool result;
11476 PyObject * obj0 = 0 ;
11477 char *kwnames[] = {
11478 (char *) "self", NULL
11479 };
11480
11481 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasAlpha",kwnames,&obj0)) goto fail;
11482 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11483 if (SWIG_arg_fail(1)) SWIG_fail;
11484 {
11485 PyThreadState* __tstate = wxPyBeginAllowThreads();
11486 result = (bool)(arg1)->HasAlpha();
11487
11488 wxPyEndAllowThreads(__tstate);
11489 if (PyErr_Occurred()) SWIG_fail;
11490 }
11491 {
11492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11493 }
11494 return resultobj;
11495 fail:
11496 return NULL;
11497 }
11498
11499
11500 static PyObject *_wrap_Image_InitAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11501 PyObject *resultobj;
11502 wxImage *arg1 = (wxImage *) 0 ;
11503 PyObject * obj0 = 0 ;
11504 char *kwnames[] = {
11505 (char *) "self", NULL
11506 };
11507
11508 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InitAlpha",kwnames,&obj0)) goto fail;
11509 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11510 if (SWIG_arg_fail(1)) SWIG_fail;
11511 {
11512 PyThreadState* __tstate = wxPyBeginAllowThreads();
11513 (arg1)->InitAlpha();
11514
11515 wxPyEndAllowThreads(__tstate);
11516 if (PyErr_Occurred()) SWIG_fail;
11517 }
11518 Py_INCREF(Py_None); resultobj = Py_None;
11519 return resultobj;
11520 fail:
11521 return NULL;
11522 }
11523
11524
11525 static PyObject *_wrap_Image_IsTransparent(PyObject *, PyObject *args, PyObject *kwargs) {
11526 PyObject *resultobj;
11527 wxImage *arg1 = (wxImage *) 0 ;
11528 int arg2 ;
11529 int arg3 ;
11530 unsigned char arg4 = (unsigned char) wxIMAGE_ALPHA_THRESHOLD ;
11531 bool result;
11532 PyObject * obj0 = 0 ;
11533 PyObject * obj1 = 0 ;
11534 PyObject * obj2 = 0 ;
11535 PyObject * obj3 = 0 ;
11536 char *kwnames[] = {
11537 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
11538 };
11539
11540 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11541 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11542 if (SWIG_arg_fail(1)) SWIG_fail;
11543 {
11544 arg2 = (int)(SWIG_As_int(obj1));
11545 if (SWIG_arg_fail(2)) SWIG_fail;
11546 }
11547 {
11548 arg3 = (int)(SWIG_As_int(obj2));
11549 if (SWIG_arg_fail(3)) SWIG_fail;
11550 }
11551 if (obj3) {
11552 {
11553 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11554 if (SWIG_arg_fail(4)) SWIG_fail;
11555 }
11556 }
11557 {
11558 PyThreadState* __tstate = wxPyBeginAllowThreads();
11559 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
11560
11561 wxPyEndAllowThreads(__tstate);
11562 if (PyErr_Occurred()) SWIG_fail;
11563 }
11564 {
11565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11566 }
11567 return resultobj;
11568 fail:
11569 return NULL;
11570 }
11571
11572
11573 static PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *, PyObject *args, PyObject *kwargs) {
11574 PyObject *resultobj;
11575 wxImage *arg1 = (wxImage *) 0 ;
11576 byte *arg2 = (byte *) 0 ;
11577 byte *arg3 = (byte *) 0 ;
11578 byte *arg4 = (byte *) 0 ;
11579 byte arg5 = (byte) 0 ;
11580 byte arg6 = (byte) 0 ;
11581 byte arg7 = (byte) 0 ;
11582 bool result;
11583 byte temp2 ;
11584 int res2 = 0 ;
11585 byte temp3 ;
11586 int res3 = 0 ;
11587 byte temp4 ;
11588 int res4 = 0 ;
11589 PyObject * obj0 = 0 ;
11590 PyObject * obj1 = 0 ;
11591 PyObject * obj2 = 0 ;
11592 PyObject * obj3 = 0 ;
11593 char *kwnames[] = {
11594 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
11595 };
11596
11597 arg2 = &temp2; res2 = SWIG_NEWOBJ;
11598 arg3 = &temp3; res3 = SWIG_NEWOBJ;
11599 arg4 = &temp4; res4 = SWIG_NEWOBJ;
11600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11602 if (SWIG_arg_fail(1)) SWIG_fail;
11603 if (obj1) {
11604 {
11605 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11606 if (SWIG_arg_fail(5)) SWIG_fail;
11607 }
11608 }
11609 if (obj2) {
11610 {
11611 arg6 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11612 if (SWIG_arg_fail(6)) SWIG_fail;
11613 }
11614 }
11615 if (obj3) {
11616 {
11617 arg7 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11618 if (SWIG_arg_fail(7)) SWIG_fail;
11619 }
11620 }
11621 {
11622 PyThreadState* __tstate = wxPyBeginAllowThreads();
11623 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
11624
11625 wxPyEndAllowThreads(__tstate);
11626 if (PyErr_Occurred()) SWIG_fail;
11627 }
11628 {
11629 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11630 }
11631 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
11632 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
11633 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
11634 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
11635 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
11636 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
11637 return resultobj;
11638 fail:
11639 return NULL;
11640 }
11641
11642
11643 static PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *, PyObject *args, PyObject *kwargs) {
11644 PyObject *resultobj;
11645 wxImage *arg1 = (wxImage *) 0 ;
11646 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
11647 bool result;
11648 PyObject * obj0 = 0 ;
11649 PyObject * obj1 = 0 ;
11650 char *kwnames[] = {
11651 (char *) "self",(char *) "threshold", NULL
11652 };
11653
11654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) goto fail;
11655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11656 if (SWIG_arg_fail(1)) SWIG_fail;
11657 if (obj1) {
11658 {
11659 arg2 = (byte)(SWIG_As_unsigned_SS_char(obj1));
11660 if (SWIG_arg_fail(2)) SWIG_fail;
11661 }
11662 }
11663 {
11664 PyThreadState* __tstate = wxPyBeginAllowThreads();
11665 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
11666
11667 wxPyEndAllowThreads(__tstate);
11668 if (PyErr_Occurred()) SWIG_fail;
11669 }
11670 {
11671 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11672 }
11673 return resultobj;
11674 fail:
11675 return NULL;
11676 }
11677
11678
11679 static PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *, PyObject *args, PyObject *kwargs) {
11680 PyObject *resultobj;
11681 wxImage *arg1 = (wxImage *) 0 ;
11682 unsigned char arg2 ;
11683 unsigned char arg3 ;
11684 unsigned char arg4 ;
11685 bool result;
11686 PyObject * obj0 = 0 ;
11687 PyObject * obj1 = 0 ;
11688 PyObject * obj2 = 0 ;
11689 PyObject * obj3 = 0 ;
11690 char *kwnames[] = {
11691 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
11692 };
11693
11694 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11696 if (SWIG_arg_fail(1)) SWIG_fail;
11697 {
11698 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
11699 if (SWIG_arg_fail(2)) SWIG_fail;
11700 }
11701 {
11702 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
11703 if (SWIG_arg_fail(3)) SWIG_fail;
11704 }
11705 {
11706 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
11707 if (SWIG_arg_fail(4)) SWIG_fail;
11708 }
11709 {
11710 PyThreadState* __tstate = wxPyBeginAllowThreads();
11711 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
11712
11713 wxPyEndAllowThreads(__tstate);
11714 if (PyErr_Occurred()) SWIG_fail;
11715 }
11716 {
11717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11718 }
11719 return resultobj;
11720 fail:
11721 return NULL;
11722 }
11723
11724
11725 static PyObject *_wrap_Image_SetMaskFromImage(PyObject *, PyObject *args, PyObject *kwargs) {
11726 PyObject *resultobj;
11727 wxImage *arg1 = (wxImage *) 0 ;
11728 wxImage *arg2 = 0 ;
11729 byte arg3 ;
11730 byte arg4 ;
11731 byte arg5 ;
11732 bool result;
11733 PyObject * obj0 = 0 ;
11734 PyObject * obj1 = 0 ;
11735 PyObject * obj2 = 0 ;
11736 PyObject * obj3 = 0 ;
11737 PyObject * obj4 = 0 ;
11738 char *kwnames[] = {
11739 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
11740 };
11741
11742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
11743 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11744 if (SWIG_arg_fail(1)) SWIG_fail;
11745 {
11746 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11747 if (SWIG_arg_fail(2)) SWIG_fail;
11748 if (arg2 == NULL) {
11749 SWIG_null_ref("wxImage");
11750 }
11751 if (SWIG_arg_fail(2)) SWIG_fail;
11752 }
11753 {
11754 arg3 = (byte)(SWIG_As_unsigned_SS_char(obj2));
11755 if (SWIG_arg_fail(3)) SWIG_fail;
11756 }
11757 {
11758 arg4 = (byte)(SWIG_As_unsigned_SS_char(obj3));
11759 if (SWIG_arg_fail(4)) SWIG_fail;
11760 }
11761 {
11762 arg5 = (byte)(SWIG_As_unsigned_SS_char(obj4));
11763 if (SWIG_arg_fail(5)) SWIG_fail;
11764 }
11765 {
11766 PyThreadState* __tstate = wxPyBeginAllowThreads();
11767 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
11768
11769 wxPyEndAllowThreads(__tstate);
11770 if (PyErr_Occurred()) SWIG_fail;
11771 }
11772 {
11773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11774 }
11775 return resultobj;
11776 fail:
11777 return NULL;
11778 }
11779
11780
11781 static PyObject *_wrap_Image_CanRead(PyObject *, PyObject *args, PyObject *kwargs) {
11782 PyObject *resultobj;
11783 wxString *arg1 = 0 ;
11784 bool result;
11785 bool temp1 = false ;
11786 PyObject * obj0 = 0 ;
11787 char *kwnames[] = {
11788 (char *) "name", NULL
11789 };
11790
11791 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) goto fail;
11792 {
11793 arg1 = wxString_in_helper(obj0);
11794 if (arg1 == NULL) SWIG_fail;
11795 temp1 = true;
11796 }
11797 {
11798 PyThreadState* __tstate = wxPyBeginAllowThreads();
11799 result = (bool)wxImage::CanRead((wxString const &)*arg1);
11800
11801 wxPyEndAllowThreads(__tstate);
11802 if (PyErr_Occurred()) SWIG_fail;
11803 }
11804 {
11805 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11806 }
11807 {
11808 if (temp1)
11809 delete arg1;
11810 }
11811 return resultobj;
11812 fail:
11813 {
11814 if (temp1)
11815 delete arg1;
11816 }
11817 return NULL;
11818 }
11819
11820
11821 static PyObject *_wrap_Image_GetImageCount(PyObject *, PyObject *args, PyObject *kwargs) {
11822 PyObject *resultobj;
11823 wxString *arg1 = 0 ;
11824 long arg2 = (long) wxBITMAP_TYPE_ANY ;
11825 int result;
11826 bool temp1 = false ;
11827 PyObject * obj0 = 0 ;
11828 PyObject * obj1 = 0 ;
11829 char *kwnames[] = {
11830 (char *) "name",(char *) "type", NULL
11831 };
11832
11833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) goto fail;
11834 {
11835 arg1 = wxString_in_helper(obj0);
11836 if (arg1 == NULL) SWIG_fail;
11837 temp1 = true;
11838 }
11839 if (obj1) {
11840 {
11841 arg2 = (long)(SWIG_As_long(obj1));
11842 if (SWIG_arg_fail(2)) SWIG_fail;
11843 }
11844 }
11845 {
11846 PyThreadState* __tstate = wxPyBeginAllowThreads();
11847 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
11848
11849 wxPyEndAllowThreads(__tstate);
11850 if (PyErr_Occurred()) SWIG_fail;
11851 }
11852 {
11853 resultobj = SWIG_From_int((int)(result));
11854 }
11855 {
11856 if (temp1)
11857 delete arg1;
11858 }
11859 return resultobj;
11860 fail:
11861 {
11862 if (temp1)
11863 delete arg1;
11864 }
11865 return NULL;
11866 }
11867
11868
11869 static PyObject *_wrap_Image_LoadFile(PyObject *, PyObject *args, PyObject *kwargs) {
11870 PyObject *resultobj;
11871 wxImage *arg1 = (wxImage *) 0 ;
11872 wxString *arg2 = 0 ;
11873 long arg3 = (long) wxBITMAP_TYPE_ANY ;
11874 int arg4 = (int) -1 ;
11875 bool result;
11876 bool temp2 = false ;
11877 PyObject * obj0 = 0 ;
11878 PyObject * obj1 = 0 ;
11879 PyObject * obj2 = 0 ;
11880 PyObject * obj3 = 0 ;
11881 char *kwnames[] = {
11882 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
11883 };
11884
11885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11887 if (SWIG_arg_fail(1)) SWIG_fail;
11888 {
11889 arg2 = wxString_in_helper(obj1);
11890 if (arg2 == NULL) SWIG_fail;
11891 temp2 = true;
11892 }
11893 if (obj2) {
11894 {
11895 arg3 = (long)(SWIG_As_long(obj2));
11896 if (SWIG_arg_fail(3)) SWIG_fail;
11897 }
11898 }
11899 if (obj3) {
11900 {
11901 arg4 = (int)(SWIG_As_int(obj3));
11902 if (SWIG_arg_fail(4)) SWIG_fail;
11903 }
11904 }
11905 {
11906 PyThreadState* __tstate = wxPyBeginAllowThreads();
11907 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
11908
11909 wxPyEndAllowThreads(__tstate);
11910 if (PyErr_Occurred()) SWIG_fail;
11911 }
11912 {
11913 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11914 }
11915 {
11916 if (temp2)
11917 delete arg2;
11918 }
11919 return resultobj;
11920 fail:
11921 {
11922 if (temp2)
11923 delete arg2;
11924 }
11925 return NULL;
11926 }
11927
11928
11929 static PyObject *_wrap_Image_LoadMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
11930 PyObject *resultobj;
11931 wxImage *arg1 = (wxImage *) 0 ;
11932 wxString *arg2 = 0 ;
11933 wxString *arg3 = 0 ;
11934 int arg4 = (int) -1 ;
11935 bool result;
11936 bool temp2 = false ;
11937 bool temp3 = false ;
11938 PyObject * obj0 = 0 ;
11939 PyObject * obj1 = 0 ;
11940 PyObject * obj2 = 0 ;
11941 PyObject * obj3 = 0 ;
11942 char *kwnames[] = {
11943 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
11944 };
11945
11946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
11947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
11948 if (SWIG_arg_fail(1)) SWIG_fail;
11949 {
11950 arg2 = wxString_in_helper(obj1);
11951 if (arg2 == NULL) SWIG_fail;
11952 temp2 = true;
11953 }
11954 {
11955 arg3 = wxString_in_helper(obj2);
11956 if (arg3 == NULL) SWIG_fail;
11957 temp3 = true;
11958 }
11959 if (obj3) {
11960 {
11961 arg4 = (int)(SWIG_As_int(obj3));
11962 if (SWIG_arg_fail(4)) SWIG_fail;
11963 }
11964 }
11965 {
11966 PyThreadState* __tstate = wxPyBeginAllowThreads();
11967 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
11968
11969 wxPyEndAllowThreads(__tstate);
11970 if (PyErr_Occurred()) SWIG_fail;
11971 }
11972 {
11973 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11974 }
11975 {
11976 if (temp2)
11977 delete arg2;
11978 }
11979 {
11980 if (temp3)
11981 delete arg3;
11982 }
11983 return resultobj;
11984 fail:
11985 {
11986 if (temp2)
11987 delete arg2;
11988 }
11989 {
11990 if (temp3)
11991 delete arg3;
11992 }
11993 return NULL;
11994 }
11995
11996
11997 static PyObject *_wrap_Image_SaveFile(PyObject *, PyObject *args, PyObject *kwargs) {
11998 PyObject *resultobj;
11999 wxImage *arg1 = (wxImage *) 0 ;
12000 wxString *arg2 = 0 ;
12001 int arg3 ;
12002 bool result;
12003 bool temp2 = false ;
12004 PyObject * obj0 = 0 ;
12005 PyObject * obj1 = 0 ;
12006 PyObject * obj2 = 0 ;
12007 char *kwnames[] = {
12008 (char *) "self",(char *) "name",(char *) "type", NULL
12009 };
12010
12011 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12012 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12013 if (SWIG_arg_fail(1)) SWIG_fail;
12014 {
12015 arg2 = wxString_in_helper(obj1);
12016 if (arg2 == NULL) SWIG_fail;
12017 temp2 = true;
12018 }
12019 {
12020 arg3 = (int)(SWIG_As_int(obj2));
12021 if (SWIG_arg_fail(3)) SWIG_fail;
12022 }
12023 {
12024 PyThreadState* __tstate = wxPyBeginAllowThreads();
12025 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
12026
12027 wxPyEndAllowThreads(__tstate);
12028 if (PyErr_Occurred()) SWIG_fail;
12029 }
12030 {
12031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12032 }
12033 {
12034 if (temp2)
12035 delete arg2;
12036 }
12037 return resultobj;
12038 fail:
12039 {
12040 if (temp2)
12041 delete arg2;
12042 }
12043 return NULL;
12044 }
12045
12046
12047 static PyObject *_wrap_Image_SaveMimeFile(PyObject *, PyObject *args, PyObject *kwargs) {
12048 PyObject *resultobj;
12049 wxImage *arg1 = (wxImage *) 0 ;
12050 wxString *arg2 = 0 ;
12051 wxString *arg3 = 0 ;
12052 bool result;
12053 bool temp2 = false ;
12054 bool temp3 = false ;
12055 PyObject * obj0 = 0 ;
12056 PyObject * obj1 = 0 ;
12057 PyObject * obj2 = 0 ;
12058 char *kwnames[] = {
12059 (char *) "self",(char *) "name",(char *) "mimetype", NULL
12060 };
12061
12062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) goto fail;
12063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12064 if (SWIG_arg_fail(1)) SWIG_fail;
12065 {
12066 arg2 = wxString_in_helper(obj1);
12067 if (arg2 == NULL) SWIG_fail;
12068 temp2 = true;
12069 }
12070 {
12071 arg3 = wxString_in_helper(obj2);
12072 if (arg3 == NULL) SWIG_fail;
12073 temp3 = true;
12074 }
12075 {
12076 PyThreadState* __tstate = wxPyBeginAllowThreads();
12077 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
12078
12079 wxPyEndAllowThreads(__tstate);
12080 if (PyErr_Occurred()) SWIG_fail;
12081 }
12082 {
12083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12084 }
12085 {
12086 if (temp2)
12087 delete arg2;
12088 }
12089 {
12090 if (temp3)
12091 delete arg3;
12092 }
12093 return resultobj;
12094 fail:
12095 {
12096 if (temp2)
12097 delete arg2;
12098 }
12099 {
12100 if (temp3)
12101 delete arg3;
12102 }
12103 return NULL;
12104 }
12105
12106
12107 static PyObject *_wrap_Image_CanReadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12108 PyObject *resultobj;
12109 wxInputStream *arg1 = 0 ;
12110 bool result;
12111 wxPyInputStream *temp1 ;
12112 bool created1 ;
12113 PyObject * obj0 = 0 ;
12114 char *kwnames[] = {
12115 (char *) "stream", NULL
12116 };
12117
12118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) goto fail;
12119 {
12120 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12121 arg1 = temp1->m_wxis;
12122 created1 = false;
12123 } else {
12124 PyErr_Clear(); // clear the failure of the wxPyConvert above
12125 arg1 = wxPyCBInputStream_create(obj0, false);
12126 if (arg1 == NULL) {
12127 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12128 SWIG_fail;
12129 }
12130 created1 = true;
12131 }
12132 }
12133 {
12134 PyThreadState* __tstate = wxPyBeginAllowThreads();
12135 result = (bool)wxImage::CanRead(*arg1);
12136
12137 wxPyEndAllowThreads(__tstate);
12138 if (PyErr_Occurred()) SWIG_fail;
12139 }
12140 {
12141 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12142 }
12143 {
12144 if (created1) delete arg1;
12145 }
12146 return resultobj;
12147 fail:
12148 {
12149 if (created1) delete arg1;
12150 }
12151 return NULL;
12152 }
12153
12154
12155 static PyObject *_wrap_Image_LoadStream(PyObject *, PyObject *args, PyObject *kwargs) {
12156 PyObject *resultobj;
12157 wxImage *arg1 = (wxImage *) 0 ;
12158 wxInputStream *arg2 = 0 ;
12159 long arg3 = (long) wxBITMAP_TYPE_ANY ;
12160 int arg4 = (int) -1 ;
12161 bool result;
12162 wxPyInputStream *temp2 ;
12163 bool created2 ;
12164 PyObject * obj0 = 0 ;
12165 PyObject * obj1 = 0 ;
12166 PyObject * obj2 = 0 ;
12167 PyObject * obj3 = 0 ;
12168 char *kwnames[] = {
12169 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
12170 };
12171
12172 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12173 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12174 if (SWIG_arg_fail(1)) SWIG_fail;
12175 {
12176 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12177 arg2 = temp2->m_wxis;
12178 created2 = false;
12179 } else {
12180 PyErr_Clear(); // clear the failure of the wxPyConvert above
12181 arg2 = wxPyCBInputStream_create(obj1, false);
12182 if (arg2 == NULL) {
12183 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12184 SWIG_fail;
12185 }
12186 created2 = true;
12187 }
12188 }
12189 if (obj2) {
12190 {
12191 arg3 = (long)(SWIG_As_long(obj2));
12192 if (SWIG_arg_fail(3)) SWIG_fail;
12193 }
12194 }
12195 if (obj3) {
12196 {
12197 arg4 = (int)(SWIG_As_int(obj3));
12198 if (SWIG_arg_fail(4)) SWIG_fail;
12199 }
12200 }
12201 {
12202 PyThreadState* __tstate = wxPyBeginAllowThreads();
12203 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
12204
12205 wxPyEndAllowThreads(__tstate);
12206 if (PyErr_Occurred()) SWIG_fail;
12207 }
12208 {
12209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12210 }
12211 {
12212 if (created2) delete arg2;
12213 }
12214 return resultobj;
12215 fail:
12216 {
12217 if (created2) delete arg2;
12218 }
12219 return NULL;
12220 }
12221
12222
12223 static PyObject *_wrap_Image_LoadMimeStream(PyObject *, PyObject *args, PyObject *kwargs) {
12224 PyObject *resultobj;
12225 wxImage *arg1 = (wxImage *) 0 ;
12226 wxInputStream *arg2 = 0 ;
12227 wxString *arg3 = 0 ;
12228 int arg4 = (int) -1 ;
12229 bool result;
12230 wxPyInputStream *temp2 ;
12231 bool created2 ;
12232 bool temp3 = false ;
12233 PyObject * obj0 = 0 ;
12234 PyObject * obj1 = 0 ;
12235 PyObject * obj2 = 0 ;
12236 PyObject * obj3 = 0 ;
12237 char *kwnames[] = {
12238 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
12239 };
12240
12241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12243 if (SWIG_arg_fail(1)) SWIG_fail;
12244 {
12245 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
12246 arg2 = temp2->m_wxis;
12247 created2 = false;
12248 } else {
12249 PyErr_Clear(); // clear the failure of the wxPyConvert above
12250 arg2 = wxPyCBInputStream_create(obj1, false);
12251 if (arg2 == NULL) {
12252 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12253 SWIG_fail;
12254 }
12255 created2 = true;
12256 }
12257 }
12258 {
12259 arg3 = wxString_in_helper(obj2);
12260 if (arg3 == NULL) SWIG_fail;
12261 temp3 = true;
12262 }
12263 if (obj3) {
12264 {
12265 arg4 = (int)(SWIG_As_int(obj3));
12266 if (SWIG_arg_fail(4)) SWIG_fail;
12267 }
12268 }
12269 {
12270 PyThreadState* __tstate = wxPyBeginAllowThreads();
12271 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
12272
12273 wxPyEndAllowThreads(__tstate);
12274 if (PyErr_Occurred()) SWIG_fail;
12275 }
12276 {
12277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12278 }
12279 {
12280 if (created2) delete arg2;
12281 }
12282 {
12283 if (temp3)
12284 delete arg3;
12285 }
12286 return resultobj;
12287 fail:
12288 {
12289 if (created2) delete arg2;
12290 }
12291 {
12292 if (temp3)
12293 delete arg3;
12294 }
12295 return NULL;
12296 }
12297
12298
12299 static PyObject *_wrap_Image_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
12300 PyObject *resultobj;
12301 wxImage *arg1 = (wxImage *) 0 ;
12302 bool result;
12303 PyObject * obj0 = 0 ;
12304 char *kwnames[] = {
12305 (char *) "self", NULL
12306 };
12307
12308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Ok",kwnames,&obj0)) goto fail;
12309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12310 if (SWIG_arg_fail(1)) SWIG_fail;
12311 {
12312 PyThreadState* __tstate = wxPyBeginAllowThreads();
12313 result = (bool)(arg1)->Ok();
12314
12315 wxPyEndAllowThreads(__tstate);
12316 if (PyErr_Occurred()) SWIG_fail;
12317 }
12318 {
12319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12320 }
12321 return resultobj;
12322 fail:
12323 return NULL;
12324 }
12325
12326
12327 static PyObject *_wrap_Image_GetWidth(PyObject *, PyObject *args, PyObject *kwargs) {
12328 PyObject *resultobj;
12329 wxImage *arg1 = (wxImage *) 0 ;
12330 int result;
12331 PyObject * obj0 = 0 ;
12332 char *kwnames[] = {
12333 (char *) "self", NULL
12334 };
12335
12336 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetWidth",kwnames,&obj0)) goto fail;
12337 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12338 if (SWIG_arg_fail(1)) SWIG_fail;
12339 {
12340 PyThreadState* __tstate = wxPyBeginAllowThreads();
12341 result = (int)(arg1)->GetWidth();
12342
12343 wxPyEndAllowThreads(__tstate);
12344 if (PyErr_Occurred()) SWIG_fail;
12345 }
12346 {
12347 resultobj = SWIG_From_int((int)(result));
12348 }
12349 return resultobj;
12350 fail:
12351 return NULL;
12352 }
12353
12354
12355 static PyObject *_wrap_Image_GetHeight(PyObject *, PyObject *args, PyObject *kwargs) {
12356 PyObject *resultobj;
12357 wxImage *arg1 = (wxImage *) 0 ;
12358 int result;
12359 PyObject * obj0 = 0 ;
12360 char *kwnames[] = {
12361 (char *) "self", NULL
12362 };
12363
12364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetHeight",kwnames,&obj0)) goto fail;
12365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12366 if (SWIG_arg_fail(1)) SWIG_fail;
12367 {
12368 PyThreadState* __tstate = wxPyBeginAllowThreads();
12369 result = (int)(arg1)->GetHeight();
12370
12371 wxPyEndAllowThreads(__tstate);
12372 if (PyErr_Occurred()) SWIG_fail;
12373 }
12374 {
12375 resultobj = SWIG_From_int((int)(result));
12376 }
12377 return resultobj;
12378 fail:
12379 return NULL;
12380 }
12381
12382
12383 static PyObject *_wrap_Image_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
12384 PyObject *resultobj;
12385 wxImage *arg1 = (wxImage *) 0 ;
12386 wxSize result;
12387 PyObject * obj0 = 0 ;
12388 char *kwnames[] = {
12389 (char *) "self", NULL
12390 };
12391
12392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetSize",kwnames,&obj0)) goto fail;
12393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12394 if (SWIG_arg_fail(1)) SWIG_fail;
12395 {
12396 PyThreadState* __tstate = wxPyBeginAllowThreads();
12397 result = wxImage_GetSize(arg1);
12398
12399 wxPyEndAllowThreads(__tstate);
12400 if (PyErr_Occurred()) SWIG_fail;
12401 }
12402 {
12403 wxSize * resultptr;
12404 resultptr = new wxSize((wxSize &)(result));
12405 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
12406 }
12407 return resultobj;
12408 fail:
12409 return NULL;
12410 }
12411
12412
12413 static PyObject *_wrap_Image_GetSubImage(PyObject *, PyObject *args, PyObject *kwargs) {
12414 PyObject *resultobj;
12415 wxImage *arg1 = (wxImage *) 0 ;
12416 wxRect *arg2 = 0 ;
12417 SwigValueWrapper<wxImage > result;
12418 wxRect temp2 ;
12419 PyObject * obj0 = 0 ;
12420 PyObject * obj1 = 0 ;
12421 char *kwnames[] = {
12422 (char *) "self",(char *) "rect", NULL
12423 };
12424
12425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) goto fail;
12426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12427 if (SWIG_arg_fail(1)) SWIG_fail;
12428 {
12429 arg2 = &temp2;
12430 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
12431 }
12432 {
12433 PyThreadState* __tstate = wxPyBeginAllowThreads();
12434 result = (arg1)->GetSubImage((wxRect const &)*arg2);
12435
12436 wxPyEndAllowThreads(__tstate);
12437 if (PyErr_Occurred()) SWIG_fail;
12438 }
12439 {
12440 wxImage * resultptr;
12441 resultptr = new wxImage((wxImage &)(result));
12442 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12443 }
12444 return resultobj;
12445 fail:
12446 return NULL;
12447 }
12448
12449
12450 static PyObject *_wrap_Image_Size(PyObject *, PyObject *args, PyObject *kwargs) {
12451 PyObject *resultobj;
12452 wxImage *arg1 = (wxImage *) 0 ;
12453 wxSize *arg2 = 0 ;
12454 wxPoint *arg3 = 0 ;
12455 int arg4 = (int) -1 ;
12456 int arg5 = (int) -1 ;
12457 int arg6 = (int) -1 ;
12458 SwigValueWrapper<wxImage > result;
12459 wxSize temp2 ;
12460 wxPoint temp3 ;
12461 PyObject * obj0 = 0 ;
12462 PyObject * obj1 = 0 ;
12463 PyObject * obj2 = 0 ;
12464 PyObject * obj3 = 0 ;
12465 PyObject * obj4 = 0 ;
12466 PyObject * obj5 = 0 ;
12467 char *kwnames[] = {
12468 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
12469 };
12470
12471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
12472 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12473 if (SWIG_arg_fail(1)) SWIG_fail;
12474 {
12475 arg2 = &temp2;
12476 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
12477 }
12478 {
12479 arg3 = &temp3;
12480 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
12481 }
12482 if (obj3) {
12483 {
12484 arg4 = (int)(SWIG_As_int(obj3));
12485 if (SWIG_arg_fail(4)) SWIG_fail;
12486 }
12487 }
12488 if (obj4) {
12489 {
12490 arg5 = (int)(SWIG_As_int(obj4));
12491 if (SWIG_arg_fail(5)) SWIG_fail;
12492 }
12493 }
12494 if (obj5) {
12495 {
12496 arg6 = (int)(SWIG_As_int(obj5));
12497 if (SWIG_arg_fail(6)) SWIG_fail;
12498 }
12499 }
12500 {
12501 PyThreadState* __tstate = wxPyBeginAllowThreads();
12502 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
12503
12504 wxPyEndAllowThreads(__tstate);
12505 if (PyErr_Occurred()) SWIG_fail;
12506 }
12507 {
12508 wxImage * resultptr;
12509 resultptr = new wxImage((wxImage &)(result));
12510 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12511 }
12512 return resultobj;
12513 fail:
12514 return NULL;
12515 }
12516
12517
12518 static PyObject *_wrap_Image_Copy(PyObject *, PyObject *args, PyObject *kwargs) {
12519 PyObject *resultobj;
12520 wxImage *arg1 = (wxImage *) 0 ;
12521 SwigValueWrapper<wxImage > result;
12522 PyObject * obj0 = 0 ;
12523 char *kwnames[] = {
12524 (char *) "self", NULL
12525 };
12526
12527 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_Copy",kwnames,&obj0)) goto fail;
12528 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12529 if (SWIG_arg_fail(1)) SWIG_fail;
12530 {
12531 PyThreadState* __tstate = wxPyBeginAllowThreads();
12532 result = (arg1)->Copy();
12533
12534 wxPyEndAllowThreads(__tstate);
12535 if (PyErr_Occurred()) SWIG_fail;
12536 }
12537 {
12538 wxImage * resultptr;
12539 resultptr = new wxImage((wxImage &)(result));
12540 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
12541 }
12542 return resultobj;
12543 fail:
12544 return NULL;
12545 }
12546
12547
12548 static PyObject *_wrap_Image_Paste(PyObject *, PyObject *args, PyObject *kwargs) {
12549 PyObject *resultobj;
12550 wxImage *arg1 = (wxImage *) 0 ;
12551 wxImage *arg2 = 0 ;
12552 int arg3 ;
12553 int arg4 ;
12554 PyObject * obj0 = 0 ;
12555 PyObject * obj1 = 0 ;
12556 PyObject * obj2 = 0 ;
12557 PyObject * obj3 = 0 ;
12558 char *kwnames[] = {
12559 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
12560 };
12561
12562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12564 if (SWIG_arg_fail(1)) SWIG_fail;
12565 {
12566 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12567 if (SWIG_arg_fail(2)) SWIG_fail;
12568 if (arg2 == NULL) {
12569 SWIG_null_ref("wxImage");
12570 }
12571 if (SWIG_arg_fail(2)) SWIG_fail;
12572 }
12573 {
12574 arg3 = (int)(SWIG_As_int(obj2));
12575 if (SWIG_arg_fail(3)) SWIG_fail;
12576 }
12577 {
12578 arg4 = (int)(SWIG_As_int(obj3));
12579 if (SWIG_arg_fail(4)) SWIG_fail;
12580 }
12581 {
12582 PyThreadState* __tstate = wxPyBeginAllowThreads();
12583 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
12584
12585 wxPyEndAllowThreads(__tstate);
12586 if (PyErr_Occurred()) SWIG_fail;
12587 }
12588 Py_INCREF(Py_None); resultobj = Py_None;
12589 return resultobj;
12590 fail:
12591 return NULL;
12592 }
12593
12594
12595 static PyObject *_wrap_Image_GetData(PyObject *, PyObject *args, PyObject *kwargs) {
12596 PyObject *resultobj;
12597 wxImage *arg1 = (wxImage *) 0 ;
12598 PyObject *result;
12599 PyObject * obj0 = 0 ;
12600 char *kwnames[] = {
12601 (char *) "self", NULL
12602 };
12603
12604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetData",kwnames,&obj0)) goto fail;
12605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12606 if (SWIG_arg_fail(1)) SWIG_fail;
12607 {
12608 PyThreadState* __tstate = wxPyBeginAllowThreads();
12609 result = (PyObject *)wxImage_GetData(arg1);
12610
12611 wxPyEndAllowThreads(__tstate);
12612 if (PyErr_Occurred()) SWIG_fail;
12613 }
12614 resultobj = result;
12615 return resultobj;
12616 fail:
12617 return NULL;
12618 }
12619
12620
12621 static PyObject *_wrap_Image_SetData(PyObject *, PyObject *args, PyObject *kwargs) {
12622 PyObject *resultobj;
12623 wxImage *arg1 = (wxImage *) 0 ;
12624 buffer arg2 ;
12625 int arg3 ;
12626 PyObject * obj0 = 0 ;
12627 PyObject * obj1 = 0 ;
12628 char *kwnames[] = {
12629 (char *) "self",(char *) "data", NULL
12630 };
12631
12632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) goto fail;
12633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12634 if (SWIG_arg_fail(1)) SWIG_fail;
12635 {
12636 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12637 }
12638 {
12639 PyThreadState* __tstate = wxPyBeginAllowThreads();
12640 wxImage_SetData(arg1,arg2,arg3);
12641
12642 wxPyEndAllowThreads(__tstate);
12643 if (PyErr_Occurred()) SWIG_fail;
12644 }
12645 Py_INCREF(Py_None); resultobj = Py_None;
12646 return resultobj;
12647 fail:
12648 return NULL;
12649 }
12650
12651
12652 static PyObject *_wrap_Image_GetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12653 PyObject *resultobj;
12654 wxImage *arg1 = (wxImage *) 0 ;
12655 PyObject *result;
12656 PyObject * obj0 = 0 ;
12657 char *kwnames[] = {
12658 (char *) "self", NULL
12659 };
12660
12661 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetDataBuffer",kwnames,&obj0)) goto fail;
12662 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12663 if (SWIG_arg_fail(1)) SWIG_fail;
12664 {
12665 PyThreadState* __tstate = wxPyBeginAllowThreads();
12666 result = (PyObject *)wxImage_GetDataBuffer(arg1);
12667
12668 wxPyEndAllowThreads(__tstate);
12669 if (PyErr_Occurred()) SWIG_fail;
12670 }
12671 resultobj = result;
12672 return resultobj;
12673 fail:
12674 return NULL;
12675 }
12676
12677
12678 static PyObject *_wrap_Image_SetDataBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12679 PyObject *resultobj;
12680 wxImage *arg1 = (wxImage *) 0 ;
12681 buffer arg2 ;
12682 int arg3 ;
12683 PyObject * obj0 = 0 ;
12684 PyObject * obj1 = 0 ;
12685 char *kwnames[] = {
12686 (char *) "self",(char *) "data", NULL
12687 };
12688
12689 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) goto fail;
12690 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12691 if (SWIG_arg_fail(1)) SWIG_fail;
12692 {
12693 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12694 }
12695 {
12696 PyThreadState* __tstate = wxPyBeginAllowThreads();
12697 wxImage_SetDataBuffer(arg1,arg2,arg3);
12698
12699 wxPyEndAllowThreads(__tstate);
12700 if (PyErr_Occurred()) SWIG_fail;
12701 }
12702 Py_INCREF(Py_None); resultobj = Py_None;
12703 return resultobj;
12704 fail:
12705 return NULL;
12706 }
12707
12708
12709 static PyObject *_wrap_Image_GetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12710 PyObject *resultobj;
12711 wxImage *arg1 = (wxImage *) 0 ;
12712 PyObject *result;
12713 PyObject * obj0 = 0 ;
12714 char *kwnames[] = {
12715 (char *) "self", NULL
12716 };
12717
12718 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaData",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 = (PyObject *)wxImage_GetAlphaData(arg1);
12724
12725 wxPyEndAllowThreads(__tstate);
12726 if (PyErr_Occurred()) SWIG_fail;
12727 }
12728 resultobj = result;
12729 return resultobj;
12730 fail:
12731 return NULL;
12732 }
12733
12734
12735 static PyObject *_wrap_Image_SetAlphaData(PyObject *, PyObject *args, PyObject *kwargs) {
12736 PyObject *resultobj;
12737 wxImage *arg1 = (wxImage *) 0 ;
12738 buffer arg2 ;
12739 int arg3 ;
12740 PyObject * obj0 = 0 ;
12741 PyObject * obj1 = 0 ;
12742 char *kwnames[] = {
12743 (char *) "self",(char *) "alpha", NULL
12744 };
12745
12746 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) 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 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12751 }
12752 {
12753 PyThreadState* __tstate = wxPyBeginAllowThreads();
12754 wxImage_SetAlphaData(arg1,arg2,arg3);
12755
12756 wxPyEndAllowThreads(__tstate);
12757 if (PyErr_Occurred()) SWIG_fail;
12758 }
12759 Py_INCREF(Py_None); resultobj = Py_None;
12760 return resultobj;
12761 fail:
12762 return NULL;
12763 }
12764
12765
12766 static PyObject *_wrap_Image_GetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12767 PyObject *resultobj;
12768 wxImage *arg1 = (wxImage *) 0 ;
12769 PyObject *result;
12770 PyObject * obj0 = 0 ;
12771 char *kwnames[] = {
12772 (char *) "self", NULL
12773 };
12774
12775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetAlphaBuffer",kwnames,&obj0)) goto fail;
12776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12777 if (SWIG_arg_fail(1)) SWIG_fail;
12778 {
12779 PyThreadState* __tstate = wxPyBeginAllowThreads();
12780 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
12781
12782 wxPyEndAllowThreads(__tstate);
12783 if (PyErr_Occurred()) SWIG_fail;
12784 }
12785 resultobj = result;
12786 return resultobj;
12787 fail:
12788 return NULL;
12789 }
12790
12791
12792 static PyObject *_wrap_Image_SetAlphaBuffer(PyObject *, PyObject *args, PyObject *kwargs) {
12793 PyObject *resultobj;
12794 wxImage *arg1 = (wxImage *) 0 ;
12795 buffer arg2 ;
12796 int arg3 ;
12797 PyObject * obj0 = 0 ;
12798 PyObject * obj1 = 0 ;
12799 char *kwnames[] = {
12800 (char *) "self",(char *) "alpha", NULL
12801 };
12802
12803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) goto fail;
12804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12805 if (SWIG_arg_fail(1)) SWIG_fail;
12806 {
12807 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
12808 }
12809 {
12810 PyThreadState* __tstate = wxPyBeginAllowThreads();
12811 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
12812
12813 wxPyEndAllowThreads(__tstate);
12814 if (PyErr_Occurred()) SWIG_fail;
12815 }
12816 Py_INCREF(Py_None); resultobj = Py_None;
12817 return resultobj;
12818 fail:
12819 return NULL;
12820 }
12821
12822
12823 static PyObject *_wrap_Image_SetMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12824 PyObject *resultobj;
12825 wxImage *arg1 = (wxImage *) 0 ;
12826 unsigned char arg2 ;
12827 unsigned char arg3 ;
12828 unsigned char arg4 ;
12829 PyObject * obj0 = 0 ;
12830 PyObject * obj1 = 0 ;
12831 PyObject * obj2 = 0 ;
12832 PyObject * obj3 = 0 ;
12833 char *kwnames[] = {
12834 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12835 };
12836
12837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
12838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12839 if (SWIG_arg_fail(1)) SWIG_fail;
12840 {
12841 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
12842 if (SWIG_arg_fail(2)) SWIG_fail;
12843 }
12844 {
12845 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
12846 if (SWIG_arg_fail(3)) SWIG_fail;
12847 }
12848 {
12849 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
12850 if (SWIG_arg_fail(4)) SWIG_fail;
12851 }
12852 {
12853 PyThreadState* __tstate = wxPyBeginAllowThreads();
12854 (arg1)->SetMaskColour(arg2,arg3,arg4);
12855
12856 wxPyEndAllowThreads(__tstate);
12857 if (PyErr_Occurred()) SWIG_fail;
12858 }
12859 Py_INCREF(Py_None); resultobj = Py_None;
12860 return resultobj;
12861 fail:
12862 return NULL;
12863 }
12864
12865
12866 static PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *, PyObject *args, PyObject *kwargs) {
12867 PyObject *resultobj;
12868 wxImage *arg1 = (wxImage *) 0 ;
12869 unsigned char *arg2 = (unsigned char *) 0 ;
12870 unsigned char *arg3 = (unsigned char *) 0 ;
12871 unsigned char *arg4 = (unsigned char *) 0 ;
12872 unsigned char temp2 ;
12873 int res2 = 0 ;
12874 unsigned char temp3 ;
12875 int res3 = 0 ;
12876 unsigned char temp4 ;
12877 int res4 = 0 ;
12878 PyObject * obj0 = 0 ;
12879 char *kwnames[] = {
12880 (char *) "self", NULL
12881 };
12882
12883 arg2 = &temp2; res2 = SWIG_NEWOBJ;
12884 arg3 = &temp3; res3 = SWIG_NEWOBJ;
12885 arg4 = &temp4; res4 = SWIG_NEWOBJ;
12886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetOrFindMaskColour",kwnames,&obj0)) goto fail;
12887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12888 if (SWIG_arg_fail(1)) SWIG_fail;
12889 {
12890 PyThreadState* __tstate = wxPyBeginAllowThreads();
12891 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
12892
12893 wxPyEndAllowThreads(__tstate);
12894 if (PyErr_Occurred()) SWIG_fail;
12895 }
12896 Py_INCREF(Py_None); resultobj = Py_None;
12897 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
12898 SWIG_From_unsigned_SS_char((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, 0)));
12899 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
12900 SWIG_From_unsigned_SS_char((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, 0)));
12901 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
12902 SWIG_From_unsigned_SS_char((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, 0)));
12903 return resultobj;
12904 fail:
12905 return NULL;
12906 }
12907
12908
12909 static PyObject *_wrap_Image_GetMaskRed(PyObject *, PyObject *args, PyObject *kwargs) {
12910 PyObject *resultobj;
12911 wxImage *arg1 = (wxImage *) 0 ;
12912 unsigned char result;
12913 PyObject * obj0 = 0 ;
12914 char *kwnames[] = {
12915 (char *) "self", NULL
12916 };
12917
12918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskRed",kwnames,&obj0)) goto fail;
12919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12920 if (SWIG_arg_fail(1)) SWIG_fail;
12921 {
12922 PyThreadState* __tstate = wxPyBeginAllowThreads();
12923 result = (unsigned char)(arg1)->GetMaskRed();
12924
12925 wxPyEndAllowThreads(__tstate);
12926 if (PyErr_Occurred()) SWIG_fail;
12927 }
12928 {
12929 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12930 }
12931 return resultobj;
12932 fail:
12933 return NULL;
12934 }
12935
12936
12937 static PyObject *_wrap_Image_GetMaskGreen(PyObject *, PyObject *args, PyObject *kwargs) {
12938 PyObject *resultobj;
12939 wxImage *arg1 = (wxImage *) 0 ;
12940 unsigned char result;
12941 PyObject * obj0 = 0 ;
12942 char *kwnames[] = {
12943 (char *) "self", NULL
12944 };
12945
12946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskGreen",kwnames,&obj0)) goto fail;
12947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12948 if (SWIG_arg_fail(1)) SWIG_fail;
12949 {
12950 PyThreadState* __tstate = wxPyBeginAllowThreads();
12951 result = (unsigned char)(arg1)->GetMaskGreen();
12952
12953 wxPyEndAllowThreads(__tstate);
12954 if (PyErr_Occurred()) SWIG_fail;
12955 }
12956 {
12957 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12958 }
12959 return resultobj;
12960 fail:
12961 return NULL;
12962 }
12963
12964
12965 static PyObject *_wrap_Image_GetMaskBlue(PyObject *, PyObject *args, PyObject *kwargs) {
12966 PyObject *resultobj;
12967 wxImage *arg1 = (wxImage *) 0 ;
12968 unsigned char result;
12969 PyObject * obj0 = 0 ;
12970 char *kwnames[] = {
12971 (char *) "self", NULL
12972 };
12973
12974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_GetMaskBlue",kwnames,&obj0)) goto fail;
12975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
12976 if (SWIG_arg_fail(1)) SWIG_fail;
12977 {
12978 PyThreadState* __tstate = wxPyBeginAllowThreads();
12979 result = (unsigned char)(arg1)->GetMaskBlue();
12980
12981 wxPyEndAllowThreads(__tstate);
12982 if (PyErr_Occurred()) SWIG_fail;
12983 }
12984 {
12985 resultobj = SWIG_From_unsigned_SS_char((unsigned char)(result));
12986 }
12987 return resultobj;
12988 fail:
12989 return NULL;
12990 }
12991
12992
12993 static PyObject *_wrap_Image_SetMask(PyObject *, PyObject *args, PyObject *kwargs) {
12994 PyObject *resultobj;
12995 wxImage *arg1 = (wxImage *) 0 ;
12996 bool arg2 = (bool) true ;
12997 PyObject * obj0 = 0 ;
12998 PyObject * obj1 = 0 ;
12999 char *kwnames[] = {
13000 (char *) "self",(char *) "mask", NULL
13001 };
13002
13003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) goto fail;
13004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13005 if (SWIG_arg_fail(1)) SWIG_fail;
13006 if (obj1) {
13007 {
13008 arg2 = (bool)(SWIG_As_bool(obj1));
13009 if (SWIG_arg_fail(2)) SWIG_fail;
13010 }
13011 }
13012 {
13013 PyThreadState* __tstate = wxPyBeginAllowThreads();
13014 (arg1)->SetMask(arg2);
13015
13016 wxPyEndAllowThreads(__tstate);
13017 if (PyErr_Occurred()) SWIG_fail;
13018 }
13019 Py_INCREF(Py_None); resultobj = Py_None;
13020 return resultobj;
13021 fail:
13022 return NULL;
13023 }
13024
13025
13026 static PyObject *_wrap_Image_HasMask(PyObject *, PyObject *args, PyObject *kwargs) {
13027 PyObject *resultobj;
13028 wxImage *arg1 = (wxImage *) 0 ;
13029 bool result;
13030 PyObject * obj0 = 0 ;
13031 char *kwnames[] = {
13032 (char *) "self", NULL
13033 };
13034
13035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HasMask",kwnames,&obj0)) goto fail;
13036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13037 if (SWIG_arg_fail(1)) SWIG_fail;
13038 {
13039 PyThreadState* __tstate = wxPyBeginAllowThreads();
13040 result = (bool)(arg1)->HasMask();
13041
13042 wxPyEndAllowThreads(__tstate);
13043 if (PyErr_Occurred()) SWIG_fail;
13044 }
13045 {
13046 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13047 }
13048 return resultobj;
13049 fail:
13050 return NULL;
13051 }
13052
13053
13054 static PyObject *_wrap_Image_Rotate(PyObject *, PyObject *args, PyObject *kwargs) {
13055 PyObject *resultobj;
13056 wxImage *arg1 = (wxImage *) 0 ;
13057 double arg2 ;
13058 wxPoint *arg3 = 0 ;
13059 bool arg4 = (bool) true ;
13060 wxPoint *arg5 = (wxPoint *) NULL ;
13061 SwigValueWrapper<wxImage > result;
13062 wxPoint temp3 ;
13063 PyObject * obj0 = 0 ;
13064 PyObject * obj1 = 0 ;
13065 PyObject * obj2 = 0 ;
13066 PyObject * obj3 = 0 ;
13067 PyObject * obj4 = 0 ;
13068 char *kwnames[] = {
13069 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
13070 };
13071
13072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
13073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13074 if (SWIG_arg_fail(1)) SWIG_fail;
13075 {
13076 arg2 = (double)(SWIG_As_double(obj1));
13077 if (SWIG_arg_fail(2)) SWIG_fail;
13078 }
13079 {
13080 arg3 = &temp3;
13081 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13082 }
13083 if (obj3) {
13084 {
13085 arg4 = (bool)(SWIG_As_bool(obj3));
13086 if (SWIG_arg_fail(4)) SWIG_fail;
13087 }
13088 }
13089 if (obj4) {
13090 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION | 0);
13091 if (SWIG_arg_fail(5)) SWIG_fail;
13092 }
13093 {
13094 PyThreadState* __tstate = wxPyBeginAllowThreads();
13095 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
13096
13097 wxPyEndAllowThreads(__tstate);
13098 if (PyErr_Occurred()) SWIG_fail;
13099 }
13100 {
13101 wxImage * resultptr;
13102 resultptr = new wxImage((wxImage &)(result));
13103 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13104 }
13105 return resultobj;
13106 fail:
13107 return NULL;
13108 }
13109
13110
13111 static PyObject *_wrap_Image_Rotate90(PyObject *, PyObject *args, PyObject *kwargs) {
13112 PyObject *resultobj;
13113 wxImage *arg1 = (wxImage *) 0 ;
13114 bool arg2 = (bool) true ;
13115 SwigValueWrapper<wxImage > result;
13116 PyObject * obj0 = 0 ;
13117 PyObject * obj1 = 0 ;
13118 char *kwnames[] = {
13119 (char *) "self",(char *) "clockwise", NULL
13120 };
13121
13122 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) goto fail;
13123 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13124 if (SWIG_arg_fail(1)) SWIG_fail;
13125 if (obj1) {
13126 {
13127 arg2 = (bool)(SWIG_As_bool(obj1));
13128 if (SWIG_arg_fail(2)) SWIG_fail;
13129 }
13130 }
13131 {
13132 PyThreadState* __tstate = wxPyBeginAllowThreads();
13133 result = (arg1)->Rotate90(arg2);
13134
13135 wxPyEndAllowThreads(__tstate);
13136 if (PyErr_Occurred()) SWIG_fail;
13137 }
13138 {
13139 wxImage * resultptr;
13140 resultptr = new wxImage((wxImage &)(result));
13141 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13142 }
13143 return resultobj;
13144 fail:
13145 return NULL;
13146 }
13147
13148
13149 static PyObject *_wrap_Image_Mirror(PyObject *, PyObject *args, PyObject *kwargs) {
13150 PyObject *resultobj;
13151 wxImage *arg1 = (wxImage *) 0 ;
13152 bool arg2 = (bool) true ;
13153 SwigValueWrapper<wxImage > result;
13154 PyObject * obj0 = 0 ;
13155 PyObject * obj1 = 0 ;
13156 char *kwnames[] = {
13157 (char *) "self",(char *) "horizontally", NULL
13158 };
13159
13160 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) goto fail;
13161 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13162 if (SWIG_arg_fail(1)) SWIG_fail;
13163 if (obj1) {
13164 {
13165 arg2 = (bool)(SWIG_As_bool(obj1));
13166 if (SWIG_arg_fail(2)) SWIG_fail;
13167 }
13168 }
13169 {
13170 PyThreadState* __tstate = wxPyBeginAllowThreads();
13171 result = (arg1)->Mirror(arg2);
13172
13173 wxPyEndAllowThreads(__tstate);
13174 if (PyErr_Occurred()) SWIG_fail;
13175 }
13176 {
13177 wxImage * resultptr;
13178 resultptr = new wxImage((wxImage &)(result));
13179 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13180 }
13181 return resultobj;
13182 fail:
13183 return NULL;
13184 }
13185
13186
13187 static PyObject *_wrap_Image_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
13188 PyObject *resultobj;
13189 wxImage *arg1 = (wxImage *) 0 ;
13190 unsigned char arg2 ;
13191 unsigned char arg3 ;
13192 unsigned char arg4 ;
13193 unsigned char arg5 ;
13194 unsigned char arg6 ;
13195 unsigned char arg7 ;
13196 PyObject * obj0 = 0 ;
13197 PyObject * obj1 = 0 ;
13198 PyObject * obj2 = 0 ;
13199 PyObject * obj3 = 0 ;
13200 PyObject * obj4 = 0 ;
13201 PyObject * obj5 = 0 ;
13202 PyObject * obj6 = 0 ;
13203 char *kwnames[] = {
13204 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
13205 };
13206
13207 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
13208 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13209 if (SWIG_arg_fail(1)) SWIG_fail;
13210 {
13211 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13212 if (SWIG_arg_fail(2)) SWIG_fail;
13213 }
13214 {
13215 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13216 if (SWIG_arg_fail(3)) SWIG_fail;
13217 }
13218 {
13219 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13220 if (SWIG_arg_fail(4)) SWIG_fail;
13221 }
13222 {
13223 arg5 = (unsigned char)(SWIG_As_unsigned_SS_char(obj4));
13224 if (SWIG_arg_fail(5)) SWIG_fail;
13225 }
13226 {
13227 arg6 = (unsigned char)(SWIG_As_unsigned_SS_char(obj5));
13228 if (SWIG_arg_fail(6)) SWIG_fail;
13229 }
13230 {
13231 arg7 = (unsigned char)(SWIG_As_unsigned_SS_char(obj6));
13232 if (SWIG_arg_fail(7)) SWIG_fail;
13233 }
13234 {
13235 PyThreadState* __tstate = wxPyBeginAllowThreads();
13236 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
13237
13238 wxPyEndAllowThreads(__tstate);
13239 if (PyErr_Occurred()) SWIG_fail;
13240 }
13241 Py_INCREF(Py_None); resultobj = Py_None;
13242 return resultobj;
13243 fail:
13244 return NULL;
13245 }
13246
13247
13248 static PyObject *_wrap_Image_ConvertToMono(PyObject *, PyObject *args, PyObject *kwargs) {
13249 PyObject *resultobj;
13250 wxImage *arg1 = (wxImage *) 0 ;
13251 unsigned char arg2 ;
13252 unsigned char arg3 ;
13253 unsigned char arg4 ;
13254 SwigValueWrapper<wxImage > result;
13255 PyObject * obj0 = 0 ;
13256 PyObject * obj1 = 0 ;
13257 PyObject * obj2 = 0 ;
13258 PyObject * obj3 = 0 ;
13259 char *kwnames[] = {
13260 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
13261 };
13262
13263 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13264 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13265 if (SWIG_arg_fail(1)) SWIG_fail;
13266 {
13267 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13268 if (SWIG_arg_fail(2)) SWIG_fail;
13269 }
13270 {
13271 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13272 if (SWIG_arg_fail(3)) SWIG_fail;
13273 }
13274 {
13275 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13276 if (SWIG_arg_fail(4)) SWIG_fail;
13277 }
13278 {
13279 PyThreadState* __tstate = wxPyBeginAllowThreads();
13280 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
13281
13282 wxPyEndAllowThreads(__tstate);
13283 if (PyErr_Occurred()) SWIG_fail;
13284 }
13285 {
13286 wxImage * resultptr;
13287 resultptr = new wxImage((wxImage &)(result));
13288 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxImage, 1);
13289 }
13290 return resultobj;
13291 fail:
13292 return NULL;
13293 }
13294
13295
13296 static PyObject *_wrap_Image_SetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13297 PyObject *resultobj;
13298 wxImage *arg1 = (wxImage *) 0 ;
13299 wxString *arg2 = 0 ;
13300 wxString *arg3 = 0 ;
13301 bool temp2 = false ;
13302 bool temp3 = false ;
13303 PyObject * obj0 = 0 ;
13304 PyObject * obj1 = 0 ;
13305 PyObject * obj2 = 0 ;
13306 char *kwnames[] = {
13307 (char *) "self",(char *) "name",(char *) "value", NULL
13308 };
13309
13310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) goto fail;
13311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13312 if (SWIG_arg_fail(1)) SWIG_fail;
13313 {
13314 arg2 = wxString_in_helper(obj1);
13315 if (arg2 == NULL) SWIG_fail;
13316 temp2 = true;
13317 }
13318 {
13319 arg3 = wxString_in_helper(obj2);
13320 if (arg3 == NULL) SWIG_fail;
13321 temp3 = true;
13322 }
13323 {
13324 PyThreadState* __tstate = wxPyBeginAllowThreads();
13325 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
13326
13327 wxPyEndAllowThreads(__tstate);
13328 if (PyErr_Occurred()) SWIG_fail;
13329 }
13330 Py_INCREF(Py_None); resultobj = Py_None;
13331 {
13332 if (temp2)
13333 delete arg2;
13334 }
13335 {
13336 if (temp3)
13337 delete arg3;
13338 }
13339 return resultobj;
13340 fail:
13341 {
13342 if (temp2)
13343 delete arg2;
13344 }
13345 {
13346 if (temp3)
13347 delete arg3;
13348 }
13349 return NULL;
13350 }
13351
13352
13353 static PyObject *_wrap_Image_SetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13354 PyObject *resultobj;
13355 wxImage *arg1 = (wxImage *) 0 ;
13356 wxString *arg2 = 0 ;
13357 int arg3 ;
13358 bool temp2 = false ;
13359 PyObject * obj0 = 0 ;
13360 PyObject * obj1 = 0 ;
13361 PyObject * obj2 = 0 ;
13362 char *kwnames[] = {
13363 (char *) "self",(char *) "name",(char *) "value", NULL
13364 };
13365
13366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) goto fail;
13367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13368 if (SWIG_arg_fail(1)) SWIG_fail;
13369 {
13370 arg2 = wxString_in_helper(obj1);
13371 if (arg2 == NULL) SWIG_fail;
13372 temp2 = true;
13373 }
13374 {
13375 arg3 = (int)(SWIG_As_int(obj2));
13376 if (SWIG_arg_fail(3)) SWIG_fail;
13377 }
13378 {
13379 PyThreadState* __tstate = wxPyBeginAllowThreads();
13380 (arg1)->SetOption((wxString const &)*arg2,arg3);
13381
13382 wxPyEndAllowThreads(__tstate);
13383 if (PyErr_Occurred()) SWIG_fail;
13384 }
13385 Py_INCREF(Py_None); resultobj = Py_None;
13386 {
13387 if (temp2)
13388 delete arg2;
13389 }
13390 return resultobj;
13391 fail:
13392 {
13393 if (temp2)
13394 delete arg2;
13395 }
13396 return NULL;
13397 }
13398
13399
13400 static PyObject *_wrap_Image_GetOption(PyObject *, PyObject *args, PyObject *kwargs) {
13401 PyObject *resultobj;
13402 wxImage *arg1 = (wxImage *) 0 ;
13403 wxString *arg2 = 0 ;
13404 wxString result;
13405 bool temp2 = false ;
13406 PyObject * obj0 = 0 ;
13407 PyObject * obj1 = 0 ;
13408 char *kwnames[] = {
13409 (char *) "self",(char *) "name", NULL
13410 };
13411
13412 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) goto fail;
13413 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13414 if (SWIG_arg_fail(1)) SWIG_fail;
13415 {
13416 arg2 = wxString_in_helper(obj1);
13417 if (arg2 == NULL) SWIG_fail;
13418 temp2 = true;
13419 }
13420 {
13421 PyThreadState* __tstate = wxPyBeginAllowThreads();
13422 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
13423
13424 wxPyEndAllowThreads(__tstate);
13425 if (PyErr_Occurred()) SWIG_fail;
13426 }
13427 {
13428 #if wxUSE_UNICODE
13429 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13430 #else
13431 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13432 #endif
13433 }
13434 {
13435 if (temp2)
13436 delete arg2;
13437 }
13438 return resultobj;
13439 fail:
13440 {
13441 if (temp2)
13442 delete arg2;
13443 }
13444 return NULL;
13445 }
13446
13447
13448 static PyObject *_wrap_Image_GetOptionInt(PyObject *, PyObject *args, PyObject *kwargs) {
13449 PyObject *resultobj;
13450 wxImage *arg1 = (wxImage *) 0 ;
13451 wxString *arg2 = 0 ;
13452 int result;
13453 bool temp2 = false ;
13454 PyObject * obj0 = 0 ;
13455 PyObject * obj1 = 0 ;
13456 char *kwnames[] = {
13457 (char *) "self",(char *) "name", NULL
13458 };
13459
13460 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) goto fail;
13461 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13462 if (SWIG_arg_fail(1)) SWIG_fail;
13463 {
13464 arg2 = wxString_in_helper(obj1);
13465 if (arg2 == NULL) SWIG_fail;
13466 temp2 = true;
13467 }
13468 {
13469 PyThreadState* __tstate = wxPyBeginAllowThreads();
13470 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
13471
13472 wxPyEndAllowThreads(__tstate);
13473 if (PyErr_Occurred()) SWIG_fail;
13474 }
13475 {
13476 resultobj = SWIG_From_int((int)(result));
13477 }
13478 {
13479 if (temp2)
13480 delete arg2;
13481 }
13482 return resultobj;
13483 fail:
13484 {
13485 if (temp2)
13486 delete arg2;
13487 }
13488 return NULL;
13489 }
13490
13491
13492 static PyObject *_wrap_Image_HasOption(PyObject *, PyObject *args, PyObject *kwargs) {
13493 PyObject *resultobj;
13494 wxImage *arg1 = (wxImage *) 0 ;
13495 wxString *arg2 = 0 ;
13496 bool result;
13497 bool temp2 = false ;
13498 PyObject * obj0 = 0 ;
13499 PyObject * obj1 = 0 ;
13500 char *kwnames[] = {
13501 (char *) "self",(char *) "name", NULL
13502 };
13503
13504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) goto fail;
13505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13506 if (SWIG_arg_fail(1)) SWIG_fail;
13507 {
13508 arg2 = wxString_in_helper(obj1);
13509 if (arg2 == NULL) SWIG_fail;
13510 temp2 = true;
13511 }
13512 {
13513 PyThreadState* __tstate = wxPyBeginAllowThreads();
13514 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
13515
13516 wxPyEndAllowThreads(__tstate);
13517 if (PyErr_Occurred()) SWIG_fail;
13518 }
13519 {
13520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13521 }
13522 {
13523 if (temp2)
13524 delete arg2;
13525 }
13526 return resultobj;
13527 fail:
13528 {
13529 if (temp2)
13530 delete arg2;
13531 }
13532 return NULL;
13533 }
13534
13535
13536 static PyObject *_wrap_Image_CountColours(PyObject *, PyObject *args, PyObject *kwargs) {
13537 PyObject *resultobj;
13538 wxImage *arg1 = (wxImage *) 0 ;
13539 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
13540 unsigned long result;
13541 PyObject * obj0 = 0 ;
13542 PyObject * obj1 = 0 ;
13543 char *kwnames[] = {
13544 (char *) "self",(char *) "stopafter", NULL
13545 };
13546
13547 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) goto fail;
13548 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13549 if (SWIG_arg_fail(1)) SWIG_fail;
13550 if (obj1) {
13551 {
13552 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
13553 if (SWIG_arg_fail(2)) SWIG_fail;
13554 }
13555 }
13556 {
13557 PyThreadState* __tstate = wxPyBeginAllowThreads();
13558 result = (unsigned long)(arg1)->CountColours(arg2);
13559
13560 wxPyEndAllowThreads(__tstate);
13561 if (PyErr_Occurred()) SWIG_fail;
13562 }
13563 {
13564 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13565 }
13566 return resultobj;
13567 fail:
13568 return NULL;
13569 }
13570
13571
13572 static PyObject *_wrap_Image_ComputeHistogram(PyObject *, PyObject *args, PyObject *kwargs) {
13573 PyObject *resultobj;
13574 wxImage *arg1 = (wxImage *) 0 ;
13575 wxImageHistogram *arg2 = 0 ;
13576 unsigned long result;
13577 PyObject * obj0 = 0 ;
13578 PyObject * obj1 = 0 ;
13579 char *kwnames[] = {
13580 (char *) "self",(char *) "h", NULL
13581 };
13582
13583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) goto fail;
13584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13585 if (SWIG_arg_fail(1)) SWIG_fail;
13586 {
13587 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_EXCEPTION | 0);
13588 if (SWIG_arg_fail(2)) SWIG_fail;
13589 if (arg2 == NULL) {
13590 SWIG_null_ref("wxImageHistogram");
13591 }
13592 if (SWIG_arg_fail(2)) SWIG_fail;
13593 }
13594 {
13595 PyThreadState* __tstate = wxPyBeginAllowThreads();
13596 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
13597
13598 wxPyEndAllowThreads(__tstate);
13599 if (PyErr_Occurred()) SWIG_fail;
13600 }
13601 {
13602 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
13603 }
13604 return resultobj;
13605 fail:
13606 return NULL;
13607 }
13608
13609
13610 static PyObject *_wrap_Image_AddHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13611 PyObject *resultobj;
13612 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13613 PyObject * obj0 = 0 ;
13614 char *kwnames[] = {
13615 (char *) "handler", NULL
13616 };
13617
13618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) goto fail;
13619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13620 if (SWIG_arg_fail(1)) SWIG_fail;
13621 {
13622 PyThreadState* __tstate = wxPyBeginAllowThreads();
13623 wxImage::AddHandler(arg1);
13624
13625 wxPyEndAllowThreads(__tstate);
13626 if (PyErr_Occurred()) SWIG_fail;
13627 }
13628 Py_INCREF(Py_None); resultobj = Py_None;
13629 return resultobj;
13630 fail:
13631 return NULL;
13632 }
13633
13634
13635 static PyObject *_wrap_Image_InsertHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13636 PyObject *resultobj;
13637 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
13638 PyObject * obj0 = 0 ;
13639 char *kwnames[] = {
13640 (char *) "handler", NULL
13641 };
13642
13643 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) goto fail;
13644 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImageHandler, SWIG_POINTER_EXCEPTION | 0);
13645 if (SWIG_arg_fail(1)) SWIG_fail;
13646 {
13647 PyThreadState* __tstate = wxPyBeginAllowThreads();
13648 wxImage::InsertHandler(arg1);
13649
13650 wxPyEndAllowThreads(__tstate);
13651 if (PyErr_Occurred()) SWIG_fail;
13652 }
13653 Py_INCREF(Py_None); resultobj = Py_None;
13654 return resultobj;
13655 fail:
13656 return NULL;
13657 }
13658
13659
13660 static PyObject *_wrap_Image_RemoveHandler(PyObject *, PyObject *args, PyObject *kwargs) {
13661 PyObject *resultobj;
13662 wxString *arg1 = 0 ;
13663 bool result;
13664 bool temp1 = false ;
13665 PyObject * obj0 = 0 ;
13666 char *kwnames[] = {
13667 (char *) "name", NULL
13668 };
13669
13670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) goto fail;
13671 {
13672 arg1 = wxString_in_helper(obj0);
13673 if (arg1 == NULL) SWIG_fail;
13674 temp1 = true;
13675 }
13676 {
13677 PyThreadState* __tstate = wxPyBeginAllowThreads();
13678 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
13679
13680 wxPyEndAllowThreads(__tstate);
13681 if (PyErr_Occurred()) SWIG_fail;
13682 }
13683 {
13684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13685 }
13686 {
13687 if (temp1)
13688 delete arg1;
13689 }
13690 return resultobj;
13691 fail:
13692 {
13693 if (temp1)
13694 delete arg1;
13695 }
13696 return NULL;
13697 }
13698
13699
13700 static PyObject *_wrap_Image_GetImageExtWildcard(PyObject *, PyObject *args, PyObject *kwargs) {
13701 PyObject *resultobj;
13702 wxString result;
13703 char *kwnames[] = {
13704 NULL
13705 };
13706
13707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Image_GetImageExtWildcard",kwnames)) goto fail;
13708 {
13709 PyThreadState* __tstate = wxPyBeginAllowThreads();
13710 result = wxImage::GetImageExtWildcard();
13711
13712 wxPyEndAllowThreads(__tstate);
13713 if (PyErr_Occurred()) SWIG_fail;
13714 }
13715 {
13716 #if wxUSE_UNICODE
13717 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13718 #else
13719 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13720 #endif
13721 }
13722 return resultobj;
13723 fail:
13724 return NULL;
13725 }
13726
13727
13728 static PyObject *_wrap_Image_ConvertToBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13729 PyObject *resultobj;
13730 wxImage *arg1 = (wxImage *) 0 ;
13731 int arg2 = (int) -1 ;
13732 wxBitmap result;
13733 PyObject * obj0 = 0 ;
13734 PyObject * obj1 = 0 ;
13735 char *kwnames[] = {
13736 (char *) "self",(char *) "depth", NULL
13737 };
13738
13739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) goto fail;
13740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13741 if (SWIG_arg_fail(1)) SWIG_fail;
13742 if (obj1) {
13743 {
13744 arg2 = (int)(SWIG_As_int(obj1));
13745 if (SWIG_arg_fail(2)) SWIG_fail;
13746 }
13747 }
13748 {
13749 if (!wxPyCheckForApp()) SWIG_fail;
13750 PyThreadState* __tstate = wxPyBeginAllowThreads();
13751 result = wxImage_ConvertToBitmap(arg1,arg2);
13752
13753 wxPyEndAllowThreads(__tstate);
13754 if (PyErr_Occurred()) SWIG_fail;
13755 }
13756 {
13757 wxBitmap * resultptr;
13758 resultptr = new wxBitmap((wxBitmap &)(result));
13759 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13760 }
13761 return resultobj;
13762 fail:
13763 return NULL;
13764 }
13765
13766
13767 static PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
13768 PyObject *resultobj;
13769 wxImage *arg1 = (wxImage *) 0 ;
13770 unsigned char arg2 ;
13771 unsigned char arg3 ;
13772 unsigned char arg4 ;
13773 wxBitmap result;
13774 PyObject * obj0 = 0 ;
13775 PyObject * obj1 = 0 ;
13776 PyObject * obj2 = 0 ;
13777 PyObject * obj3 = 0 ;
13778 char *kwnames[] = {
13779 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
13780 };
13781
13782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
13783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
13784 if (SWIG_arg_fail(1)) SWIG_fail;
13785 {
13786 arg2 = (unsigned char)(SWIG_As_unsigned_SS_char(obj1));
13787 if (SWIG_arg_fail(2)) SWIG_fail;
13788 }
13789 {
13790 arg3 = (unsigned char)(SWIG_As_unsigned_SS_char(obj2));
13791 if (SWIG_arg_fail(3)) SWIG_fail;
13792 }
13793 {
13794 arg4 = (unsigned char)(SWIG_As_unsigned_SS_char(obj3));
13795 if (SWIG_arg_fail(4)) SWIG_fail;
13796 }
13797 {
13798 if (!wxPyCheckForApp()) SWIG_fail;
13799 PyThreadState* __tstate = wxPyBeginAllowThreads();
13800 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
13801
13802 wxPyEndAllowThreads(__tstate);
13803 if (PyErr_Occurred()) SWIG_fail;
13804 }
13805 {
13806 wxBitmap * resultptr;
13807 resultptr = new wxBitmap((wxBitmap &)(result));
13808 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxBitmap, 1);
13809 }
13810 return resultobj;
13811 fail:
13812 return NULL;
13813 }
13814
13815
13816 static PyObject * Image_swigregister(PyObject *, PyObject *args) {
13817 PyObject *obj;
13818 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
13819 SWIG_TypeClientData(SWIGTYPE_p_wxImage, obj);
13820 Py_INCREF(obj);
13821 return Py_BuildValue((char *)"");
13822 }
13823 static int _wrap_NullImage_set(PyObject *) {
13824 PyErr_SetString(PyExc_TypeError,"Variable NullImage is read-only.");
13825 return 1;
13826 }
13827
13828
13829 static PyObject *_wrap_NullImage_get(void) {
13830 PyObject *pyobj;
13831
13832 pyobj = SWIG_NewPointerObj((void *)(&wxNullImage), SWIGTYPE_p_wxImage, 0);
13833 return pyobj;
13834 }
13835
13836
13837 static int _wrap_IMAGE_OPTION_FILENAME_set(PyObject *) {
13838 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
13839 return 1;
13840 }
13841
13842
13843 static PyObject *_wrap_IMAGE_OPTION_FILENAME_get(void) {
13844 PyObject *pyobj;
13845
13846 {
13847 #if wxUSE_UNICODE
13848 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13849 #else
13850 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
13851 #endif
13852 }
13853 return pyobj;
13854 }
13855
13856
13857 static int _wrap_IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
13858 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
13859 return 1;
13860 }
13861
13862
13863 static PyObject *_wrap_IMAGE_OPTION_BMP_FORMAT_get(void) {
13864 PyObject *pyobj;
13865
13866 {
13867 #if wxUSE_UNICODE
13868 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13869 #else
13870 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
13871 #endif
13872 }
13873 return pyobj;
13874 }
13875
13876
13877 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
13878 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
13879 return 1;
13880 }
13881
13882
13883 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
13884 PyObject *pyobj;
13885
13886 {
13887 #if wxUSE_UNICODE
13888 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13889 #else
13890 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
13891 #endif
13892 }
13893 return pyobj;
13894 }
13895
13896
13897 static int _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
13898 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
13899 return 1;
13900 }
13901
13902
13903 static PyObject *_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
13904 PyObject *pyobj;
13905
13906 {
13907 #if wxUSE_UNICODE
13908 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13909 #else
13910 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
13911 #endif
13912 }
13913 return pyobj;
13914 }
13915
13916
13917 static int _wrap_IMAGE_OPTION_RESOLUTION_set(PyObject *) {
13918 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
13919 return 1;
13920 }
13921
13922
13923 static PyObject *_wrap_IMAGE_OPTION_RESOLUTION_get(void) {
13924 PyObject *pyobj;
13925
13926 {
13927 #if wxUSE_UNICODE
13928 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13929 #else
13930 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
13931 #endif
13932 }
13933 return pyobj;
13934 }
13935
13936
13937 static int _wrap_IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
13938 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
13939 return 1;
13940 }
13941
13942
13943 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONX_get(void) {
13944 PyObject *pyobj;
13945
13946 {
13947 #if wxUSE_UNICODE
13948 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13949 #else
13950 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
13951 #endif
13952 }
13953 return pyobj;
13954 }
13955
13956
13957 static int _wrap_IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
13958 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
13959 return 1;
13960 }
13961
13962
13963 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONY_get(void) {
13964 PyObject *pyobj;
13965
13966 {
13967 #if wxUSE_UNICODE
13968 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13969 #else
13970 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
13971 #endif
13972 }
13973 return pyobj;
13974 }
13975
13976
13977 static int _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
13978 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
13979 return 1;
13980 }
13981
13982
13983 static PyObject *_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
13984 PyObject *pyobj;
13985
13986 {
13987 #if wxUSE_UNICODE
13988 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13989 #else
13990 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
13991 #endif
13992 }
13993 return pyobj;
13994 }
13995
13996
13997 static int _wrap_IMAGE_OPTION_QUALITY_set(PyObject *) {
13998 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
13999 return 1;
14000 }
14001
14002
14003 static PyObject *_wrap_IMAGE_OPTION_QUALITY_get(void) {
14004 PyObject *pyobj;
14005
14006 {
14007 #if wxUSE_UNICODE
14008 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14009 #else
14010 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
14011 #endif
14012 }
14013 return pyobj;
14014 }
14015
14016
14017 static int _wrap_IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
14018 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
14019 return 1;
14020 }
14021
14022
14023 static PyObject *_wrap_IMAGE_OPTION_BITSPERSAMPLE_get(void) {
14024 PyObject *pyobj;
14025
14026 {
14027 #if wxUSE_UNICODE
14028 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14029 #else
14030 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
14031 #endif
14032 }
14033 return pyobj;
14034 }
14035
14036
14037 static int _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
14038 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
14039 return 1;
14040 }
14041
14042
14043 static PyObject *_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
14044 PyObject *pyobj;
14045
14046 {
14047 #if wxUSE_UNICODE
14048 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14049 #else
14050 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
14051 #endif
14052 }
14053 return pyobj;
14054 }
14055
14056
14057 static int _wrap_IMAGE_OPTION_COMPRESSION_set(PyObject *) {
14058 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
14059 return 1;
14060 }
14061
14062
14063 static PyObject *_wrap_IMAGE_OPTION_COMPRESSION_get(void) {
14064 PyObject *pyobj;
14065
14066 {
14067 #if wxUSE_UNICODE
14068 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14069 #else
14070 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
14071 #endif
14072 }
14073 return pyobj;
14074 }
14075
14076
14077 static int _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
14078 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
14079 return 1;
14080 }
14081
14082
14083 static PyObject *_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
14084 PyObject *pyobj;
14085
14086 {
14087 #if wxUSE_UNICODE
14088 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14089 #else
14090 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
14091 #endif
14092 }
14093 return pyobj;
14094 }
14095
14096
14097 static int _wrap_IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
14098 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
14099 return 1;
14100 }
14101
14102
14103 static PyObject *_wrap_IMAGE_OPTION_PNG_FORMAT_get(void) {
14104 PyObject *pyobj;
14105
14106 {
14107 #if wxUSE_UNICODE
14108 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14109 #else
14110 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
14111 #endif
14112 }
14113 return pyobj;
14114 }
14115
14116
14117 static int _wrap_IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
14118 PyErr_SetString(PyExc_TypeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
14119 return 1;
14120 }
14121
14122
14123 static PyObject *_wrap_IMAGE_OPTION_PNG_BITDEPTH_get(void) {
14124 PyObject *pyobj;
14125
14126 {
14127 #if wxUSE_UNICODE
14128 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14129 #else
14130 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
14131 #endif
14132 }
14133 return pyobj;
14134 }
14135
14136
14137 static PyObject *_wrap_new_BMPHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14138 PyObject *resultobj;
14139 wxBMPHandler *result;
14140 char *kwnames[] = {
14141 NULL
14142 };
14143
14144 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_BMPHandler",kwnames)) goto fail;
14145 {
14146 PyThreadState* __tstate = wxPyBeginAllowThreads();
14147 result = (wxBMPHandler *)new wxBMPHandler();
14148
14149 wxPyEndAllowThreads(__tstate);
14150 if (PyErr_Occurred()) SWIG_fail;
14151 }
14152 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBMPHandler, 1);
14153 return resultobj;
14154 fail:
14155 return NULL;
14156 }
14157
14158
14159 static PyObject * BMPHandler_swigregister(PyObject *, PyObject *args) {
14160 PyObject *obj;
14161 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14162 SWIG_TypeClientData(SWIGTYPE_p_wxBMPHandler, obj);
14163 Py_INCREF(obj);
14164 return Py_BuildValue((char *)"");
14165 }
14166 static PyObject *_wrap_new_ICOHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14167 PyObject *resultobj;
14168 wxICOHandler *result;
14169 char *kwnames[] = {
14170 NULL
14171 };
14172
14173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ICOHandler",kwnames)) goto fail;
14174 {
14175 PyThreadState* __tstate = wxPyBeginAllowThreads();
14176 result = (wxICOHandler *)new wxICOHandler();
14177
14178 wxPyEndAllowThreads(__tstate);
14179 if (PyErr_Occurred()) SWIG_fail;
14180 }
14181 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxICOHandler, 1);
14182 return resultobj;
14183 fail:
14184 return NULL;
14185 }
14186
14187
14188 static PyObject * ICOHandler_swigregister(PyObject *, PyObject *args) {
14189 PyObject *obj;
14190 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14191 SWIG_TypeClientData(SWIGTYPE_p_wxICOHandler, obj);
14192 Py_INCREF(obj);
14193 return Py_BuildValue((char *)"");
14194 }
14195 static PyObject *_wrap_new_CURHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14196 PyObject *resultobj;
14197 wxCURHandler *result;
14198 char *kwnames[] = {
14199 NULL
14200 };
14201
14202 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_CURHandler",kwnames)) goto fail;
14203 {
14204 PyThreadState* __tstate = wxPyBeginAllowThreads();
14205 result = (wxCURHandler *)new wxCURHandler();
14206
14207 wxPyEndAllowThreads(__tstate);
14208 if (PyErr_Occurred()) SWIG_fail;
14209 }
14210 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCURHandler, 1);
14211 return resultobj;
14212 fail:
14213 return NULL;
14214 }
14215
14216
14217 static PyObject * CURHandler_swigregister(PyObject *, PyObject *args) {
14218 PyObject *obj;
14219 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14220 SWIG_TypeClientData(SWIGTYPE_p_wxCURHandler, obj);
14221 Py_INCREF(obj);
14222 return Py_BuildValue((char *)"");
14223 }
14224 static PyObject *_wrap_new_ANIHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14225 PyObject *resultobj;
14226 wxANIHandler *result;
14227 char *kwnames[] = {
14228 NULL
14229 };
14230
14231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_ANIHandler",kwnames)) goto fail;
14232 {
14233 PyThreadState* __tstate = wxPyBeginAllowThreads();
14234 result = (wxANIHandler *)new wxANIHandler();
14235
14236 wxPyEndAllowThreads(__tstate);
14237 if (PyErr_Occurred()) SWIG_fail;
14238 }
14239 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxANIHandler, 1);
14240 return resultobj;
14241 fail:
14242 return NULL;
14243 }
14244
14245
14246 static PyObject * ANIHandler_swigregister(PyObject *, PyObject *args) {
14247 PyObject *obj;
14248 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14249 SWIG_TypeClientData(SWIGTYPE_p_wxANIHandler, obj);
14250 Py_INCREF(obj);
14251 return Py_BuildValue((char *)"");
14252 }
14253 static PyObject *_wrap_new_PNGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14254 PyObject *resultobj;
14255 wxPNGHandler *result;
14256 char *kwnames[] = {
14257 NULL
14258 };
14259
14260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNGHandler",kwnames)) goto fail;
14261 {
14262 PyThreadState* __tstate = wxPyBeginAllowThreads();
14263 result = (wxPNGHandler *)new wxPNGHandler();
14264
14265 wxPyEndAllowThreads(__tstate);
14266 if (PyErr_Occurred()) SWIG_fail;
14267 }
14268 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNGHandler, 1);
14269 return resultobj;
14270 fail:
14271 return NULL;
14272 }
14273
14274
14275 static PyObject * PNGHandler_swigregister(PyObject *, PyObject *args) {
14276 PyObject *obj;
14277 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14278 SWIG_TypeClientData(SWIGTYPE_p_wxPNGHandler, obj);
14279 Py_INCREF(obj);
14280 return Py_BuildValue((char *)"");
14281 }
14282 static PyObject *_wrap_new_GIFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14283 PyObject *resultobj;
14284 wxGIFHandler *result;
14285 char *kwnames[] = {
14286 NULL
14287 };
14288
14289 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GIFHandler",kwnames)) goto fail;
14290 {
14291 PyThreadState* __tstate = wxPyBeginAllowThreads();
14292 result = (wxGIFHandler *)new wxGIFHandler();
14293
14294 wxPyEndAllowThreads(__tstate);
14295 if (PyErr_Occurred()) SWIG_fail;
14296 }
14297 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGIFHandler, 1);
14298 return resultobj;
14299 fail:
14300 return NULL;
14301 }
14302
14303
14304 static PyObject * GIFHandler_swigregister(PyObject *, PyObject *args) {
14305 PyObject *obj;
14306 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14307 SWIG_TypeClientData(SWIGTYPE_p_wxGIFHandler, obj);
14308 Py_INCREF(obj);
14309 return Py_BuildValue((char *)"");
14310 }
14311 static PyObject *_wrap_new_PCXHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14312 PyObject *resultobj;
14313 wxPCXHandler *result;
14314 char *kwnames[] = {
14315 NULL
14316 };
14317
14318 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PCXHandler",kwnames)) goto fail;
14319 {
14320 PyThreadState* __tstate = wxPyBeginAllowThreads();
14321 result = (wxPCXHandler *)new wxPCXHandler();
14322
14323 wxPyEndAllowThreads(__tstate);
14324 if (PyErr_Occurred()) SWIG_fail;
14325 }
14326 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPCXHandler, 1);
14327 return resultobj;
14328 fail:
14329 return NULL;
14330 }
14331
14332
14333 static PyObject * PCXHandler_swigregister(PyObject *, PyObject *args) {
14334 PyObject *obj;
14335 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14336 SWIG_TypeClientData(SWIGTYPE_p_wxPCXHandler, obj);
14337 Py_INCREF(obj);
14338 return Py_BuildValue((char *)"");
14339 }
14340 static PyObject *_wrap_new_JPEGHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14341 PyObject *resultobj;
14342 wxJPEGHandler *result;
14343 char *kwnames[] = {
14344 NULL
14345 };
14346
14347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_JPEGHandler",kwnames)) goto fail;
14348 {
14349 PyThreadState* __tstate = wxPyBeginAllowThreads();
14350 result = (wxJPEGHandler *)new wxJPEGHandler();
14351
14352 wxPyEndAllowThreads(__tstate);
14353 if (PyErr_Occurred()) SWIG_fail;
14354 }
14355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxJPEGHandler, 1);
14356 return resultobj;
14357 fail:
14358 return NULL;
14359 }
14360
14361
14362 static PyObject * JPEGHandler_swigregister(PyObject *, PyObject *args) {
14363 PyObject *obj;
14364 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14365 SWIG_TypeClientData(SWIGTYPE_p_wxJPEGHandler, obj);
14366 Py_INCREF(obj);
14367 return Py_BuildValue((char *)"");
14368 }
14369 static PyObject *_wrap_new_PNMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14370 PyObject *resultobj;
14371 wxPNMHandler *result;
14372 char *kwnames[] = {
14373 NULL
14374 };
14375
14376 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PNMHandler",kwnames)) goto fail;
14377 {
14378 PyThreadState* __tstate = wxPyBeginAllowThreads();
14379 result = (wxPNMHandler *)new wxPNMHandler();
14380
14381 wxPyEndAllowThreads(__tstate);
14382 if (PyErr_Occurred()) SWIG_fail;
14383 }
14384 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPNMHandler, 1);
14385 return resultobj;
14386 fail:
14387 return NULL;
14388 }
14389
14390
14391 static PyObject * PNMHandler_swigregister(PyObject *, PyObject *args) {
14392 PyObject *obj;
14393 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14394 SWIG_TypeClientData(SWIGTYPE_p_wxPNMHandler, obj);
14395 Py_INCREF(obj);
14396 return Py_BuildValue((char *)"");
14397 }
14398 static PyObject *_wrap_new_XPMHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14399 PyObject *resultobj;
14400 wxXPMHandler *result;
14401 char *kwnames[] = {
14402 NULL
14403 };
14404
14405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_XPMHandler",kwnames)) goto fail;
14406 {
14407 PyThreadState* __tstate = wxPyBeginAllowThreads();
14408 result = (wxXPMHandler *)new wxXPMHandler();
14409
14410 wxPyEndAllowThreads(__tstate);
14411 if (PyErr_Occurred()) SWIG_fail;
14412 }
14413 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxXPMHandler, 1);
14414 return resultobj;
14415 fail:
14416 return NULL;
14417 }
14418
14419
14420 static PyObject * XPMHandler_swigregister(PyObject *, PyObject *args) {
14421 PyObject *obj;
14422 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14423 SWIG_TypeClientData(SWIGTYPE_p_wxXPMHandler, obj);
14424 Py_INCREF(obj);
14425 return Py_BuildValue((char *)"");
14426 }
14427 static PyObject *_wrap_new_TIFFHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14428 PyObject *resultobj;
14429 wxTIFFHandler *result;
14430 char *kwnames[] = {
14431 NULL
14432 };
14433
14434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_TIFFHandler",kwnames)) goto fail;
14435 {
14436 PyThreadState* __tstate = wxPyBeginAllowThreads();
14437 result = (wxTIFFHandler *)new wxTIFFHandler();
14438
14439 wxPyEndAllowThreads(__tstate);
14440 if (PyErr_Occurred()) SWIG_fail;
14441 }
14442 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxTIFFHandler, 1);
14443 return resultobj;
14444 fail:
14445 return NULL;
14446 }
14447
14448
14449 static PyObject * TIFFHandler_swigregister(PyObject *, PyObject *args) {
14450 PyObject *obj;
14451 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14452 SWIG_TypeClientData(SWIGTYPE_p_wxTIFFHandler, obj);
14453 Py_INCREF(obj);
14454 return Py_BuildValue((char *)"");
14455 }
14456 static PyObject *_wrap_Quantize_Quantize(PyObject *, PyObject *args, PyObject *kwargs) {
14457 PyObject *resultobj;
14458 wxImage *arg1 = 0 ;
14459 wxImage *arg2 = 0 ;
14460 int arg3 = (int) 236 ;
14461 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
14462 bool result;
14463 PyObject * obj0 = 0 ;
14464 PyObject * obj1 = 0 ;
14465 PyObject * obj2 = 0 ;
14466 PyObject * obj3 = 0 ;
14467 char *kwnames[] = {
14468 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
14469 };
14470
14471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14472 {
14473 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14474 if (SWIG_arg_fail(1)) SWIG_fail;
14475 if (arg1 == NULL) {
14476 SWIG_null_ref("wxImage");
14477 }
14478 if (SWIG_arg_fail(1)) SWIG_fail;
14479 }
14480 {
14481 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxImage, SWIG_POINTER_EXCEPTION | 0);
14482 if (SWIG_arg_fail(2)) SWIG_fail;
14483 if (arg2 == NULL) {
14484 SWIG_null_ref("wxImage");
14485 }
14486 if (SWIG_arg_fail(2)) SWIG_fail;
14487 }
14488 if (obj2) {
14489 {
14490 arg3 = (int)(SWIG_As_int(obj2));
14491 if (SWIG_arg_fail(3)) SWIG_fail;
14492 }
14493 }
14494 if (obj3) {
14495 {
14496 arg4 = (int)(SWIG_As_int(obj3));
14497 if (SWIG_arg_fail(4)) SWIG_fail;
14498 }
14499 }
14500 {
14501 PyThreadState* __tstate = wxPyBeginAllowThreads();
14502 result = (bool)Quantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
14503
14504 wxPyEndAllowThreads(__tstate);
14505 if (PyErr_Occurred()) SWIG_fail;
14506 }
14507 {
14508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14509 }
14510 return resultobj;
14511 fail:
14512 return NULL;
14513 }
14514
14515
14516 static PyObject * Quantize_swigregister(PyObject *, PyObject *args) {
14517 PyObject *obj;
14518 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14519 SWIG_TypeClientData(SWIGTYPE_p_wxQuantize, obj);
14520 Py_INCREF(obj);
14521 return Py_BuildValue((char *)"");
14522 }
14523 static PyObject *_wrap_new_EvtHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14524 PyObject *resultobj;
14525 wxEvtHandler *result;
14526 char *kwnames[] = {
14527 NULL
14528 };
14529
14530 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EvtHandler",kwnames)) goto fail;
14531 {
14532 PyThreadState* __tstate = wxPyBeginAllowThreads();
14533 result = (wxEvtHandler *)new wxEvtHandler();
14534
14535 wxPyEndAllowThreads(__tstate);
14536 if (PyErr_Occurred()) SWIG_fail;
14537 }
14538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvtHandler, 1);
14539 return resultobj;
14540 fail:
14541 return NULL;
14542 }
14543
14544
14545 static PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14546 PyObject *resultobj;
14547 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14548 wxEvtHandler *result;
14549 PyObject * obj0 = 0 ;
14550 char *kwnames[] = {
14551 (char *) "self", NULL
14552 };
14553
14554 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetNextHandler",kwnames,&obj0)) goto fail;
14555 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14556 if (SWIG_arg_fail(1)) SWIG_fail;
14557 {
14558 PyThreadState* __tstate = wxPyBeginAllowThreads();
14559 result = (wxEvtHandler *)(arg1)->GetNextHandler();
14560
14561 wxPyEndAllowThreads(__tstate);
14562 if (PyErr_Occurred()) SWIG_fail;
14563 }
14564 {
14565 resultobj = wxPyMake_wxObject(result, 0);
14566 }
14567 return resultobj;
14568 fail:
14569 return NULL;
14570 }
14571
14572
14573 static PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14574 PyObject *resultobj;
14575 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14576 wxEvtHandler *result;
14577 PyObject * obj0 = 0 ;
14578 char *kwnames[] = {
14579 (char *) "self", NULL
14580 };
14581
14582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetPreviousHandler",kwnames,&obj0)) goto fail;
14583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14584 if (SWIG_arg_fail(1)) SWIG_fail;
14585 {
14586 PyThreadState* __tstate = wxPyBeginAllowThreads();
14587 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
14588
14589 wxPyEndAllowThreads(__tstate);
14590 if (PyErr_Occurred()) SWIG_fail;
14591 }
14592 {
14593 resultobj = wxPyMake_wxObject(result, 0);
14594 }
14595 return resultobj;
14596 fail:
14597 return NULL;
14598 }
14599
14600
14601 static PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14602 PyObject *resultobj;
14603 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14604 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14605 PyObject * obj0 = 0 ;
14606 PyObject * obj1 = 0 ;
14607 char *kwnames[] = {
14608 (char *) "self",(char *) "handler", NULL
14609 };
14610
14611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) goto fail;
14612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14613 if (SWIG_arg_fail(1)) SWIG_fail;
14614 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14615 if (SWIG_arg_fail(2)) SWIG_fail;
14616 {
14617 PyThreadState* __tstate = wxPyBeginAllowThreads();
14618 (arg1)->SetNextHandler(arg2);
14619
14620 wxPyEndAllowThreads(__tstate);
14621 if (PyErr_Occurred()) SWIG_fail;
14622 }
14623 Py_INCREF(Py_None); resultobj = Py_None;
14624 return resultobj;
14625 fail:
14626 return NULL;
14627 }
14628
14629
14630 static PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *, PyObject *args, PyObject *kwargs) {
14631 PyObject *resultobj;
14632 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14633 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
14634 PyObject * obj0 = 0 ;
14635 PyObject * obj1 = 0 ;
14636 char *kwnames[] = {
14637 (char *) "self",(char *) "handler", NULL
14638 };
14639
14640 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) goto fail;
14641 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14642 if (SWIG_arg_fail(1)) SWIG_fail;
14643 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14644 if (SWIG_arg_fail(2)) SWIG_fail;
14645 {
14646 PyThreadState* __tstate = wxPyBeginAllowThreads();
14647 (arg1)->SetPreviousHandler(arg2);
14648
14649 wxPyEndAllowThreads(__tstate);
14650 if (PyErr_Occurred()) SWIG_fail;
14651 }
14652 Py_INCREF(Py_None); resultobj = Py_None;
14653 return resultobj;
14654 fail:
14655 return NULL;
14656 }
14657
14658
14659 static PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14660 PyObject *resultobj;
14661 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14662 bool result;
14663 PyObject * obj0 = 0 ;
14664 char *kwnames[] = {
14665 (char *) "self", NULL
14666 };
14667
14668 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_GetEvtHandlerEnabled",kwnames,&obj0)) goto fail;
14669 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14670 if (SWIG_arg_fail(1)) SWIG_fail;
14671 {
14672 PyThreadState* __tstate = wxPyBeginAllowThreads();
14673 result = (bool)(arg1)->GetEvtHandlerEnabled();
14674
14675 wxPyEndAllowThreads(__tstate);
14676 if (PyErr_Occurred()) SWIG_fail;
14677 }
14678 {
14679 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14680 }
14681 return resultobj;
14682 fail:
14683 return NULL;
14684 }
14685
14686
14687 static PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
14688 PyObject *resultobj;
14689 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14690 bool arg2 ;
14691 PyObject * obj0 = 0 ;
14692 PyObject * obj1 = 0 ;
14693 char *kwnames[] = {
14694 (char *) "self",(char *) "enabled", NULL
14695 };
14696
14697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) goto fail;
14698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14699 if (SWIG_arg_fail(1)) SWIG_fail;
14700 {
14701 arg2 = (bool)(SWIG_As_bool(obj1));
14702 if (SWIG_arg_fail(2)) SWIG_fail;
14703 }
14704 {
14705 PyThreadState* __tstate = wxPyBeginAllowThreads();
14706 (arg1)->SetEvtHandlerEnabled(arg2);
14707
14708 wxPyEndAllowThreads(__tstate);
14709 if (PyErr_Occurred()) SWIG_fail;
14710 }
14711 Py_INCREF(Py_None); resultobj = Py_None;
14712 return resultobj;
14713 fail:
14714 return NULL;
14715 }
14716
14717
14718 static PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14719 PyObject *resultobj;
14720 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14721 wxEvent *arg2 = 0 ;
14722 bool result;
14723 PyObject * obj0 = 0 ;
14724 PyObject * obj1 = 0 ;
14725 char *kwnames[] = {
14726 (char *) "self",(char *) "event", NULL
14727 };
14728
14729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) goto fail;
14730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14731 if (SWIG_arg_fail(1)) SWIG_fail;
14732 {
14733 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14734 if (SWIG_arg_fail(2)) SWIG_fail;
14735 if (arg2 == NULL) {
14736 SWIG_null_ref("wxEvent");
14737 }
14738 if (SWIG_arg_fail(2)) SWIG_fail;
14739 }
14740 {
14741 PyThreadState* __tstate = wxPyBeginAllowThreads();
14742 result = (bool)(arg1)->ProcessEvent(*arg2);
14743
14744 wxPyEndAllowThreads(__tstate);
14745 if (PyErr_Occurred()) SWIG_fail;
14746 }
14747 {
14748 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14749 }
14750 return resultobj;
14751 fail:
14752 return NULL;
14753 }
14754
14755
14756 static PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *, PyObject *args, PyObject *kwargs) {
14757 PyObject *resultobj;
14758 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14759 wxEvent *arg2 = 0 ;
14760 PyObject * obj0 = 0 ;
14761 PyObject * obj1 = 0 ;
14762 char *kwnames[] = {
14763 (char *) "self",(char *) "event", NULL
14764 };
14765
14766 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) goto fail;
14767 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14768 if (SWIG_arg_fail(1)) SWIG_fail;
14769 {
14770 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14771 if (SWIG_arg_fail(2)) SWIG_fail;
14772 if (arg2 == NULL) {
14773 SWIG_null_ref("wxEvent");
14774 }
14775 if (SWIG_arg_fail(2)) SWIG_fail;
14776 }
14777 {
14778 PyThreadState* __tstate = wxPyBeginAllowThreads();
14779 (arg1)->AddPendingEvent(*arg2);
14780
14781 wxPyEndAllowThreads(__tstate);
14782 if (PyErr_Occurred()) SWIG_fail;
14783 }
14784 Py_INCREF(Py_None); resultobj = Py_None;
14785 return resultobj;
14786 fail:
14787 return NULL;
14788 }
14789
14790
14791 static PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
14792 PyObject *resultobj;
14793 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14794 PyObject * obj0 = 0 ;
14795 char *kwnames[] = {
14796 (char *) "self", NULL
14797 };
14798
14799 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EvtHandler_ProcessPendingEvents",kwnames,&obj0)) goto fail;
14800 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14801 if (SWIG_arg_fail(1)) SWIG_fail;
14802 {
14803 PyThreadState* __tstate = wxPyBeginAllowThreads();
14804 (arg1)->ProcessPendingEvents();
14805
14806 wxPyEndAllowThreads(__tstate);
14807 if (PyErr_Occurred()) SWIG_fail;
14808 }
14809 Py_INCREF(Py_None); resultobj = Py_None;
14810 return resultobj;
14811 fail:
14812 return NULL;
14813 }
14814
14815
14816 static PyObject *_wrap_EvtHandler_Connect(PyObject *, PyObject *args, PyObject *kwargs) {
14817 PyObject *resultobj;
14818 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14819 int arg2 ;
14820 int arg3 ;
14821 int arg4 ;
14822 PyObject *arg5 = (PyObject *) 0 ;
14823 PyObject * obj0 = 0 ;
14824 PyObject * obj1 = 0 ;
14825 PyObject * obj2 = 0 ;
14826 PyObject * obj3 = 0 ;
14827 PyObject * obj4 = 0 ;
14828 char *kwnames[] = {
14829 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
14830 };
14831
14832 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
14833 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14834 if (SWIG_arg_fail(1)) SWIG_fail;
14835 {
14836 arg2 = (int)(SWIG_As_int(obj1));
14837 if (SWIG_arg_fail(2)) SWIG_fail;
14838 }
14839 {
14840 arg3 = (int)(SWIG_As_int(obj2));
14841 if (SWIG_arg_fail(3)) SWIG_fail;
14842 }
14843 {
14844 arg4 = (int)(SWIG_As_int(obj3));
14845 if (SWIG_arg_fail(4)) SWIG_fail;
14846 }
14847 arg5 = obj4;
14848 {
14849 PyThreadState* __tstate = wxPyBeginAllowThreads();
14850 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
14851
14852 wxPyEndAllowThreads(__tstate);
14853 if (PyErr_Occurred()) SWIG_fail;
14854 }
14855 Py_INCREF(Py_None); resultobj = Py_None;
14856 return resultobj;
14857 fail:
14858 return NULL;
14859 }
14860
14861
14862 static PyObject *_wrap_EvtHandler_Disconnect(PyObject *, PyObject *args, PyObject *kwargs) {
14863 PyObject *resultobj;
14864 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14865 int arg2 ;
14866 int arg3 = (int) -1 ;
14867 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
14868 bool result;
14869 PyObject * obj0 = 0 ;
14870 PyObject * obj1 = 0 ;
14871 PyObject * obj2 = 0 ;
14872 PyObject * obj3 = 0 ;
14873 char *kwnames[] = {
14874 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
14875 };
14876
14877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
14878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14879 if (SWIG_arg_fail(1)) SWIG_fail;
14880 {
14881 arg2 = (int)(SWIG_As_int(obj1));
14882 if (SWIG_arg_fail(2)) SWIG_fail;
14883 }
14884 if (obj2) {
14885 {
14886 arg3 = (int)(SWIG_As_int(obj2));
14887 if (SWIG_arg_fail(3)) SWIG_fail;
14888 }
14889 }
14890 if (obj3) {
14891 {
14892 arg4 = (wxEventType)(SWIG_As_int(obj3));
14893 if (SWIG_arg_fail(4)) SWIG_fail;
14894 }
14895 }
14896 {
14897 PyThreadState* __tstate = wxPyBeginAllowThreads();
14898 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
14899
14900 wxPyEndAllowThreads(__tstate);
14901 if (PyErr_Occurred()) SWIG_fail;
14902 }
14903 {
14904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14905 }
14906 return resultobj;
14907 fail:
14908 return NULL;
14909 }
14910
14911
14912 static PyObject *_wrap_EvtHandler__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
14913 PyObject *resultobj;
14914 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
14915 PyObject *arg2 = (PyObject *) 0 ;
14916 bool arg3 = (bool) true ;
14917 PyObject * obj0 = 0 ;
14918 PyObject * obj1 = 0 ;
14919 PyObject * obj2 = 0 ;
14920 char *kwnames[] = {
14921 (char *) "self",(char *) "_self",(char *) "incref", NULL
14922 };
14923
14924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
14925 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
14926 if (SWIG_arg_fail(1)) SWIG_fail;
14927 arg2 = obj1;
14928 if (obj2) {
14929 {
14930 arg3 = (bool)(SWIG_As_bool(obj2));
14931 if (SWIG_arg_fail(3)) SWIG_fail;
14932 }
14933 }
14934 {
14935 PyThreadState* __tstate = wxPyBeginAllowThreads();
14936 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
14937
14938 wxPyEndAllowThreads(__tstate);
14939 if (PyErr_Occurred()) SWIG_fail;
14940 }
14941 Py_INCREF(Py_None); resultobj = Py_None;
14942 return resultobj;
14943 fail:
14944 return NULL;
14945 }
14946
14947
14948 static PyObject * EvtHandler_swigregister(PyObject *, PyObject *args) {
14949 PyObject *obj;
14950 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
14951 SWIG_TypeClientData(SWIGTYPE_p_wxEvtHandler, obj);
14952 Py_INCREF(obj);
14953 return Py_BuildValue((char *)"");
14954 }
14955 static PyObject *_wrap_NewEventType(PyObject *, PyObject *args, PyObject *kwargs) {
14956 PyObject *resultobj;
14957 wxEventType result;
14958 char *kwnames[] = {
14959 NULL
14960 };
14961
14962 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":NewEventType",kwnames)) goto fail;
14963 {
14964 PyThreadState* __tstate = wxPyBeginAllowThreads();
14965 result = (wxEventType)wxNewEventType();
14966
14967 wxPyEndAllowThreads(__tstate);
14968 if (PyErr_Occurred()) SWIG_fail;
14969 }
14970 {
14971 resultobj = SWIG_From_int((int)(result));
14972 }
14973 return resultobj;
14974 fail:
14975 return NULL;
14976 }
14977
14978
14979 static PyObject *_wrap_delete_Event(PyObject *, PyObject *args, PyObject *kwargs) {
14980 PyObject *resultobj;
14981 wxEvent *arg1 = (wxEvent *) 0 ;
14982 PyObject * obj0 = 0 ;
14983 char *kwnames[] = {
14984 (char *) "self", NULL
14985 };
14986
14987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_Event",kwnames,&obj0)) goto fail;
14988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
14989 if (SWIG_arg_fail(1)) SWIG_fail;
14990 {
14991 PyThreadState* __tstate = wxPyBeginAllowThreads();
14992 delete arg1;
14993
14994 wxPyEndAllowThreads(__tstate);
14995 if (PyErr_Occurred()) SWIG_fail;
14996 }
14997 Py_INCREF(Py_None); resultobj = Py_None;
14998 return resultobj;
14999 fail:
15000 return NULL;
15001 }
15002
15003
15004 static PyObject *_wrap_Event_SetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15005 PyObject *resultobj;
15006 wxEvent *arg1 = (wxEvent *) 0 ;
15007 wxEventType arg2 ;
15008 PyObject * obj0 = 0 ;
15009 PyObject * obj1 = 0 ;
15010 char *kwnames[] = {
15011 (char *) "self",(char *) "typ", NULL
15012 };
15013
15014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) goto fail;
15015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15016 if (SWIG_arg_fail(1)) SWIG_fail;
15017 {
15018 arg2 = (wxEventType)(SWIG_As_int(obj1));
15019 if (SWIG_arg_fail(2)) SWIG_fail;
15020 }
15021 {
15022 PyThreadState* __tstate = wxPyBeginAllowThreads();
15023 (arg1)->SetEventType(arg2);
15024
15025 wxPyEndAllowThreads(__tstate);
15026 if (PyErr_Occurred()) SWIG_fail;
15027 }
15028 Py_INCREF(Py_None); resultobj = Py_None;
15029 return resultobj;
15030 fail:
15031 return NULL;
15032 }
15033
15034
15035 static PyObject *_wrap_Event_GetEventType(PyObject *, PyObject *args, PyObject *kwargs) {
15036 PyObject *resultobj;
15037 wxEvent *arg1 = (wxEvent *) 0 ;
15038 wxEventType result;
15039 PyObject * obj0 = 0 ;
15040 char *kwnames[] = {
15041 (char *) "self", NULL
15042 };
15043
15044 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventType",kwnames,&obj0)) goto fail;
15045 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15046 if (SWIG_arg_fail(1)) SWIG_fail;
15047 {
15048 PyThreadState* __tstate = wxPyBeginAllowThreads();
15049 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
15050
15051 wxPyEndAllowThreads(__tstate);
15052 if (PyErr_Occurred()) SWIG_fail;
15053 }
15054 {
15055 resultobj = SWIG_From_int((int)(result));
15056 }
15057 return resultobj;
15058 fail:
15059 return NULL;
15060 }
15061
15062
15063 static PyObject *_wrap_Event_GetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15064 PyObject *resultobj;
15065 wxEvent *arg1 = (wxEvent *) 0 ;
15066 wxObject *result;
15067 PyObject * obj0 = 0 ;
15068 char *kwnames[] = {
15069 (char *) "self", NULL
15070 };
15071
15072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetEventObject",kwnames,&obj0)) goto fail;
15073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15074 if (SWIG_arg_fail(1)) SWIG_fail;
15075 {
15076 PyThreadState* __tstate = wxPyBeginAllowThreads();
15077 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
15078
15079 wxPyEndAllowThreads(__tstate);
15080 if (PyErr_Occurred()) SWIG_fail;
15081 }
15082 {
15083 resultobj = wxPyMake_wxObject(result, 0);
15084 }
15085 return resultobj;
15086 fail:
15087 return NULL;
15088 }
15089
15090
15091 static PyObject *_wrap_Event_SetEventObject(PyObject *, PyObject *args, PyObject *kwargs) {
15092 PyObject *resultobj;
15093 wxEvent *arg1 = (wxEvent *) 0 ;
15094 wxObject *arg2 = (wxObject *) 0 ;
15095 PyObject * obj0 = 0 ;
15096 PyObject * obj1 = 0 ;
15097 char *kwnames[] = {
15098 (char *) "self",(char *) "obj", NULL
15099 };
15100
15101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) goto fail;
15102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15103 if (SWIG_arg_fail(1)) SWIG_fail;
15104 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxObject, SWIG_POINTER_EXCEPTION | 0);
15105 if (SWIG_arg_fail(2)) SWIG_fail;
15106 {
15107 PyThreadState* __tstate = wxPyBeginAllowThreads();
15108 (arg1)->SetEventObject(arg2);
15109
15110 wxPyEndAllowThreads(__tstate);
15111 if (PyErr_Occurred()) SWIG_fail;
15112 }
15113 Py_INCREF(Py_None); resultobj = Py_None;
15114 return resultobj;
15115 fail:
15116 return NULL;
15117 }
15118
15119
15120 static PyObject *_wrap_Event_GetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15121 PyObject *resultobj;
15122 wxEvent *arg1 = (wxEvent *) 0 ;
15123 long result;
15124 PyObject * obj0 = 0 ;
15125 char *kwnames[] = {
15126 (char *) "self", NULL
15127 };
15128
15129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetTimestamp",kwnames,&obj0)) goto fail;
15130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15131 if (SWIG_arg_fail(1)) SWIG_fail;
15132 {
15133 PyThreadState* __tstate = wxPyBeginAllowThreads();
15134 result = (long)((wxEvent const *)arg1)->GetTimestamp();
15135
15136 wxPyEndAllowThreads(__tstate);
15137 if (PyErr_Occurred()) SWIG_fail;
15138 }
15139 {
15140 resultobj = SWIG_From_long((long)(result));
15141 }
15142 return resultobj;
15143 fail:
15144 return NULL;
15145 }
15146
15147
15148 static PyObject *_wrap_Event_SetTimestamp(PyObject *, PyObject *args, PyObject *kwargs) {
15149 PyObject *resultobj;
15150 wxEvent *arg1 = (wxEvent *) 0 ;
15151 long arg2 = (long) 0 ;
15152 PyObject * obj0 = 0 ;
15153 PyObject * obj1 = 0 ;
15154 char *kwnames[] = {
15155 (char *) "self",(char *) "ts", NULL
15156 };
15157
15158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) goto fail;
15159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15160 if (SWIG_arg_fail(1)) SWIG_fail;
15161 if (obj1) {
15162 {
15163 arg2 = (long)(SWIG_As_long(obj1));
15164 if (SWIG_arg_fail(2)) SWIG_fail;
15165 }
15166 }
15167 {
15168 PyThreadState* __tstate = wxPyBeginAllowThreads();
15169 (arg1)->SetTimestamp(arg2);
15170
15171 wxPyEndAllowThreads(__tstate);
15172 if (PyErr_Occurred()) SWIG_fail;
15173 }
15174 Py_INCREF(Py_None); resultobj = Py_None;
15175 return resultobj;
15176 fail:
15177 return NULL;
15178 }
15179
15180
15181 static PyObject *_wrap_Event_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
15182 PyObject *resultobj;
15183 wxEvent *arg1 = (wxEvent *) 0 ;
15184 int result;
15185 PyObject * obj0 = 0 ;
15186 char *kwnames[] = {
15187 (char *) "self", NULL
15188 };
15189
15190 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetId",kwnames,&obj0)) goto fail;
15191 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15192 if (SWIG_arg_fail(1)) SWIG_fail;
15193 {
15194 PyThreadState* __tstate = wxPyBeginAllowThreads();
15195 result = (int)((wxEvent const *)arg1)->GetId();
15196
15197 wxPyEndAllowThreads(__tstate);
15198 if (PyErr_Occurred()) SWIG_fail;
15199 }
15200 {
15201 resultobj = SWIG_From_int((int)(result));
15202 }
15203 return resultobj;
15204 fail:
15205 return NULL;
15206 }
15207
15208
15209 static PyObject *_wrap_Event_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
15210 PyObject *resultobj;
15211 wxEvent *arg1 = (wxEvent *) 0 ;
15212 int arg2 ;
15213 PyObject * obj0 = 0 ;
15214 PyObject * obj1 = 0 ;
15215 char *kwnames[] = {
15216 (char *) "self",(char *) "Id", NULL
15217 };
15218
15219 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) goto fail;
15220 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15221 if (SWIG_arg_fail(1)) SWIG_fail;
15222 {
15223 arg2 = (int)(SWIG_As_int(obj1));
15224 if (SWIG_arg_fail(2)) SWIG_fail;
15225 }
15226 {
15227 PyThreadState* __tstate = wxPyBeginAllowThreads();
15228 (arg1)->SetId(arg2);
15229
15230 wxPyEndAllowThreads(__tstate);
15231 if (PyErr_Occurred()) SWIG_fail;
15232 }
15233 Py_INCREF(Py_None); resultobj = Py_None;
15234 return resultobj;
15235 fail:
15236 return NULL;
15237 }
15238
15239
15240 static PyObject *_wrap_Event_IsCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15241 PyObject *resultobj;
15242 wxEvent *arg1 = (wxEvent *) 0 ;
15243 bool result;
15244 PyObject * obj0 = 0 ;
15245 char *kwnames[] = {
15246 (char *) "self", NULL
15247 };
15248
15249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_IsCommandEvent",kwnames,&obj0)) goto fail;
15250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15251 if (SWIG_arg_fail(1)) SWIG_fail;
15252 {
15253 PyThreadState* __tstate = wxPyBeginAllowThreads();
15254 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
15255
15256 wxPyEndAllowThreads(__tstate);
15257 if (PyErr_Occurred()) SWIG_fail;
15258 }
15259 {
15260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15261 }
15262 return resultobj;
15263 fail:
15264 return NULL;
15265 }
15266
15267
15268 static PyObject *_wrap_Event_Skip(PyObject *, PyObject *args, PyObject *kwargs) {
15269 PyObject *resultobj;
15270 wxEvent *arg1 = (wxEvent *) 0 ;
15271 bool arg2 = (bool) true ;
15272 PyObject * obj0 = 0 ;
15273 PyObject * obj1 = 0 ;
15274 char *kwnames[] = {
15275 (char *) "self",(char *) "skip", NULL
15276 };
15277
15278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) goto fail;
15279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15280 if (SWIG_arg_fail(1)) SWIG_fail;
15281 if (obj1) {
15282 {
15283 arg2 = (bool)(SWIG_As_bool(obj1));
15284 if (SWIG_arg_fail(2)) SWIG_fail;
15285 }
15286 }
15287 {
15288 PyThreadState* __tstate = wxPyBeginAllowThreads();
15289 (arg1)->Skip(arg2);
15290
15291 wxPyEndAllowThreads(__tstate);
15292 if (PyErr_Occurred()) SWIG_fail;
15293 }
15294 Py_INCREF(Py_None); resultobj = Py_None;
15295 return resultobj;
15296 fail:
15297 return NULL;
15298 }
15299
15300
15301 static PyObject *_wrap_Event_GetSkipped(PyObject *, PyObject *args, PyObject *kwargs) {
15302 PyObject *resultobj;
15303 wxEvent *arg1 = (wxEvent *) 0 ;
15304 bool result;
15305 PyObject * obj0 = 0 ;
15306 char *kwnames[] = {
15307 (char *) "self", NULL
15308 };
15309
15310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_GetSkipped",kwnames,&obj0)) goto fail;
15311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15312 if (SWIG_arg_fail(1)) SWIG_fail;
15313 {
15314 PyThreadState* __tstate = wxPyBeginAllowThreads();
15315 result = (bool)((wxEvent const *)arg1)->GetSkipped();
15316
15317 wxPyEndAllowThreads(__tstate);
15318 if (PyErr_Occurred()) SWIG_fail;
15319 }
15320 {
15321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15322 }
15323 return resultobj;
15324 fail:
15325 return NULL;
15326 }
15327
15328
15329 static PyObject *_wrap_Event_ShouldPropagate(PyObject *, PyObject *args, PyObject *kwargs) {
15330 PyObject *resultobj;
15331 wxEvent *arg1 = (wxEvent *) 0 ;
15332 bool result;
15333 PyObject * obj0 = 0 ;
15334 char *kwnames[] = {
15335 (char *) "self", NULL
15336 };
15337
15338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_ShouldPropagate",kwnames,&obj0)) goto fail;
15339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15340 if (SWIG_arg_fail(1)) SWIG_fail;
15341 {
15342 PyThreadState* __tstate = wxPyBeginAllowThreads();
15343 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
15344
15345 wxPyEndAllowThreads(__tstate);
15346 if (PyErr_Occurred()) SWIG_fail;
15347 }
15348 {
15349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15350 }
15351 return resultobj;
15352 fail:
15353 return NULL;
15354 }
15355
15356
15357 static PyObject *_wrap_Event_StopPropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15358 PyObject *resultobj;
15359 wxEvent *arg1 = (wxEvent *) 0 ;
15360 int result;
15361 PyObject * obj0 = 0 ;
15362 char *kwnames[] = {
15363 (char *) "self", NULL
15364 };
15365
15366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_StopPropagation",kwnames,&obj0)) goto fail;
15367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15368 if (SWIG_arg_fail(1)) SWIG_fail;
15369 {
15370 PyThreadState* __tstate = wxPyBeginAllowThreads();
15371 result = (int)(arg1)->StopPropagation();
15372
15373 wxPyEndAllowThreads(__tstate);
15374 if (PyErr_Occurred()) SWIG_fail;
15375 }
15376 {
15377 resultobj = SWIG_From_int((int)(result));
15378 }
15379 return resultobj;
15380 fail:
15381 return NULL;
15382 }
15383
15384
15385 static PyObject *_wrap_Event_ResumePropagation(PyObject *, PyObject *args, PyObject *kwargs) {
15386 PyObject *resultobj;
15387 wxEvent *arg1 = (wxEvent *) 0 ;
15388 int arg2 ;
15389 PyObject * obj0 = 0 ;
15390 PyObject * obj1 = 0 ;
15391 char *kwnames[] = {
15392 (char *) "self",(char *) "propagationLevel", NULL
15393 };
15394
15395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) goto fail;
15396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15397 if (SWIG_arg_fail(1)) SWIG_fail;
15398 {
15399 arg2 = (int)(SWIG_As_int(obj1));
15400 if (SWIG_arg_fail(2)) SWIG_fail;
15401 }
15402 {
15403 PyThreadState* __tstate = wxPyBeginAllowThreads();
15404 (arg1)->ResumePropagation(arg2);
15405
15406 wxPyEndAllowThreads(__tstate);
15407 if (PyErr_Occurred()) SWIG_fail;
15408 }
15409 Py_INCREF(Py_None); resultobj = Py_None;
15410 return resultobj;
15411 fail:
15412 return NULL;
15413 }
15414
15415
15416 static PyObject *_wrap_Event_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15417 PyObject *resultobj;
15418 wxEvent *arg1 = (wxEvent *) 0 ;
15419 wxEvent *result;
15420 PyObject * obj0 = 0 ;
15421 char *kwnames[] = {
15422 (char *) "self", NULL
15423 };
15424
15425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Event_Clone",kwnames,&obj0)) goto fail;
15426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15427 if (SWIG_arg_fail(1)) SWIG_fail;
15428 {
15429 PyThreadState* __tstate = wxPyBeginAllowThreads();
15430 result = (wxEvent *)(arg1)->Clone();
15431
15432 wxPyEndAllowThreads(__tstate);
15433 if (PyErr_Occurred()) SWIG_fail;
15434 }
15435 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15436 return resultobj;
15437 fail:
15438 return NULL;
15439 }
15440
15441
15442 static PyObject * Event_swigregister(PyObject *, PyObject *args) {
15443 PyObject *obj;
15444 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15445 SWIG_TypeClientData(SWIGTYPE_p_wxEvent, obj);
15446 Py_INCREF(obj);
15447 return Py_BuildValue((char *)"");
15448 }
15449 static PyObject *_wrap_new_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15450 PyObject *resultobj;
15451 wxEvent *arg1 = 0 ;
15452 wxPropagationDisabler *result;
15453 PyObject * obj0 = 0 ;
15454 char *kwnames[] = {
15455 (char *) "event", NULL
15456 };
15457
15458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) goto fail;
15459 {
15460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15461 if (SWIG_arg_fail(1)) SWIG_fail;
15462 if (arg1 == NULL) {
15463 SWIG_null_ref("wxEvent");
15464 }
15465 if (SWIG_arg_fail(1)) SWIG_fail;
15466 }
15467 {
15468 PyThreadState* __tstate = wxPyBeginAllowThreads();
15469 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
15470
15471 wxPyEndAllowThreads(__tstate);
15472 if (PyErr_Occurred()) SWIG_fail;
15473 }
15474 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagationDisabler, 1);
15475 return resultobj;
15476 fail:
15477 return NULL;
15478 }
15479
15480
15481 static PyObject *_wrap_delete_PropagationDisabler(PyObject *, PyObject *args, PyObject *kwargs) {
15482 PyObject *resultobj;
15483 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
15484 PyObject * obj0 = 0 ;
15485 char *kwnames[] = {
15486 (char *) "self", NULL
15487 };
15488
15489 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagationDisabler",kwnames,&obj0)) goto fail;
15490 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_EXCEPTION | 0);
15491 if (SWIG_arg_fail(1)) SWIG_fail;
15492 {
15493 PyThreadState* __tstate = wxPyBeginAllowThreads();
15494 delete arg1;
15495
15496 wxPyEndAllowThreads(__tstate);
15497 if (PyErr_Occurred()) SWIG_fail;
15498 }
15499 Py_INCREF(Py_None); resultobj = Py_None;
15500 return resultobj;
15501 fail:
15502 return NULL;
15503 }
15504
15505
15506 static PyObject * PropagationDisabler_swigregister(PyObject *, PyObject *args) {
15507 PyObject *obj;
15508 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15509 SWIG_TypeClientData(SWIGTYPE_p_wxPropagationDisabler, obj);
15510 Py_INCREF(obj);
15511 return Py_BuildValue((char *)"");
15512 }
15513 static PyObject *_wrap_new_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15514 PyObject *resultobj;
15515 wxEvent *arg1 = 0 ;
15516 wxPropagateOnce *result;
15517 PyObject * obj0 = 0 ;
15518 char *kwnames[] = {
15519 (char *) "event", NULL
15520 };
15521
15522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) goto fail;
15523 {
15524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
15525 if (SWIG_arg_fail(1)) SWIG_fail;
15526 if (arg1 == NULL) {
15527 SWIG_null_ref("wxEvent");
15528 }
15529 if (SWIG_arg_fail(1)) SWIG_fail;
15530 }
15531 {
15532 PyThreadState* __tstate = wxPyBeginAllowThreads();
15533 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
15534
15535 wxPyEndAllowThreads(__tstate);
15536 if (PyErr_Occurred()) SWIG_fail;
15537 }
15538 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPropagateOnce, 1);
15539 return resultobj;
15540 fail:
15541 return NULL;
15542 }
15543
15544
15545 static PyObject *_wrap_delete_PropagateOnce(PyObject *, PyObject *args, PyObject *kwargs) {
15546 PyObject *resultobj;
15547 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
15548 PyObject * obj0 = 0 ;
15549 char *kwnames[] = {
15550 (char *) "self", NULL
15551 };
15552
15553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PropagateOnce",kwnames,&obj0)) goto fail;
15554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_EXCEPTION | 0);
15555 if (SWIG_arg_fail(1)) SWIG_fail;
15556 {
15557 PyThreadState* __tstate = wxPyBeginAllowThreads();
15558 delete arg1;
15559
15560 wxPyEndAllowThreads(__tstate);
15561 if (PyErr_Occurred()) SWIG_fail;
15562 }
15563 Py_INCREF(Py_None); resultobj = Py_None;
15564 return resultobj;
15565 fail:
15566 return NULL;
15567 }
15568
15569
15570 static PyObject * PropagateOnce_swigregister(PyObject *, PyObject *args) {
15571 PyObject *obj;
15572 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15573 SWIG_TypeClientData(SWIGTYPE_p_wxPropagateOnce, obj);
15574 Py_INCREF(obj);
15575 return Py_BuildValue((char *)"");
15576 }
15577 static PyObject *_wrap_new_CommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15578 PyObject *resultobj;
15579 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15580 int arg2 = (int) 0 ;
15581 wxCommandEvent *result;
15582 PyObject * obj0 = 0 ;
15583 PyObject * obj1 = 0 ;
15584 char *kwnames[] = {
15585 (char *) "commandType",(char *) "winid", NULL
15586 };
15587
15588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) goto fail;
15589 if (obj0) {
15590 {
15591 arg1 = (wxEventType)(SWIG_As_int(obj0));
15592 if (SWIG_arg_fail(1)) SWIG_fail;
15593 }
15594 }
15595 if (obj1) {
15596 {
15597 arg2 = (int)(SWIG_As_int(obj1));
15598 if (SWIG_arg_fail(2)) SWIG_fail;
15599 }
15600 }
15601 {
15602 PyThreadState* __tstate = wxPyBeginAllowThreads();
15603 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
15604
15605 wxPyEndAllowThreads(__tstate);
15606 if (PyErr_Occurred()) SWIG_fail;
15607 }
15608 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCommandEvent, 1);
15609 return resultobj;
15610 fail:
15611 return NULL;
15612 }
15613
15614
15615 static PyObject *_wrap_CommandEvent_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15616 PyObject *resultobj;
15617 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15618 int result;
15619 PyObject * obj0 = 0 ;
15620 char *kwnames[] = {
15621 (char *) "self", NULL
15622 };
15623
15624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetSelection",kwnames,&obj0)) goto fail;
15625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15626 if (SWIG_arg_fail(1)) SWIG_fail;
15627 {
15628 PyThreadState* __tstate = wxPyBeginAllowThreads();
15629 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
15630
15631 wxPyEndAllowThreads(__tstate);
15632 if (PyErr_Occurred()) SWIG_fail;
15633 }
15634 {
15635 resultobj = SWIG_From_int((int)(result));
15636 }
15637 return resultobj;
15638 fail:
15639 return NULL;
15640 }
15641
15642
15643 static PyObject *_wrap_CommandEvent_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
15644 PyObject *resultobj;
15645 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15646 wxString *arg2 = 0 ;
15647 bool temp2 = false ;
15648 PyObject * obj0 = 0 ;
15649 PyObject * obj1 = 0 ;
15650 char *kwnames[] = {
15651 (char *) "self",(char *) "s", NULL
15652 };
15653
15654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) goto fail;
15655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15656 if (SWIG_arg_fail(1)) SWIG_fail;
15657 {
15658 arg2 = wxString_in_helper(obj1);
15659 if (arg2 == NULL) SWIG_fail;
15660 temp2 = true;
15661 }
15662 {
15663 PyThreadState* __tstate = wxPyBeginAllowThreads();
15664 (arg1)->SetString((wxString const &)*arg2);
15665
15666 wxPyEndAllowThreads(__tstate);
15667 if (PyErr_Occurred()) SWIG_fail;
15668 }
15669 Py_INCREF(Py_None); resultobj = Py_None;
15670 {
15671 if (temp2)
15672 delete arg2;
15673 }
15674 return resultobj;
15675 fail:
15676 {
15677 if (temp2)
15678 delete arg2;
15679 }
15680 return NULL;
15681 }
15682
15683
15684 static PyObject *_wrap_CommandEvent_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
15685 PyObject *resultobj;
15686 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15687 wxString result;
15688 PyObject * obj0 = 0 ;
15689 char *kwnames[] = {
15690 (char *) "self", NULL
15691 };
15692
15693 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetString",kwnames,&obj0)) goto fail;
15694 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15695 if (SWIG_arg_fail(1)) SWIG_fail;
15696 {
15697 PyThreadState* __tstate = wxPyBeginAllowThreads();
15698 result = ((wxCommandEvent const *)arg1)->GetString();
15699
15700 wxPyEndAllowThreads(__tstate);
15701 if (PyErr_Occurred()) SWIG_fail;
15702 }
15703 {
15704 #if wxUSE_UNICODE
15705 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
15706 #else
15707 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
15708 #endif
15709 }
15710 return resultobj;
15711 fail:
15712 return NULL;
15713 }
15714
15715
15716 static PyObject *_wrap_CommandEvent_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
15717 PyObject *resultobj;
15718 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15719 bool result;
15720 PyObject * obj0 = 0 ;
15721 char *kwnames[] = {
15722 (char *) "self", NULL
15723 };
15724
15725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsChecked",kwnames,&obj0)) goto fail;
15726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15727 if (SWIG_arg_fail(1)) SWIG_fail;
15728 {
15729 PyThreadState* __tstate = wxPyBeginAllowThreads();
15730 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
15731
15732 wxPyEndAllowThreads(__tstate);
15733 if (PyErr_Occurred()) SWIG_fail;
15734 }
15735 {
15736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15737 }
15738 return resultobj;
15739 fail:
15740 return NULL;
15741 }
15742
15743
15744 static PyObject *_wrap_CommandEvent_IsSelection(PyObject *, PyObject *args, PyObject *kwargs) {
15745 PyObject *resultobj;
15746 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15747 bool result;
15748 PyObject * obj0 = 0 ;
15749 char *kwnames[] = {
15750 (char *) "self", NULL
15751 };
15752
15753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_IsSelection",kwnames,&obj0)) goto fail;
15754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15755 if (SWIG_arg_fail(1)) SWIG_fail;
15756 {
15757 PyThreadState* __tstate = wxPyBeginAllowThreads();
15758 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
15759
15760 wxPyEndAllowThreads(__tstate);
15761 if (PyErr_Occurred()) SWIG_fail;
15762 }
15763 {
15764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15765 }
15766 return resultobj;
15767 fail:
15768 return NULL;
15769 }
15770
15771
15772 static PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15773 PyObject *resultobj;
15774 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15775 long arg2 ;
15776 PyObject * obj0 = 0 ;
15777 PyObject * obj1 = 0 ;
15778 char *kwnames[] = {
15779 (char *) "self",(char *) "extraLong", NULL
15780 };
15781
15782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) goto fail;
15783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15784 if (SWIG_arg_fail(1)) SWIG_fail;
15785 {
15786 arg2 = (long)(SWIG_As_long(obj1));
15787 if (SWIG_arg_fail(2)) SWIG_fail;
15788 }
15789 {
15790 PyThreadState* __tstate = wxPyBeginAllowThreads();
15791 (arg1)->SetExtraLong(arg2);
15792
15793 wxPyEndAllowThreads(__tstate);
15794 if (PyErr_Occurred()) SWIG_fail;
15795 }
15796 Py_INCREF(Py_None); resultobj = Py_None;
15797 return resultobj;
15798 fail:
15799 return NULL;
15800 }
15801
15802
15803 static PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *, PyObject *args, PyObject *kwargs) {
15804 PyObject *resultobj;
15805 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15806 long result;
15807 PyObject * obj0 = 0 ;
15808 char *kwnames[] = {
15809 (char *) "self", NULL
15810 };
15811
15812 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetExtraLong",kwnames,&obj0)) goto fail;
15813 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15814 if (SWIG_arg_fail(1)) SWIG_fail;
15815 {
15816 PyThreadState* __tstate = wxPyBeginAllowThreads();
15817 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
15818
15819 wxPyEndAllowThreads(__tstate);
15820 if (PyErr_Occurred()) SWIG_fail;
15821 }
15822 {
15823 resultobj = SWIG_From_long((long)(result));
15824 }
15825 return resultobj;
15826 fail:
15827 return NULL;
15828 }
15829
15830
15831 static PyObject *_wrap_CommandEvent_SetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15832 PyObject *resultobj;
15833 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15834 int arg2 ;
15835 PyObject * obj0 = 0 ;
15836 PyObject * obj1 = 0 ;
15837 char *kwnames[] = {
15838 (char *) "self",(char *) "i", NULL
15839 };
15840
15841 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) goto fail;
15842 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15843 if (SWIG_arg_fail(1)) SWIG_fail;
15844 {
15845 arg2 = (int)(SWIG_As_int(obj1));
15846 if (SWIG_arg_fail(2)) SWIG_fail;
15847 }
15848 {
15849 PyThreadState* __tstate = wxPyBeginAllowThreads();
15850 (arg1)->SetInt(arg2);
15851
15852 wxPyEndAllowThreads(__tstate);
15853 if (PyErr_Occurred()) SWIG_fail;
15854 }
15855 Py_INCREF(Py_None); resultobj = Py_None;
15856 return resultobj;
15857 fail:
15858 return NULL;
15859 }
15860
15861
15862 static PyObject *_wrap_CommandEvent_GetInt(PyObject *, PyObject *args, PyObject *kwargs) {
15863 PyObject *resultobj;
15864 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15865 long result;
15866 PyObject * obj0 = 0 ;
15867 char *kwnames[] = {
15868 (char *) "self", NULL
15869 };
15870
15871 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_GetInt",kwnames,&obj0)) goto fail;
15872 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15873 if (SWIG_arg_fail(1)) SWIG_fail;
15874 {
15875 PyThreadState* __tstate = wxPyBeginAllowThreads();
15876 result = (long)((wxCommandEvent const *)arg1)->GetInt();
15877
15878 wxPyEndAllowThreads(__tstate);
15879 if (PyErr_Occurred()) SWIG_fail;
15880 }
15881 {
15882 resultobj = SWIG_From_long((long)(result));
15883 }
15884 return resultobj;
15885 fail:
15886 return NULL;
15887 }
15888
15889
15890 static PyObject *_wrap_CommandEvent_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
15891 PyObject *resultobj;
15892 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
15893 wxEvent *result;
15894 PyObject * obj0 = 0 ;
15895 char *kwnames[] = {
15896 (char *) "self", NULL
15897 };
15898
15899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CommandEvent_Clone",kwnames,&obj0)) goto fail;
15900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
15901 if (SWIG_arg_fail(1)) SWIG_fail;
15902 {
15903 PyThreadState* __tstate = wxPyBeginAllowThreads();
15904 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
15905
15906 wxPyEndAllowThreads(__tstate);
15907 if (PyErr_Occurred()) SWIG_fail;
15908 }
15909 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEvent, 0);
15910 return resultobj;
15911 fail:
15912 return NULL;
15913 }
15914
15915
15916 static PyObject * CommandEvent_swigregister(PyObject *, PyObject *args) {
15917 PyObject *obj;
15918 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
15919 SWIG_TypeClientData(SWIGTYPE_p_wxCommandEvent, obj);
15920 Py_INCREF(obj);
15921 return Py_BuildValue((char *)"");
15922 }
15923 static PyObject *_wrap_new_NotifyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
15924 PyObject *resultobj;
15925 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
15926 int arg2 = (int) 0 ;
15927 wxNotifyEvent *result;
15928 PyObject * obj0 = 0 ;
15929 PyObject * obj1 = 0 ;
15930 char *kwnames[] = {
15931 (char *) "commandType",(char *) "winid", NULL
15932 };
15933
15934 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) goto fail;
15935 if (obj0) {
15936 {
15937 arg1 = (wxEventType)(SWIG_As_int(obj0));
15938 if (SWIG_arg_fail(1)) SWIG_fail;
15939 }
15940 }
15941 if (obj1) {
15942 {
15943 arg2 = (int)(SWIG_As_int(obj1));
15944 if (SWIG_arg_fail(2)) SWIG_fail;
15945 }
15946 }
15947 {
15948 PyThreadState* __tstate = wxPyBeginAllowThreads();
15949 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
15950
15951 wxPyEndAllowThreads(__tstate);
15952 if (PyErr_Occurred()) SWIG_fail;
15953 }
15954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNotifyEvent, 1);
15955 return resultobj;
15956 fail:
15957 return NULL;
15958 }
15959
15960
15961 static PyObject *_wrap_NotifyEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
15962 PyObject *resultobj;
15963 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15964 PyObject * obj0 = 0 ;
15965 char *kwnames[] = {
15966 (char *) "self", NULL
15967 };
15968
15969 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Veto",kwnames,&obj0)) goto fail;
15970 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15971 if (SWIG_arg_fail(1)) SWIG_fail;
15972 {
15973 PyThreadState* __tstate = wxPyBeginAllowThreads();
15974 (arg1)->Veto();
15975
15976 wxPyEndAllowThreads(__tstate);
15977 if (PyErr_Occurred()) SWIG_fail;
15978 }
15979 Py_INCREF(Py_None); resultobj = Py_None;
15980 return resultobj;
15981 fail:
15982 return NULL;
15983 }
15984
15985
15986 static PyObject *_wrap_NotifyEvent_Allow(PyObject *, PyObject *args, PyObject *kwargs) {
15987 PyObject *resultobj;
15988 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
15989 PyObject * obj0 = 0 ;
15990 char *kwnames[] = {
15991 (char *) "self", NULL
15992 };
15993
15994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_Allow",kwnames,&obj0)) goto fail;
15995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
15996 if (SWIG_arg_fail(1)) SWIG_fail;
15997 {
15998 PyThreadState* __tstate = wxPyBeginAllowThreads();
15999 (arg1)->Allow();
16000
16001 wxPyEndAllowThreads(__tstate);
16002 if (PyErr_Occurred()) SWIG_fail;
16003 }
16004 Py_INCREF(Py_None); resultobj = Py_None;
16005 return resultobj;
16006 fail:
16007 return NULL;
16008 }
16009
16010
16011 static PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *, PyObject *args, PyObject *kwargs) {
16012 PyObject *resultobj;
16013 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
16014 bool result;
16015 PyObject * obj0 = 0 ;
16016 char *kwnames[] = {
16017 (char *) "self", NULL
16018 };
16019
16020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NotifyEvent_IsAllowed",kwnames,&obj0)) goto fail;
16021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_EXCEPTION | 0);
16022 if (SWIG_arg_fail(1)) SWIG_fail;
16023 {
16024 PyThreadState* __tstate = wxPyBeginAllowThreads();
16025 result = (bool)(arg1)->IsAllowed();
16026
16027 wxPyEndAllowThreads(__tstate);
16028 if (PyErr_Occurred()) SWIG_fail;
16029 }
16030 {
16031 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16032 }
16033 return resultobj;
16034 fail:
16035 return NULL;
16036 }
16037
16038
16039 static PyObject * NotifyEvent_swigregister(PyObject *, PyObject *args) {
16040 PyObject *obj;
16041 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16042 SWIG_TypeClientData(SWIGTYPE_p_wxNotifyEvent, obj);
16043 Py_INCREF(obj);
16044 return Py_BuildValue((char *)"");
16045 }
16046 static PyObject *_wrap_new_ScrollEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16047 PyObject *resultobj;
16048 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16049 int arg2 = (int) 0 ;
16050 int arg3 = (int) 0 ;
16051 int arg4 = (int) 0 ;
16052 wxScrollEvent *result;
16053 PyObject * obj0 = 0 ;
16054 PyObject * obj1 = 0 ;
16055 PyObject * obj2 = 0 ;
16056 PyObject * obj3 = 0 ;
16057 char *kwnames[] = {
16058 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
16059 };
16060
16061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
16062 if (obj0) {
16063 {
16064 arg1 = (wxEventType)(SWIG_As_int(obj0));
16065 if (SWIG_arg_fail(1)) SWIG_fail;
16066 }
16067 }
16068 if (obj1) {
16069 {
16070 arg2 = (int)(SWIG_As_int(obj1));
16071 if (SWIG_arg_fail(2)) SWIG_fail;
16072 }
16073 }
16074 if (obj2) {
16075 {
16076 arg3 = (int)(SWIG_As_int(obj2));
16077 if (SWIG_arg_fail(3)) SWIG_fail;
16078 }
16079 }
16080 if (obj3) {
16081 {
16082 arg4 = (int)(SWIG_As_int(obj3));
16083 if (SWIG_arg_fail(4)) SWIG_fail;
16084 }
16085 }
16086 {
16087 PyThreadState* __tstate = wxPyBeginAllowThreads();
16088 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
16089
16090 wxPyEndAllowThreads(__tstate);
16091 if (PyErr_Occurred()) SWIG_fail;
16092 }
16093 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollEvent, 1);
16094 return resultobj;
16095 fail:
16096 return NULL;
16097 }
16098
16099
16100 static PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16101 PyObject *resultobj;
16102 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16103 int result;
16104 PyObject * obj0 = 0 ;
16105 char *kwnames[] = {
16106 (char *) "self", NULL
16107 };
16108
16109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetOrientation",kwnames,&obj0)) goto fail;
16110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16111 if (SWIG_arg_fail(1)) SWIG_fail;
16112 {
16113 PyThreadState* __tstate = wxPyBeginAllowThreads();
16114 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
16115
16116 wxPyEndAllowThreads(__tstate);
16117 if (PyErr_Occurred()) SWIG_fail;
16118 }
16119 {
16120 resultobj = SWIG_From_int((int)(result));
16121 }
16122 return resultobj;
16123 fail:
16124 return NULL;
16125 }
16126
16127
16128 static PyObject *_wrap_ScrollEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16129 PyObject *resultobj;
16130 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16131 int result;
16132 PyObject * obj0 = 0 ;
16133 char *kwnames[] = {
16134 (char *) "self", NULL
16135 };
16136
16137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollEvent_GetPosition",kwnames,&obj0)) goto fail;
16138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16139 if (SWIG_arg_fail(1)) SWIG_fail;
16140 {
16141 PyThreadState* __tstate = wxPyBeginAllowThreads();
16142 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
16143
16144 wxPyEndAllowThreads(__tstate);
16145 if (PyErr_Occurred()) SWIG_fail;
16146 }
16147 {
16148 resultobj = SWIG_From_int((int)(result));
16149 }
16150 return resultobj;
16151 fail:
16152 return NULL;
16153 }
16154
16155
16156 static PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16157 PyObject *resultobj;
16158 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16159 int arg2 ;
16160 PyObject * obj0 = 0 ;
16161 PyObject * obj1 = 0 ;
16162 char *kwnames[] = {
16163 (char *) "self",(char *) "orient", NULL
16164 };
16165
16166 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16167 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16168 if (SWIG_arg_fail(1)) SWIG_fail;
16169 {
16170 arg2 = (int)(SWIG_As_int(obj1));
16171 if (SWIG_arg_fail(2)) SWIG_fail;
16172 }
16173 {
16174 PyThreadState* __tstate = wxPyBeginAllowThreads();
16175 (arg1)->SetOrientation(arg2);
16176
16177 wxPyEndAllowThreads(__tstate);
16178 if (PyErr_Occurred()) SWIG_fail;
16179 }
16180 Py_INCREF(Py_None); resultobj = Py_None;
16181 return resultobj;
16182 fail:
16183 return NULL;
16184 }
16185
16186
16187 static PyObject *_wrap_ScrollEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16188 PyObject *resultobj;
16189 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
16190 int arg2 ;
16191 PyObject * obj0 = 0 ;
16192 PyObject * obj1 = 0 ;
16193 char *kwnames[] = {
16194 (char *) "self",(char *) "pos", NULL
16195 };
16196
16197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_EXCEPTION | 0);
16199 if (SWIG_arg_fail(1)) SWIG_fail;
16200 {
16201 arg2 = (int)(SWIG_As_int(obj1));
16202 if (SWIG_arg_fail(2)) SWIG_fail;
16203 }
16204 {
16205 PyThreadState* __tstate = wxPyBeginAllowThreads();
16206 (arg1)->SetPosition(arg2);
16207
16208 wxPyEndAllowThreads(__tstate);
16209 if (PyErr_Occurred()) SWIG_fail;
16210 }
16211 Py_INCREF(Py_None); resultobj = Py_None;
16212 return resultobj;
16213 fail:
16214 return NULL;
16215 }
16216
16217
16218 static PyObject * ScrollEvent_swigregister(PyObject *, PyObject *args) {
16219 PyObject *obj;
16220 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16221 SWIG_TypeClientData(SWIGTYPE_p_wxScrollEvent, obj);
16222 Py_INCREF(obj);
16223 return Py_BuildValue((char *)"");
16224 }
16225 static PyObject *_wrap_new_ScrollWinEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16226 PyObject *resultobj;
16227 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16228 int arg2 = (int) 0 ;
16229 int arg3 = (int) 0 ;
16230 wxScrollWinEvent *result;
16231 PyObject * obj0 = 0 ;
16232 PyObject * obj1 = 0 ;
16233 PyObject * obj2 = 0 ;
16234 char *kwnames[] = {
16235 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
16236 };
16237
16238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
16239 if (obj0) {
16240 {
16241 arg1 = (wxEventType)(SWIG_As_int(obj0));
16242 if (SWIG_arg_fail(1)) SWIG_fail;
16243 }
16244 }
16245 if (obj1) {
16246 {
16247 arg2 = (int)(SWIG_As_int(obj1));
16248 if (SWIG_arg_fail(2)) SWIG_fail;
16249 }
16250 }
16251 if (obj2) {
16252 {
16253 arg3 = (int)(SWIG_As_int(obj2));
16254 if (SWIG_arg_fail(3)) SWIG_fail;
16255 }
16256 }
16257 {
16258 PyThreadState* __tstate = wxPyBeginAllowThreads();
16259 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
16260
16261 wxPyEndAllowThreads(__tstate);
16262 if (PyErr_Occurred()) SWIG_fail;
16263 }
16264 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxScrollWinEvent, 1);
16265 return resultobj;
16266 fail:
16267 return NULL;
16268 }
16269
16270
16271 static PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16272 PyObject *resultobj;
16273 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16274 int result;
16275 PyObject * obj0 = 0 ;
16276 char *kwnames[] = {
16277 (char *) "self", NULL
16278 };
16279
16280 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetOrientation",kwnames,&obj0)) goto fail;
16281 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16282 if (SWIG_arg_fail(1)) SWIG_fail;
16283 {
16284 PyThreadState* __tstate = wxPyBeginAllowThreads();
16285 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
16286
16287 wxPyEndAllowThreads(__tstate);
16288 if (PyErr_Occurred()) SWIG_fail;
16289 }
16290 {
16291 resultobj = SWIG_From_int((int)(result));
16292 }
16293 return resultobj;
16294 fail:
16295 return NULL;
16296 }
16297
16298
16299 static PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16300 PyObject *resultobj;
16301 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16302 int result;
16303 PyObject * obj0 = 0 ;
16304 char *kwnames[] = {
16305 (char *) "self", NULL
16306 };
16307
16308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ScrollWinEvent_GetPosition",kwnames,&obj0)) goto fail;
16309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16310 if (SWIG_arg_fail(1)) SWIG_fail;
16311 {
16312 PyThreadState* __tstate = wxPyBeginAllowThreads();
16313 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
16314
16315 wxPyEndAllowThreads(__tstate);
16316 if (PyErr_Occurred()) SWIG_fail;
16317 }
16318 {
16319 resultobj = SWIG_From_int((int)(result));
16320 }
16321 return resultobj;
16322 fail:
16323 return NULL;
16324 }
16325
16326
16327 static PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
16328 PyObject *resultobj;
16329 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16330 int arg2 ;
16331 PyObject * obj0 = 0 ;
16332 PyObject * obj1 = 0 ;
16333 char *kwnames[] = {
16334 (char *) "self",(char *) "orient", NULL
16335 };
16336
16337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
16338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16339 if (SWIG_arg_fail(1)) SWIG_fail;
16340 {
16341 arg2 = (int)(SWIG_As_int(obj1));
16342 if (SWIG_arg_fail(2)) SWIG_fail;
16343 }
16344 {
16345 PyThreadState* __tstate = wxPyBeginAllowThreads();
16346 (arg1)->SetOrientation(arg2);
16347
16348 wxPyEndAllowThreads(__tstate);
16349 if (PyErr_Occurred()) SWIG_fail;
16350 }
16351 Py_INCREF(Py_None); resultobj = Py_None;
16352 return resultobj;
16353 fail:
16354 return NULL;
16355 }
16356
16357
16358 static PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
16359 PyObject *resultobj;
16360 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
16361 int arg2 ;
16362 PyObject * obj0 = 0 ;
16363 PyObject * obj1 = 0 ;
16364 char *kwnames[] = {
16365 (char *) "self",(char *) "pos", NULL
16366 };
16367
16368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
16369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_EXCEPTION | 0);
16370 if (SWIG_arg_fail(1)) SWIG_fail;
16371 {
16372 arg2 = (int)(SWIG_As_int(obj1));
16373 if (SWIG_arg_fail(2)) SWIG_fail;
16374 }
16375 {
16376 PyThreadState* __tstate = wxPyBeginAllowThreads();
16377 (arg1)->SetPosition(arg2);
16378
16379 wxPyEndAllowThreads(__tstate);
16380 if (PyErr_Occurred()) SWIG_fail;
16381 }
16382 Py_INCREF(Py_None); resultobj = Py_None;
16383 return resultobj;
16384 fail:
16385 return NULL;
16386 }
16387
16388
16389 static PyObject * ScrollWinEvent_swigregister(PyObject *, PyObject *args) {
16390 PyObject *obj;
16391 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
16392 SWIG_TypeClientData(SWIGTYPE_p_wxScrollWinEvent, obj);
16393 Py_INCREF(obj);
16394 return Py_BuildValue((char *)"");
16395 }
16396 static PyObject *_wrap_new_MouseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
16397 PyObject *resultobj;
16398 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
16399 wxMouseEvent *result;
16400 PyObject * obj0 = 0 ;
16401 char *kwnames[] = {
16402 (char *) "mouseType", NULL
16403 };
16404
16405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) goto fail;
16406 if (obj0) {
16407 {
16408 arg1 = (wxEventType)(SWIG_As_int(obj0));
16409 if (SWIG_arg_fail(1)) SWIG_fail;
16410 }
16411 }
16412 {
16413 PyThreadState* __tstate = wxPyBeginAllowThreads();
16414 result = (wxMouseEvent *)new wxMouseEvent(arg1);
16415
16416 wxPyEndAllowThreads(__tstate);
16417 if (PyErr_Occurred()) SWIG_fail;
16418 }
16419 {
16420 resultobj = wxPyMake_wxObject(result, 1);
16421 }
16422 return resultobj;
16423 fail:
16424 return NULL;
16425 }
16426
16427
16428 static PyObject *_wrap_MouseEvent_IsButton(PyObject *, PyObject *args, PyObject *kwargs) {
16429 PyObject *resultobj;
16430 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16431 bool result;
16432 PyObject * obj0 = 0 ;
16433 char *kwnames[] = {
16434 (char *) "self", NULL
16435 };
16436
16437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsButton",kwnames,&obj0)) goto fail;
16438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16439 if (SWIG_arg_fail(1)) SWIG_fail;
16440 {
16441 PyThreadState* __tstate = wxPyBeginAllowThreads();
16442 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
16443
16444 wxPyEndAllowThreads(__tstate);
16445 if (PyErr_Occurred()) SWIG_fail;
16446 }
16447 {
16448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16449 }
16450 return resultobj;
16451 fail:
16452 return NULL;
16453 }
16454
16455
16456 static PyObject *_wrap_MouseEvent_ButtonDown(PyObject *, PyObject *args, PyObject *kwargs) {
16457 PyObject *resultobj;
16458 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16459 int arg2 = (int) wxMOUSE_BTN_ANY ;
16460 bool result;
16461 PyObject * obj0 = 0 ;
16462 PyObject * obj1 = 0 ;
16463 char *kwnames[] = {
16464 (char *) "self",(char *) "but", NULL
16465 };
16466
16467 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) goto fail;
16468 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16469 if (SWIG_arg_fail(1)) SWIG_fail;
16470 if (obj1) {
16471 {
16472 arg2 = (int)(SWIG_As_int(obj1));
16473 if (SWIG_arg_fail(2)) SWIG_fail;
16474 }
16475 }
16476 {
16477 PyThreadState* __tstate = wxPyBeginAllowThreads();
16478 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
16479
16480 wxPyEndAllowThreads(__tstate);
16481 if (PyErr_Occurred()) SWIG_fail;
16482 }
16483 {
16484 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16485 }
16486 return resultobj;
16487 fail:
16488 return NULL;
16489 }
16490
16491
16492 static PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16493 PyObject *resultobj;
16494 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16495 int arg2 = (int) wxMOUSE_BTN_ANY ;
16496 bool result;
16497 PyObject * obj0 = 0 ;
16498 PyObject * obj1 = 0 ;
16499 char *kwnames[] = {
16500 (char *) "self",(char *) "but", NULL
16501 };
16502
16503 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) goto fail;
16504 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16505 if (SWIG_arg_fail(1)) SWIG_fail;
16506 if (obj1) {
16507 {
16508 arg2 = (int)(SWIG_As_int(obj1));
16509 if (SWIG_arg_fail(2)) SWIG_fail;
16510 }
16511 }
16512 {
16513 PyThreadState* __tstate = wxPyBeginAllowThreads();
16514 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
16515
16516 wxPyEndAllowThreads(__tstate);
16517 if (PyErr_Occurred()) SWIG_fail;
16518 }
16519 {
16520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16521 }
16522 return resultobj;
16523 fail:
16524 return NULL;
16525 }
16526
16527
16528 static PyObject *_wrap_MouseEvent_ButtonUp(PyObject *, PyObject *args, PyObject *kwargs) {
16529 PyObject *resultobj;
16530 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16531 int arg2 = (int) wxMOUSE_BTN_ANY ;
16532 bool result;
16533 PyObject * obj0 = 0 ;
16534 PyObject * obj1 = 0 ;
16535 char *kwnames[] = {
16536 (char *) "self",(char *) "but", NULL
16537 };
16538
16539 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) goto fail;
16540 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16541 if (SWIG_arg_fail(1)) SWIG_fail;
16542 if (obj1) {
16543 {
16544 arg2 = (int)(SWIG_As_int(obj1));
16545 if (SWIG_arg_fail(2)) SWIG_fail;
16546 }
16547 }
16548 {
16549 PyThreadState* __tstate = wxPyBeginAllowThreads();
16550 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
16551
16552 wxPyEndAllowThreads(__tstate);
16553 if (PyErr_Occurred()) SWIG_fail;
16554 }
16555 {
16556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16557 }
16558 return resultobj;
16559 fail:
16560 return NULL;
16561 }
16562
16563
16564 static PyObject *_wrap_MouseEvent_Button(PyObject *, PyObject *args, PyObject *kwargs) {
16565 PyObject *resultobj;
16566 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16567 int arg2 ;
16568 bool result;
16569 PyObject * obj0 = 0 ;
16570 PyObject * obj1 = 0 ;
16571 char *kwnames[] = {
16572 (char *) "self",(char *) "but", NULL
16573 };
16574
16575 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) goto fail;
16576 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16577 if (SWIG_arg_fail(1)) SWIG_fail;
16578 {
16579 arg2 = (int)(SWIG_As_int(obj1));
16580 if (SWIG_arg_fail(2)) SWIG_fail;
16581 }
16582 {
16583 PyThreadState* __tstate = wxPyBeginAllowThreads();
16584 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
16585
16586 wxPyEndAllowThreads(__tstate);
16587 if (PyErr_Occurred()) SWIG_fail;
16588 }
16589 {
16590 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16591 }
16592 return resultobj;
16593 fail:
16594 return NULL;
16595 }
16596
16597
16598 static PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
16599 PyObject *resultobj;
16600 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16601 int arg2 ;
16602 bool result;
16603 PyObject * obj0 = 0 ;
16604 PyObject * obj1 = 0 ;
16605 char *kwnames[] = {
16606 (char *) "self",(char *) "but", NULL
16607 };
16608
16609 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) goto fail;
16610 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16611 if (SWIG_arg_fail(1)) SWIG_fail;
16612 {
16613 arg2 = (int)(SWIG_As_int(obj1));
16614 if (SWIG_arg_fail(2)) SWIG_fail;
16615 }
16616 {
16617 PyThreadState* __tstate = wxPyBeginAllowThreads();
16618 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
16619
16620 wxPyEndAllowThreads(__tstate);
16621 if (PyErr_Occurred()) SWIG_fail;
16622 }
16623 {
16624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16625 }
16626 return resultobj;
16627 fail:
16628 return NULL;
16629 }
16630
16631
16632 static PyObject *_wrap_MouseEvent_GetButton(PyObject *, PyObject *args, PyObject *kwargs) {
16633 PyObject *resultobj;
16634 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16635 int result;
16636 PyObject * obj0 = 0 ;
16637 char *kwnames[] = {
16638 (char *) "self", NULL
16639 };
16640
16641 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetButton",kwnames,&obj0)) goto fail;
16642 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16643 if (SWIG_arg_fail(1)) SWIG_fail;
16644 {
16645 PyThreadState* __tstate = wxPyBeginAllowThreads();
16646 result = (int)((wxMouseEvent const *)arg1)->GetButton();
16647
16648 wxPyEndAllowThreads(__tstate);
16649 if (PyErr_Occurred()) SWIG_fail;
16650 }
16651 {
16652 resultobj = SWIG_From_int((int)(result));
16653 }
16654 return resultobj;
16655 fail:
16656 return NULL;
16657 }
16658
16659
16660 static PyObject *_wrap_MouseEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
16661 PyObject *resultobj;
16662 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16663 bool result;
16664 PyObject * obj0 = 0 ;
16665 char *kwnames[] = {
16666 (char *) "self", NULL
16667 };
16668
16669 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ControlDown",kwnames,&obj0)) goto fail;
16670 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16671 if (SWIG_arg_fail(1)) SWIG_fail;
16672 {
16673 PyThreadState* __tstate = wxPyBeginAllowThreads();
16674 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
16675
16676 wxPyEndAllowThreads(__tstate);
16677 if (PyErr_Occurred()) SWIG_fail;
16678 }
16679 {
16680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16681 }
16682 return resultobj;
16683 fail:
16684 return NULL;
16685 }
16686
16687
16688 static PyObject *_wrap_MouseEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
16689 PyObject *resultobj;
16690 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16691 bool result;
16692 PyObject * obj0 = 0 ;
16693 char *kwnames[] = {
16694 (char *) "self", NULL
16695 };
16696
16697 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MetaDown",kwnames,&obj0)) goto fail;
16698 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16699 if (SWIG_arg_fail(1)) SWIG_fail;
16700 {
16701 PyThreadState* __tstate = wxPyBeginAllowThreads();
16702 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
16703
16704 wxPyEndAllowThreads(__tstate);
16705 if (PyErr_Occurred()) SWIG_fail;
16706 }
16707 {
16708 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16709 }
16710 return resultobj;
16711 fail:
16712 return NULL;
16713 }
16714
16715
16716 static PyObject *_wrap_MouseEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
16717 PyObject *resultobj;
16718 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16719 bool result;
16720 PyObject * obj0 = 0 ;
16721 char *kwnames[] = {
16722 (char *) "self", NULL
16723 };
16724
16725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_AltDown",kwnames,&obj0)) goto fail;
16726 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16727 if (SWIG_arg_fail(1)) SWIG_fail;
16728 {
16729 PyThreadState* __tstate = wxPyBeginAllowThreads();
16730 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
16731
16732 wxPyEndAllowThreads(__tstate);
16733 if (PyErr_Occurred()) SWIG_fail;
16734 }
16735 {
16736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16737 }
16738 return resultobj;
16739 fail:
16740 return NULL;
16741 }
16742
16743
16744 static PyObject *_wrap_MouseEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16745 PyObject *resultobj;
16746 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16747 bool result;
16748 PyObject * obj0 = 0 ;
16749 char *kwnames[] = {
16750 (char *) "self", NULL
16751 };
16752
16753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_ShiftDown",kwnames,&obj0)) goto fail;
16754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16755 if (SWIG_arg_fail(1)) SWIG_fail;
16756 {
16757 PyThreadState* __tstate = wxPyBeginAllowThreads();
16758 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
16759
16760 wxPyEndAllowThreads(__tstate);
16761 if (PyErr_Occurred()) SWIG_fail;
16762 }
16763 {
16764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16765 }
16766 return resultobj;
16767 fail:
16768 return NULL;
16769 }
16770
16771
16772 static PyObject *_wrap_MouseEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
16773 PyObject *resultobj;
16774 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16775 bool result;
16776 PyObject * obj0 = 0 ;
16777 char *kwnames[] = {
16778 (char *) "self", NULL
16779 };
16780
16781 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_CmdDown",kwnames,&obj0)) goto fail;
16782 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16783 if (SWIG_arg_fail(1)) SWIG_fail;
16784 {
16785 PyThreadState* __tstate = wxPyBeginAllowThreads();
16786 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
16787
16788 wxPyEndAllowThreads(__tstate);
16789 if (PyErr_Occurred()) SWIG_fail;
16790 }
16791 {
16792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16793 }
16794 return resultobj;
16795 fail:
16796 return NULL;
16797 }
16798
16799
16800 static PyObject *_wrap_MouseEvent_LeftDown(PyObject *, PyObject *args, PyObject *kwargs) {
16801 PyObject *resultobj;
16802 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16803 bool result;
16804 PyObject * obj0 = 0 ;
16805 char *kwnames[] = {
16806 (char *) "self", NULL
16807 };
16808
16809 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDown",kwnames,&obj0)) goto fail;
16810 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16811 if (SWIG_arg_fail(1)) SWIG_fail;
16812 {
16813 PyThreadState* __tstate = wxPyBeginAllowThreads();
16814 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
16815
16816 wxPyEndAllowThreads(__tstate);
16817 if (PyErr_Occurred()) SWIG_fail;
16818 }
16819 {
16820 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16821 }
16822 return resultobj;
16823 fail:
16824 return NULL;
16825 }
16826
16827
16828 static PyObject *_wrap_MouseEvent_MiddleDown(PyObject *, PyObject *args, PyObject *kwargs) {
16829 PyObject *resultobj;
16830 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16831 bool result;
16832 PyObject * obj0 = 0 ;
16833 char *kwnames[] = {
16834 (char *) "self", NULL
16835 };
16836
16837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDown",kwnames,&obj0)) goto fail;
16838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16839 if (SWIG_arg_fail(1)) SWIG_fail;
16840 {
16841 PyThreadState* __tstate = wxPyBeginAllowThreads();
16842 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
16843
16844 wxPyEndAllowThreads(__tstate);
16845 if (PyErr_Occurred()) SWIG_fail;
16846 }
16847 {
16848 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16849 }
16850 return resultobj;
16851 fail:
16852 return NULL;
16853 }
16854
16855
16856 static PyObject *_wrap_MouseEvent_RightDown(PyObject *, PyObject *args, PyObject *kwargs) {
16857 PyObject *resultobj;
16858 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16859 bool result;
16860 PyObject * obj0 = 0 ;
16861 char *kwnames[] = {
16862 (char *) "self", NULL
16863 };
16864
16865 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDown",kwnames,&obj0)) goto fail;
16866 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16867 if (SWIG_arg_fail(1)) SWIG_fail;
16868 {
16869 PyThreadState* __tstate = wxPyBeginAllowThreads();
16870 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
16871
16872 wxPyEndAllowThreads(__tstate);
16873 if (PyErr_Occurred()) SWIG_fail;
16874 }
16875 {
16876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16877 }
16878 return resultobj;
16879 fail:
16880 return NULL;
16881 }
16882
16883
16884 static PyObject *_wrap_MouseEvent_LeftUp(PyObject *, PyObject *args, PyObject *kwargs) {
16885 PyObject *resultobj;
16886 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16887 bool result;
16888 PyObject * obj0 = 0 ;
16889 char *kwnames[] = {
16890 (char *) "self", NULL
16891 };
16892
16893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftUp",kwnames,&obj0)) goto fail;
16894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16895 if (SWIG_arg_fail(1)) SWIG_fail;
16896 {
16897 PyThreadState* __tstate = wxPyBeginAllowThreads();
16898 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
16899
16900 wxPyEndAllowThreads(__tstate);
16901 if (PyErr_Occurred()) SWIG_fail;
16902 }
16903 {
16904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16905 }
16906 return resultobj;
16907 fail:
16908 return NULL;
16909 }
16910
16911
16912 static PyObject *_wrap_MouseEvent_MiddleUp(PyObject *, PyObject *args, PyObject *kwargs) {
16913 PyObject *resultobj;
16914 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16915 bool result;
16916 PyObject * obj0 = 0 ;
16917 char *kwnames[] = {
16918 (char *) "self", NULL
16919 };
16920
16921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleUp",kwnames,&obj0)) goto fail;
16922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16923 if (SWIG_arg_fail(1)) SWIG_fail;
16924 {
16925 PyThreadState* __tstate = wxPyBeginAllowThreads();
16926 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
16927
16928 wxPyEndAllowThreads(__tstate);
16929 if (PyErr_Occurred()) SWIG_fail;
16930 }
16931 {
16932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16933 }
16934 return resultobj;
16935 fail:
16936 return NULL;
16937 }
16938
16939
16940 static PyObject *_wrap_MouseEvent_RightUp(PyObject *, PyObject *args, PyObject *kwargs) {
16941 PyObject *resultobj;
16942 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16943 bool result;
16944 PyObject * obj0 = 0 ;
16945 char *kwnames[] = {
16946 (char *) "self", NULL
16947 };
16948
16949 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightUp",kwnames,&obj0)) goto fail;
16950 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16951 if (SWIG_arg_fail(1)) SWIG_fail;
16952 {
16953 PyThreadState* __tstate = wxPyBeginAllowThreads();
16954 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
16955
16956 wxPyEndAllowThreads(__tstate);
16957 if (PyErr_Occurred()) SWIG_fail;
16958 }
16959 {
16960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16961 }
16962 return resultobj;
16963 fail:
16964 return NULL;
16965 }
16966
16967
16968 static PyObject *_wrap_MouseEvent_LeftDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16969 PyObject *resultobj;
16970 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16971 bool result;
16972 PyObject * obj0 = 0 ;
16973 char *kwnames[] = {
16974 (char *) "self", NULL
16975 };
16976
16977 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftDClick",kwnames,&obj0)) goto fail;
16978 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
16979 if (SWIG_arg_fail(1)) SWIG_fail;
16980 {
16981 PyThreadState* __tstate = wxPyBeginAllowThreads();
16982 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
16983
16984 wxPyEndAllowThreads(__tstate);
16985 if (PyErr_Occurred()) SWIG_fail;
16986 }
16987 {
16988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16989 }
16990 return resultobj;
16991 fail:
16992 return NULL;
16993 }
16994
16995
16996 static PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *, PyObject *args, PyObject *kwargs) {
16997 PyObject *resultobj;
16998 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
16999 bool result;
17000 PyObject * obj0 = 0 ;
17001 char *kwnames[] = {
17002 (char *) "self", NULL
17003 };
17004
17005 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleDClick",kwnames,&obj0)) goto fail;
17006 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17007 if (SWIG_arg_fail(1)) SWIG_fail;
17008 {
17009 PyThreadState* __tstate = wxPyBeginAllowThreads();
17010 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
17011
17012 wxPyEndAllowThreads(__tstate);
17013 if (PyErr_Occurred()) SWIG_fail;
17014 }
17015 {
17016 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17017 }
17018 return resultobj;
17019 fail:
17020 return NULL;
17021 }
17022
17023
17024 static PyObject *_wrap_MouseEvent_RightDClick(PyObject *, PyObject *args, PyObject *kwargs) {
17025 PyObject *resultobj;
17026 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17027 bool result;
17028 PyObject * obj0 = 0 ;
17029 char *kwnames[] = {
17030 (char *) "self", NULL
17031 };
17032
17033 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightDClick",kwnames,&obj0)) goto fail;
17034 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17035 if (SWIG_arg_fail(1)) SWIG_fail;
17036 {
17037 PyThreadState* __tstate = wxPyBeginAllowThreads();
17038 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
17039
17040 wxPyEndAllowThreads(__tstate);
17041 if (PyErr_Occurred()) SWIG_fail;
17042 }
17043 {
17044 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17045 }
17046 return resultobj;
17047 fail:
17048 return NULL;
17049 }
17050
17051
17052 static PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17053 PyObject *resultobj;
17054 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17055 bool result;
17056 PyObject * obj0 = 0 ;
17057 char *kwnames[] = {
17058 (char *) "self", NULL
17059 };
17060
17061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_LeftIsDown",kwnames,&obj0)) goto fail;
17062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17063 if (SWIG_arg_fail(1)) SWIG_fail;
17064 {
17065 PyThreadState* __tstate = wxPyBeginAllowThreads();
17066 result = (bool)(arg1)->LeftIsDown();
17067
17068 wxPyEndAllowThreads(__tstate);
17069 if (PyErr_Occurred()) SWIG_fail;
17070 }
17071 {
17072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17073 }
17074 return resultobj;
17075 fail:
17076 return NULL;
17077 }
17078
17079
17080 static PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17081 PyObject *resultobj;
17082 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17083 bool result;
17084 PyObject * obj0 = 0 ;
17085 char *kwnames[] = {
17086 (char *) "self", NULL
17087 };
17088
17089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_MiddleIsDown",kwnames,&obj0)) goto fail;
17090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17091 if (SWIG_arg_fail(1)) SWIG_fail;
17092 {
17093 PyThreadState* __tstate = wxPyBeginAllowThreads();
17094 result = (bool)(arg1)->MiddleIsDown();
17095
17096 wxPyEndAllowThreads(__tstate);
17097 if (PyErr_Occurred()) SWIG_fail;
17098 }
17099 {
17100 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17101 }
17102 return resultobj;
17103 fail:
17104 return NULL;
17105 }
17106
17107
17108 static PyObject *_wrap_MouseEvent_RightIsDown(PyObject *, PyObject *args, PyObject *kwargs) {
17109 PyObject *resultobj;
17110 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17111 bool result;
17112 PyObject * obj0 = 0 ;
17113 char *kwnames[] = {
17114 (char *) "self", NULL
17115 };
17116
17117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_RightIsDown",kwnames,&obj0)) goto fail;
17118 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17119 if (SWIG_arg_fail(1)) SWIG_fail;
17120 {
17121 PyThreadState* __tstate = wxPyBeginAllowThreads();
17122 result = (bool)(arg1)->RightIsDown();
17123
17124 wxPyEndAllowThreads(__tstate);
17125 if (PyErr_Occurred()) SWIG_fail;
17126 }
17127 {
17128 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17129 }
17130 return resultobj;
17131 fail:
17132 return NULL;
17133 }
17134
17135
17136 static PyObject *_wrap_MouseEvent_Dragging(PyObject *, PyObject *args, PyObject *kwargs) {
17137 PyObject *resultobj;
17138 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17139 bool result;
17140 PyObject * obj0 = 0 ;
17141 char *kwnames[] = {
17142 (char *) "self", NULL
17143 };
17144
17145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Dragging",kwnames,&obj0)) goto fail;
17146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17147 if (SWIG_arg_fail(1)) SWIG_fail;
17148 {
17149 PyThreadState* __tstate = wxPyBeginAllowThreads();
17150 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
17151
17152 wxPyEndAllowThreads(__tstate);
17153 if (PyErr_Occurred()) SWIG_fail;
17154 }
17155 {
17156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17157 }
17158 return resultobj;
17159 fail:
17160 return NULL;
17161 }
17162
17163
17164 static PyObject *_wrap_MouseEvent_Moving(PyObject *, PyObject *args, PyObject *kwargs) {
17165 PyObject *resultobj;
17166 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17167 bool result;
17168 PyObject * obj0 = 0 ;
17169 char *kwnames[] = {
17170 (char *) "self", NULL
17171 };
17172
17173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Moving",kwnames,&obj0)) goto fail;
17174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17175 if (SWIG_arg_fail(1)) SWIG_fail;
17176 {
17177 PyThreadState* __tstate = wxPyBeginAllowThreads();
17178 result = (bool)((wxMouseEvent const *)arg1)->Moving();
17179
17180 wxPyEndAllowThreads(__tstate);
17181 if (PyErr_Occurred()) SWIG_fail;
17182 }
17183 {
17184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17185 }
17186 return resultobj;
17187 fail:
17188 return NULL;
17189 }
17190
17191
17192 static PyObject *_wrap_MouseEvent_Entering(PyObject *, PyObject *args, PyObject *kwargs) {
17193 PyObject *resultobj;
17194 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17195 bool result;
17196 PyObject * obj0 = 0 ;
17197 char *kwnames[] = {
17198 (char *) "self", NULL
17199 };
17200
17201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Entering",kwnames,&obj0)) goto fail;
17202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17203 if (SWIG_arg_fail(1)) SWIG_fail;
17204 {
17205 PyThreadState* __tstate = wxPyBeginAllowThreads();
17206 result = (bool)((wxMouseEvent const *)arg1)->Entering();
17207
17208 wxPyEndAllowThreads(__tstate);
17209 if (PyErr_Occurred()) SWIG_fail;
17210 }
17211 {
17212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17213 }
17214 return resultobj;
17215 fail:
17216 return NULL;
17217 }
17218
17219
17220 static PyObject *_wrap_MouseEvent_Leaving(PyObject *, PyObject *args, PyObject *kwargs) {
17221 PyObject *resultobj;
17222 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17223 bool result;
17224 PyObject * obj0 = 0 ;
17225 char *kwnames[] = {
17226 (char *) "self", NULL
17227 };
17228
17229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_Leaving",kwnames,&obj0)) goto fail;
17230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17231 if (SWIG_arg_fail(1)) SWIG_fail;
17232 {
17233 PyThreadState* __tstate = wxPyBeginAllowThreads();
17234 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
17235
17236 wxPyEndAllowThreads(__tstate);
17237 if (PyErr_Occurred()) SWIG_fail;
17238 }
17239 {
17240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17241 }
17242 return resultobj;
17243 fail:
17244 return NULL;
17245 }
17246
17247
17248 static PyObject *_wrap_MouseEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17249 PyObject *resultobj;
17250 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17251 wxPoint result;
17252 PyObject * obj0 = 0 ;
17253 char *kwnames[] = {
17254 (char *) "self", NULL
17255 };
17256
17257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPosition",kwnames,&obj0)) goto fail;
17258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17259 if (SWIG_arg_fail(1)) SWIG_fail;
17260 {
17261 PyThreadState* __tstate = wxPyBeginAllowThreads();
17262 result = (arg1)->GetPosition();
17263
17264 wxPyEndAllowThreads(__tstate);
17265 if (PyErr_Occurred()) SWIG_fail;
17266 }
17267 {
17268 wxPoint * resultptr;
17269 resultptr = new wxPoint((wxPoint &)(result));
17270 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17271 }
17272 return resultobj;
17273 fail:
17274 return NULL;
17275 }
17276
17277
17278 static PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
17279 PyObject *resultobj;
17280 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17281 long *arg2 = (long *) 0 ;
17282 long *arg3 = (long *) 0 ;
17283 long temp2 ;
17284 int res2 = 0 ;
17285 long temp3 ;
17286 int res3 = 0 ;
17287 PyObject * obj0 = 0 ;
17288 char *kwnames[] = {
17289 (char *) "self", NULL
17290 };
17291
17292 arg2 = &temp2; res2 = SWIG_NEWOBJ;
17293 arg3 = &temp3; res3 = SWIG_NEWOBJ;
17294 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
17295 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17296 if (SWIG_arg_fail(1)) SWIG_fail;
17297 {
17298 PyThreadState* __tstate = wxPyBeginAllowThreads();
17299 (arg1)->GetPosition(arg2,arg3);
17300
17301 wxPyEndAllowThreads(__tstate);
17302 if (PyErr_Occurred()) SWIG_fail;
17303 }
17304 Py_INCREF(Py_None); resultobj = Py_None;
17305 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
17306 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
17307 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
17308 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
17309 return resultobj;
17310 fail:
17311 return NULL;
17312 }
17313
17314
17315 static PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *, PyObject *args, PyObject *kwargs) {
17316 PyObject *resultobj;
17317 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17318 wxDC *arg2 = 0 ;
17319 wxPoint result;
17320 PyObject * obj0 = 0 ;
17321 PyObject * obj1 = 0 ;
17322 char *kwnames[] = {
17323 (char *) "self",(char *) "dc", NULL
17324 };
17325
17326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) 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 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
17331 if (SWIG_arg_fail(2)) SWIG_fail;
17332 if (arg2 == NULL) {
17333 SWIG_null_ref("wxDC");
17334 }
17335 if (SWIG_arg_fail(2)) SWIG_fail;
17336 }
17337 {
17338 PyThreadState* __tstate = wxPyBeginAllowThreads();
17339 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
17340
17341 wxPyEndAllowThreads(__tstate);
17342 if (PyErr_Occurred()) SWIG_fail;
17343 }
17344 {
17345 wxPoint * resultptr;
17346 resultptr = new wxPoint((wxPoint &)(result));
17347 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
17348 }
17349 return resultobj;
17350 fail:
17351 return NULL;
17352 }
17353
17354
17355 static PyObject *_wrap_MouseEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
17356 PyObject *resultobj;
17357 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17358 int result;
17359 PyObject * obj0 = 0 ;
17360 char *kwnames[] = {
17361 (char *) "self", NULL
17362 };
17363
17364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetX",kwnames,&obj0)) goto fail;
17365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17366 if (SWIG_arg_fail(1)) SWIG_fail;
17367 {
17368 PyThreadState* __tstate = wxPyBeginAllowThreads();
17369 result = (int)((wxMouseEvent const *)arg1)->GetX();
17370
17371 wxPyEndAllowThreads(__tstate);
17372 if (PyErr_Occurred()) SWIG_fail;
17373 }
17374 {
17375 resultobj = SWIG_From_int((int)(result));
17376 }
17377 return resultobj;
17378 fail:
17379 return NULL;
17380 }
17381
17382
17383 static PyObject *_wrap_MouseEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
17384 PyObject *resultobj;
17385 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17386 int result;
17387 PyObject * obj0 = 0 ;
17388 char *kwnames[] = {
17389 (char *) "self", NULL
17390 };
17391
17392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetY",kwnames,&obj0)) goto fail;
17393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17394 if (SWIG_arg_fail(1)) SWIG_fail;
17395 {
17396 PyThreadState* __tstate = wxPyBeginAllowThreads();
17397 result = (int)((wxMouseEvent const *)arg1)->GetY();
17398
17399 wxPyEndAllowThreads(__tstate);
17400 if (PyErr_Occurred()) SWIG_fail;
17401 }
17402 {
17403 resultobj = SWIG_From_int((int)(result));
17404 }
17405 return resultobj;
17406 fail:
17407 return NULL;
17408 }
17409
17410
17411 static PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *, PyObject *args, PyObject *kwargs) {
17412 PyObject *resultobj;
17413 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17414 int result;
17415 PyObject * obj0 = 0 ;
17416 char *kwnames[] = {
17417 (char *) "self", NULL
17418 };
17419
17420 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelRotation",kwnames,&obj0)) goto fail;
17421 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17422 if (SWIG_arg_fail(1)) SWIG_fail;
17423 {
17424 PyThreadState* __tstate = wxPyBeginAllowThreads();
17425 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
17426
17427 wxPyEndAllowThreads(__tstate);
17428 if (PyErr_Occurred()) SWIG_fail;
17429 }
17430 {
17431 resultobj = SWIG_From_int((int)(result));
17432 }
17433 return resultobj;
17434 fail:
17435 return NULL;
17436 }
17437
17438
17439 static PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *, PyObject *args, PyObject *kwargs) {
17440 PyObject *resultobj;
17441 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17442 int result;
17443 PyObject * obj0 = 0 ;
17444 char *kwnames[] = {
17445 (char *) "self", NULL
17446 };
17447
17448 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetWheelDelta",kwnames,&obj0)) goto fail;
17449 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17450 if (SWIG_arg_fail(1)) SWIG_fail;
17451 {
17452 PyThreadState* __tstate = wxPyBeginAllowThreads();
17453 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
17454
17455 wxPyEndAllowThreads(__tstate);
17456 if (PyErr_Occurred()) SWIG_fail;
17457 }
17458 {
17459 resultobj = SWIG_From_int((int)(result));
17460 }
17461 return resultobj;
17462 fail:
17463 return NULL;
17464 }
17465
17466
17467 static PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *, PyObject *args, PyObject *kwargs) {
17468 PyObject *resultobj;
17469 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17470 int result;
17471 PyObject * obj0 = 0 ;
17472 char *kwnames[] = {
17473 (char *) "self", NULL
17474 };
17475
17476 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_GetLinesPerAction",kwnames,&obj0)) goto fail;
17477 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17478 if (SWIG_arg_fail(1)) SWIG_fail;
17479 {
17480 PyThreadState* __tstate = wxPyBeginAllowThreads();
17481 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
17482
17483 wxPyEndAllowThreads(__tstate);
17484 if (PyErr_Occurred()) SWIG_fail;
17485 }
17486 {
17487 resultobj = SWIG_From_int((int)(result));
17488 }
17489 return resultobj;
17490 fail:
17491 return NULL;
17492 }
17493
17494
17495 static PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *, PyObject *args, PyObject *kwargs) {
17496 PyObject *resultobj;
17497 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17498 bool result;
17499 PyObject * obj0 = 0 ;
17500 char *kwnames[] = {
17501 (char *) "self", NULL
17502 };
17503
17504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_IsPageScroll",kwnames,&obj0)) goto fail;
17505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17506 if (SWIG_arg_fail(1)) SWIG_fail;
17507 {
17508 PyThreadState* __tstate = wxPyBeginAllowThreads();
17509 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
17510
17511 wxPyEndAllowThreads(__tstate);
17512 if (PyErr_Occurred()) SWIG_fail;
17513 }
17514 {
17515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17516 }
17517 return resultobj;
17518 fail:
17519 return NULL;
17520 }
17521
17522
17523 static PyObject *_wrap_MouseEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
17524 PyObject *resultobj;
17525 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17526 int arg2 ;
17527 PyObject * obj0 = 0 ;
17528 PyObject * obj1 = 0 ;
17529 char *kwnames[] = {
17530 (char *) "self",(char *) "m_x", NULL
17531 };
17532
17533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
17534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17535 if (SWIG_arg_fail(1)) SWIG_fail;
17536 {
17537 arg2 = (int)(SWIG_As_int(obj1));
17538 if (SWIG_arg_fail(2)) SWIG_fail;
17539 }
17540 if (arg1) (arg1)->m_x = arg2;
17541
17542 Py_INCREF(Py_None); resultobj = Py_None;
17543 return resultobj;
17544 fail:
17545 return NULL;
17546 }
17547
17548
17549 static PyObject *_wrap_MouseEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
17550 PyObject *resultobj;
17551 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17552 int result;
17553 PyObject * obj0 = 0 ;
17554 char *kwnames[] = {
17555 (char *) "self", NULL
17556 };
17557
17558 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_x_get",kwnames,&obj0)) goto fail;
17559 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17560 if (SWIG_arg_fail(1)) SWIG_fail;
17561 result = (int) ((arg1)->m_x);
17562
17563 {
17564 resultobj = SWIG_From_int((int)(result));
17565 }
17566 return resultobj;
17567 fail:
17568 return NULL;
17569 }
17570
17571
17572 static PyObject *_wrap_MouseEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
17573 PyObject *resultobj;
17574 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17575 int arg2 ;
17576 PyObject * obj0 = 0 ;
17577 PyObject * obj1 = 0 ;
17578 char *kwnames[] = {
17579 (char *) "self",(char *) "m_y", NULL
17580 };
17581
17582 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
17583 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17584 if (SWIG_arg_fail(1)) SWIG_fail;
17585 {
17586 arg2 = (int)(SWIG_As_int(obj1));
17587 if (SWIG_arg_fail(2)) SWIG_fail;
17588 }
17589 if (arg1) (arg1)->m_y = arg2;
17590
17591 Py_INCREF(Py_None); resultobj = Py_None;
17592 return resultobj;
17593 fail:
17594 return NULL;
17595 }
17596
17597
17598 static PyObject *_wrap_MouseEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
17599 PyObject *resultobj;
17600 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17601 int result;
17602 PyObject * obj0 = 0 ;
17603 char *kwnames[] = {
17604 (char *) "self", NULL
17605 };
17606
17607 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_y_get",kwnames,&obj0)) goto fail;
17608 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17609 if (SWIG_arg_fail(1)) SWIG_fail;
17610 result = (int) ((arg1)->m_y);
17611
17612 {
17613 resultobj = SWIG_From_int((int)(result));
17614 }
17615 return resultobj;
17616 fail:
17617 return NULL;
17618 }
17619
17620
17621 static PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17622 PyObject *resultobj;
17623 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17624 bool arg2 ;
17625 PyObject * obj0 = 0 ;
17626 PyObject * obj1 = 0 ;
17627 char *kwnames[] = {
17628 (char *) "self",(char *) "m_leftDown", NULL
17629 };
17630
17631 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_leftDown_set",kwnames,&obj0,&obj1)) goto fail;
17632 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17633 if (SWIG_arg_fail(1)) SWIG_fail;
17634 {
17635 arg2 = (bool)(SWIG_As_bool(obj1));
17636 if (SWIG_arg_fail(2)) SWIG_fail;
17637 }
17638 if (arg1) (arg1)->m_leftDown = arg2;
17639
17640 Py_INCREF(Py_None); resultobj = Py_None;
17641 return resultobj;
17642 fail:
17643 return NULL;
17644 }
17645
17646
17647 static PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17648 PyObject *resultobj;
17649 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17650 bool result;
17651 PyObject * obj0 = 0 ;
17652 char *kwnames[] = {
17653 (char *) "self", NULL
17654 };
17655
17656 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_leftDown_get",kwnames,&obj0)) goto fail;
17657 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17658 if (SWIG_arg_fail(1)) SWIG_fail;
17659 result = (bool) ((arg1)->m_leftDown);
17660
17661 {
17662 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17663 }
17664 return resultobj;
17665 fail:
17666 return NULL;
17667 }
17668
17669
17670 static PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17671 PyObject *resultobj;
17672 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17673 bool arg2 ;
17674 PyObject * obj0 = 0 ;
17675 PyObject * obj1 = 0 ;
17676 char *kwnames[] = {
17677 (char *) "self",(char *) "m_middleDown", NULL
17678 };
17679
17680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_middleDown_set",kwnames,&obj0,&obj1)) goto fail;
17681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17682 if (SWIG_arg_fail(1)) SWIG_fail;
17683 {
17684 arg2 = (bool)(SWIG_As_bool(obj1));
17685 if (SWIG_arg_fail(2)) SWIG_fail;
17686 }
17687 if (arg1) (arg1)->m_middleDown = arg2;
17688
17689 Py_INCREF(Py_None); resultobj = Py_None;
17690 return resultobj;
17691 fail:
17692 return NULL;
17693 }
17694
17695
17696 static PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17697 PyObject *resultobj;
17698 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17699 bool result;
17700 PyObject * obj0 = 0 ;
17701 char *kwnames[] = {
17702 (char *) "self", NULL
17703 };
17704
17705 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_middleDown_get",kwnames,&obj0)) goto fail;
17706 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17707 if (SWIG_arg_fail(1)) SWIG_fail;
17708 result = (bool) ((arg1)->m_middleDown);
17709
17710 {
17711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17712 }
17713 return resultobj;
17714 fail:
17715 return NULL;
17716 }
17717
17718
17719 static PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17720 PyObject *resultobj;
17721 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17722 bool arg2 ;
17723 PyObject * obj0 = 0 ;
17724 PyObject * obj1 = 0 ;
17725 char *kwnames[] = {
17726 (char *) "self",(char *) "m_rightDown", NULL
17727 };
17728
17729 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_rightDown_set",kwnames,&obj0,&obj1)) goto fail;
17730 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17731 if (SWIG_arg_fail(1)) SWIG_fail;
17732 {
17733 arg2 = (bool)(SWIG_As_bool(obj1));
17734 if (SWIG_arg_fail(2)) SWIG_fail;
17735 }
17736 if (arg1) (arg1)->m_rightDown = arg2;
17737
17738 Py_INCREF(Py_None); resultobj = Py_None;
17739 return resultobj;
17740 fail:
17741 return NULL;
17742 }
17743
17744
17745 static PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17746 PyObject *resultobj;
17747 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17748 bool result;
17749 PyObject * obj0 = 0 ;
17750 char *kwnames[] = {
17751 (char *) "self", NULL
17752 };
17753
17754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_rightDown_get",kwnames,&obj0)) goto fail;
17755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17756 if (SWIG_arg_fail(1)) SWIG_fail;
17757 result = (bool) ((arg1)->m_rightDown);
17758
17759 {
17760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17761 }
17762 return resultobj;
17763 fail:
17764 return NULL;
17765 }
17766
17767
17768 static PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17769 PyObject *resultobj;
17770 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17771 bool arg2 ;
17772 PyObject * obj0 = 0 ;
17773 PyObject * obj1 = 0 ;
17774 char *kwnames[] = {
17775 (char *) "self",(char *) "m_controlDown", NULL
17776 };
17777
17778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
17779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17780 if (SWIG_arg_fail(1)) SWIG_fail;
17781 {
17782 arg2 = (bool)(SWIG_As_bool(obj1));
17783 if (SWIG_arg_fail(2)) SWIG_fail;
17784 }
17785 if (arg1) (arg1)->m_controlDown = arg2;
17786
17787 Py_INCREF(Py_None); resultobj = Py_None;
17788 return resultobj;
17789 fail:
17790 return NULL;
17791 }
17792
17793
17794 static PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17795 PyObject *resultobj;
17796 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17797 bool result;
17798 PyObject * obj0 = 0 ;
17799 char *kwnames[] = {
17800 (char *) "self", NULL
17801 };
17802
17803 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
17804 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17805 if (SWIG_arg_fail(1)) SWIG_fail;
17806 result = (bool) ((arg1)->m_controlDown);
17807
17808 {
17809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17810 }
17811 return resultobj;
17812 fail:
17813 return NULL;
17814 }
17815
17816
17817 static PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17818 PyObject *resultobj;
17819 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17820 bool arg2 ;
17821 PyObject * obj0 = 0 ;
17822 PyObject * obj1 = 0 ;
17823 char *kwnames[] = {
17824 (char *) "self",(char *) "m_shiftDown", NULL
17825 };
17826
17827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
17828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17829 if (SWIG_arg_fail(1)) SWIG_fail;
17830 {
17831 arg2 = (bool)(SWIG_As_bool(obj1));
17832 if (SWIG_arg_fail(2)) SWIG_fail;
17833 }
17834 if (arg1) (arg1)->m_shiftDown = arg2;
17835
17836 Py_INCREF(Py_None); resultobj = Py_None;
17837 return resultobj;
17838 fail:
17839 return NULL;
17840 }
17841
17842
17843 static PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17844 PyObject *resultobj;
17845 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17846 bool result;
17847 PyObject * obj0 = 0 ;
17848 char *kwnames[] = {
17849 (char *) "self", NULL
17850 };
17851
17852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
17853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17854 if (SWIG_arg_fail(1)) SWIG_fail;
17855 result = (bool) ((arg1)->m_shiftDown);
17856
17857 {
17858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17859 }
17860 return resultobj;
17861 fail:
17862 return NULL;
17863 }
17864
17865
17866 static PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17867 PyObject *resultobj;
17868 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17869 bool arg2 ;
17870 PyObject * obj0 = 0 ;
17871 PyObject * obj1 = 0 ;
17872 char *kwnames[] = {
17873 (char *) "self",(char *) "m_altDown", NULL
17874 };
17875
17876 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
17877 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17878 if (SWIG_arg_fail(1)) SWIG_fail;
17879 {
17880 arg2 = (bool)(SWIG_As_bool(obj1));
17881 if (SWIG_arg_fail(2)) SWIG_fail;
17882 }
17883 if (arg1) (arg1)->m_altDown = arg2;
17884
17885 Py_INCREF(Py_None); resultobj = Py_None;
17886 return resultobj;
17887 fail:
17888 return NULL;
17889 }
17890
17891
17892 static PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17893 PyObject *resultobj;
17894 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17895 bool result;
17896 PyObject * obj0 = 0 ;
17897 char *kwnames[] = {
17898 (char *) "self", NULL
17899 };
17900
17901 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_altDown_get",kwnames,&obj0)) goto fail;
17902 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17903 if (SWIG_arg_fail(1)) SWIG_fail;
17904 result = (bool) ((arg1)->m_altDown);
17905
17906 {
17907 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17908 }
17909 return resultobj;
17910 fail:
17911 return NULL;
17912 }
17913
17914
17915 static PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
17916 PyObject *resultobj;
17917 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17918 bool arg2 ;
17919 PyObject * obj0 = 0 ;
17920 PyObject * obj1 = 0 ;
17921 char *kwnames[] = {
17922 (char *) "self",(char *) "m_metaDown", NULL
17923 };
17924
17925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
17926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17927 if (SWIG_arg_fail(1)) SWIG_fail;
17928 {
17929 arg2 = (bool)(SWIG_As_bool(obj1));
17930 if (SWIG_arg_fail(2)) SWIG_fail;
17931 }
17932 if (arg1) (arg1)->m_metaDown = arg2;
17933
17934 Py_INCREF(Py_None); resultobj = Py_None;
17935 return resultobj;
17936 fail:
17937 return NULL;
17938 }
17939
17940
17941 static PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
17942 PyObject *resultobj;
17943 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17944 bool result;
17945 PyObject * obj0 = 0 ;
17946 char *kwnames[] = {
17947 (char *) "self", NULL
17948 };
17949
17950 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
17951 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17952 if (SWIG_arg_fail(1)) SWIG_fail;
17953 result = (bool) ((arg1)->m_metaDown);
17954
17955 {
17956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17957 }
17958 return resultobj;
17959 fail:
17960 return NULL;
17961 }
17962
17963
17964 static PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *, PyObject *args, PyObject *kwargs) {
17965 PyObject *resultobj;
17966 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17967 int arg2 ;
17968 PyObject * obj0 = 0 ;
17969 PyObject * obj1 = 0 ;
17970 char *kwnames[] = {
17971 (char *) "self",(char *) "m_wheelRotation", NULL
17972 };
17973
17974 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelRotation_set",kwnames,&obj0,&obj1)) goto fail;
17975 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
17976 if (SWIG_arg_fail(1)) SWIG_fail;
17977 {
17978 arg2 = (int)(SWIG_As_int(obj1));
17979 if (SWIG_arg_fail(2)) SWIG_fail;
17980 }
17981 if (arg1) (arg1)->m_wheelRotation = arg2;
17982
17983 Py_INCREF(Py_None); resultobj = Py_None;
17984 return resultobj;
17985 fail:
17986 return NULL;
17987 }
17988
17989
17990 static PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *, PyObject *args, PyObject *kwargs) {
17991 PyObject *resultobj;
17992 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
17993 int result;
17994 PyObject * obj0 = 0 ;
17995 char *kwnames[] = {
17996 (char *) "self", NULL
17997 };
17998
17999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelRotation_get",kwnames,&obj0)) goto fail;
18000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18001 if (SWIG_arg_fail(1)) SWIG_fail;
18002 result = (int) ((arg1)->m_wheelRotation);
18003
18004 {
18005 resultobj = SWIG_From_int((int)(result));
18006 }
18007 return resultobj;
18008 fail:
18009 return NULL;
18010 }
18011
18012
18013 static PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *, PyObject *args, PyObject *kwargs) {
18014 PyObject *resultobj;
18015 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18016 int arg2 ;
18017 PyObject * obj0 = 0 ;
18018 PyObject * obj1 = 0 ;
18019 char *kwnames[] = {
18020 (char *) "self",(char *) "m_wheelDelta", NULL
18021 };
18022
18023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_wheelDelta_set",kwnames,&obj0,&obj1)) goto fail;
18024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18025 if (SWIG_arg_fail(1)) SWIG_fail;
18026 {
18027 arg2 = (int)(SWIG_As_int(obj1));
18028 if (SWIG_arg_fail(2)) SWIG_fail;
18029 }
18030 if (arg1) (arg1)->m_wheelDelta = arg2;
18031
18032 Py_INCREF(Py_None); resultobj = Py_None;
18033 return resultobj;
18034 fail:
18035 return NULL;
18036 }
18037
18038
18039 static PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *, PyObject *args, PyObject *kwargs) {
18040 PyObject *resultobj;
18041 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18042 int result;
18043 PyObject * obj0 = 0 ;
18044 char *kwnames[] = {
18045 (char *) "self", NULL
18046 };
18047
18048 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_wheelDelta_get",kwnames,&obj0)) goto fail;
18049 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18050 if (SWIG_arg_fail(1)) SWIG_fail;
18051 result = (int) ((arg1)->m_wheelDelta);
18052
18053 {
18054 resultobj = SWIG_From_int((int)(result));
18055 }
18056 return resultobj;
18057 fail:
18058 return NULL;
18059 }
18060
18061
18062 static PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *, PyObject *args, PyObject *kwargs) {
18063 PyObject *resultobj;
18064 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18065 int arg2 ;
18066 PyObject * obj0 = 0 ;
18067 PyObject * obj1 = 0 ;
18068 char *kwnames[] = {
18069 (char *) "self",(char *) "m_linesPerAction", NULL
18070 };
18071
18072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_m_linesPerAction_set",kwnames,&obj0,&obj1)) goto fail;
18073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18074 if (SWIG_arg_fail(1)) SWIG_fail;
18075 {
18076 arg2 = (int)(SWIG_As_int(obj1));
18077 if (SWIG_arg_fail(2)) SWIG_fail;
18078 }
18079 if (arg1) (arg1)->m_linesPerAction = arg2;
18080
18081 Py_INCREF(Py_None); resultobj = Py_None;
18082 return resultobj;
18083 fail:
18084 return NULL;
18085 }
18086
18087
18088 static PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *, PyObject *args, PyObject *kwargs) {
18089 PyObject *resultobj;
18090 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
18091 int result;
18092 PyObject * obj0 = 0 ;
18093 char *kwnames[] = {
18094 (char *) "self", NULL
18095 };
18096
18097 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseEvent_m_linesPerAction_get",kwnames,&obj0)) goto fail;
18098 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_EXCEPTION | 0);
18099 if (SWIG_arg_fail(1)) SWIG_fail;
18100 result = (int) ((arg1)->m_linesPerAction);
18101
18102 {
18103 resultobj = SWIG_From_int((int)(result));
18104 }
18105 return resultobj;
18106 fail:
18107 return NULL;
18108 }
18109
18110
18111 static PyObject * MouseEvent_swigregister(PyObject *, PyObject *args) {
18112 PyObject *obj;
18113 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18114 SWIG_TypeClientData(SWIGTYPE_p_wxMouseEvent, obj);
18115 Py_INCREF(obj);
18116 return Py_BuildValue((char *)"");
18117 }
18118 static PyObject *_wrap_new_SetCursorEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18119 PyObject *resultobj;
18120 int arg1 = (int) 0 ;
18121 int arg2 = (int) 0 ;
18122 wxSetCursorEvent *result;
18123 PyObject * obj0 = 0 ;
18124 PyObject * obj1 = 0 ;
18125 char *kwnames[] = {
18126 (char *) "x",(char *) "y", NULL
18127 };
18128
18129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) goto fail;
18130 if (obj0) {
18131 {
18132 arg1 = (int)(SWIG_As_int(obj0));
18133 if (SWIG_arg_fail(1)) SWIG_fail;
18134 }
18135 }
18136 if (obj1) {
18137 {
18138 arg2 = (int)(SWIG_As_int(obj1));
18139 if (SWIG_arg_fail(2)) SWIG_fail;
18140 }
18141 }
18142 {
18143 PyThreadState* __tstate = wxPyBeginAllowThreads();
18144 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
18145
18146 wxPyEndAllowThreads(__tstate);
18147 if (PyErr_Occurred()) SWIG_fail;
18148 }
18149 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSetCursorEvent, 1);
18150 return resultobj;
18151 fail:
18152 return NULL;
18153 }
18154
18155
18156 static PyObject *_wrap_SetCursorEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18157 PyObject *resultobj;
18158 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18159 int result;
18160 PyObject * obj0 = 0 ;
18161 char *kwnames[] = {
18162 (char *) "self", NULL
18163 };
18164
18165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetX",kwnames,&obj0)) goto fail;
18166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18167 if (SWIG_arg_fail(1)) SWIG_fail;
18168 {
18169 PyThreadState* __tstate = wxPyBeginAllowThreads();
18170 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
18171
18172 wxPyEndAllowThreads(__tstate);
18173 if (PyErr_Occurred()) SWIG_fail;
18174 }
18175 {
18176 resultobj = SWIG_From_int((int)(result));
18177 }
18178 return resultobj;
18179 fail:
18180 return NULL;
18181 }
18182
18183
18184 static PyObject *_wrap_SetCursorEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18185 PyObject *resultobj;
18186 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18187 int result;
18188 PyObject * obj0 = 0 ;
18189 char *kwnames[] = {
18190 (char *) "self", NULL
18191 };
18192
18193 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetY",kwnames,&obj0)) goto fail;
18194 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18195 if (SWIG_arg_fail(1)) SWIG_fail;
18196 {
18197 PyThreadState* __tstate = wxPyBeginAllowThreads();
18198 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
18199
18200 wxPyEndAllowThreads(__tstate);
18201 if (PyErr_Occurred()) SWIG_fail;
18202 }
18203 {
18204 resultobj = SWIG_From_int((int)(result));
18205 }
18206 return resultobj;
18207 fail:
18208 return NULL;
18209 }
18210
18211
18212 static PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18213 PyObject *resultobj;
18214 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18215 wxCursor *arg2 = 0 ;
18216 PyObject * obj0 = 0 ;
18217 PyObject * obj1 = 0 ;
18218 char *kwnames[] = {
18219 (char *) "self",(char *) "cursor", NULL
18220 };
18221
18222 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) goto fail;
18223 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18224 if (SWIG_arg_fail(1)) SWIG_fail;
18225 {
18226 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
18227 if (SWIG_arg_fail(2)) SWIG_fail;
18228 if (arg2 == NULL) {
18229 SWIG_null_ref("wxCursor");
18230 }
18231 if (SWIG_arg_fail(2)) SWIG_fail;
18232 }
18233 {
18234 PyThreadState* __tstate = wxPyBeginAllowThreads();
18235 (arg1)->SetCursor((wxCursor const &)*arg2);
18236
18237 wxPyEndAllowThreads(__tstate);
18238 if (PyErr_Occurred()) SWIG_fail;
18239 }
18240 Py_INCREF(Py_None); resultobj = Py_None;
18241 return resultobj;
18242 fail:
18243 return NULL;
18244 }
18245
18246
18247 static PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18248 PyObject *resultobj;
18249 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18250 wxCursor *result;
18251 PyObject * obj0 = 0 ;
18252 char *kwnames[] = {
18253 (char *) "self", NULL
18254 };
18255
18256 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_GetCursor",kwnames,&obj0)) goto fail;
18257 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18258 if (SWIG_arg_fail(1)) SWIG_fail;
18259 {
18260 PyThreadState* __tstate = wxPyBeginAllowThreads();
18261 {
18262 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
18263 result = (wxCursor *) &_result_ref;
18264 }
18265
18266 wxPyEndAllowThreads(__tstate);
18267 if (PyErr_Occurred()) SWIG_fail;
18268 }
18269 {
18270 wxCursor* resultptr = new wxCursor(*result);
18271 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
18272 }
18273 return resultobj;
18274 fail:
18275 return NULL;
18276 }
18277
18278
18279 static PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *, PyObject *args, PyObject *kwargs) {
18280 PyObject *resultobj;
18281 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
18282 bool result;
18283 PyObject * obj0 = 0 ;
18284 char *kwnames[] = {
18285 (char *) "self", NULL
18286 };
18287
18288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetCursorEvent_HasCursor",kwnames,&obj0)) goto fail;
18289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_EXCEPTION | 0);
18290 if (SWIG_arg_fail(1)) SWIG_fail;
18291 {
18292 PyThreadState* __tstate = wxPyBeginAllowThreads();
18293 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
18294
18295 wxPyEndAllowThreads(__tstate);
18296 if (PyErr_Occurred()) SWIG_fail;
18297 }
18298 {
18299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18300 }
18301 return resultobj;
18302 fail:
18303 return NULL;
18304 }
18305
18306
18307 static PyObject * SetCursorEvent_swigregister(PyObject *, PyObject *args) {
18308 PyObject *obj;
18309 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
18310 SWIG_TypeClientData(SWIGTYPE_p_wxSetCursorEvent, obj);
18311 Py_INCREF(obj);
18312 return Py_BuildValue((char *)"");
18313 }
18314 static PyObject *_wrap_new_KeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
18315 PyObject *resultobj;
18316 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18317 wxKeyEvent *result;
18318 PyObject * obj0 = 0 ;
18319 char *kwnames[] = {
18320 (char *) "keyType", NULL
18321 };
18322
18323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) goto fail;
18324 if (obj0) {
18325 {
18326 arg1 = (wxEventType)(SWIG_As_int(obj0));
18327 if (SWIG_arg_fail(1)) SWIG_fail;
18328 }
18329 }
18330 {
18331 PyThreadState* __tstate = wxPyBeginAllowThreads();
18332 result = (wxKeyEvent *)new wxKeyEvent(arg1);
18333
18334 wxPyEndAllowThreads(__tstate);
18335 if (PyErr_Occurred()) SWIG_fail;
18336 }
18337 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxKeyEvent, 1);
18338 return resultobj;
18339 fail:
18340 return NULL;
18341 }
18342
18343
18344 static PyObject *_wrap_KeyEvent_ControlDown(PyObject *, PyObject *args, PyObject *kwargs) {
18345 PyObject *resultobj;
18346 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18347 bool result;
18348 PyObject * obj0 = 0 ;
18349 char *kwnames[] = {
18350 (char *) "self", NULL
18351 };
18352
18353 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ControlDown",kwnames,&obj0)) goto fail;
18354 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18355 if (SWIG_arg_fail(1)) SWIG_fail;
18356 {
18357 PyThreadState* __tstate = wxPyBeginAllowThreads();
18358 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
18359
18360 wxPyEndAllowThreads(__tstate);
18361 if (PyErr_Occurred()) SWIG_fail;
18362 }
18363 {
18364 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18365 }
18366 return resultobj;
18367 fail:
18368 return NULL;
18369 }
18370
18371
18372 static PyObject *_wrap_KeyEvent_MetaDown(PyObject *, PyObject *args, PyObject *kwargs) {
18373 PyObject *resultobj;
18374 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18375 bool result;
18376 PyObject * obj0 = 0 ;
18377 char *kwnames[] = {
18378 (char *) "self", NULL
18379 };
18380
18381 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_MetaDown",kwnames,&obj0)) goto fail;
18382 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18383 if (SWIG_arg_fail(1)) SWIG_fail;
18384 {
18385 PyThreadState* __tstate = wxPyBeginAllowThreads();
18386 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
18387
18388 wxPyEndAllowThreads(__tstate);
18389 if (PyErr_Occurred()) SWIG_fail;
18390 }
18391 {
18392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18393 }
18394 return resultobj;
18395 fail:
18396 return NULL;
18397 }
18398
18399
18400 static PyObject *_wrap_KeyEvent_AltDown(PyObject *, PyObject *args, PyObject *kwargs) {
18401 PyObject *resultobj;
18402 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18403 bool result;
18404 PyObject * obj0 = 0 ;
18405 char *kwnames[] = {
18406 (char *) "self", NULL
18407 };
18408
18409 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_AltDown",kwnames,&obj0)) goto fail;
18410 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18411 if (SWIG_arg_fail(1)) SWIG_fail;
18412 {
18413 PyThreadState* __tstate = wxPyBeginAllowThreads();
18414 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
18415
18416 wxPyEndAllowThreads(__tstate);
18417 if (PyErr_Occurred()) SWIG_fail;
18418 }
18419 {
18420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18421 }
18422 return resultobj;
18423 fail:
18424 return NULL;
18425 }
18426
18427
18428 static PyObject *_wrap_KeyEvent_ShiftDown(PyObject *, PyObject *args, PyObject *kwargs) {
18429 PyObject *resultobj;
18430 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18431 bool result;
18432 PyObject * obj0 = 0 ;
18433 char *kwnames[] = {
18434 (char *) "self", NULL
18435 };
18436
18437 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_ShiftDown",kwnames,&obj0)) goto fail;
18438 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18439 if (SWIG_arg_fail(1)) SWIG_fail;
18440 {
18441 PyThreadState* __tstate = wxPyBeginAllowThreads();
18442 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
18443
18444 wxPyEndAllowThreads(__tstate);
18445 if (PyErr_Occurred()) SWIG_fail;
18446 }
18447 {
18448 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18449 }
18450 return resultobj;
18451 fail:
18452 return NULL;
18453 }
18454
18455
18456 static PyObject *_wrap_KeyEvent_CmdDown(PyObject *, PyObject *args, PyObject *kwargs) {
18457 PyObject *resultobj;
18458 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18459 bool result;
18460 PyObject * obj0 = 0 ;
18461 char *kwnames[] = {
18462 (char *) "self", NULL
18463 };
18464
18465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_CmdDown",kwnames,&obj0)) goto fail;
18466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18467 if (SWIG_arg_fail(1)) SWIG_fail;
18468 {
18469 PyThreadState* __tstate = wxPyBeginAllowThreads();
18470 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
18471
18472 wxPyEndAllowThreads(__tstate);
18473 if (PyErr_Occurred()) SWIG_fail;
18474 }
18475 {
18476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18477 }
18478 return resultobj;
18479 fail:
18480 return NULL;
18481 }
18482
18483
18484 static PyObject *_wrap_KeyEvent_HasModifiers(PyObject *, PyObject *args, PyObject *kwargs) {
18485 PyObject *resultobj;
18486 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18487 bool result;
18488 PyObject * obj0 = 0 ;
18489 char *kwnames[] = {
18490 (char *) "self", NULL
18491 };
18492
18493 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_HasModifiers",kwnames,&obj0)) goto fail;
18494 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18495 if (SWIG_arg_fail(1)) SWIG_fail;
18496 {
18497 PyThreadState* __tstate = wxPyBeginAllowThreads();
18498 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
18499
18500 wxPyEndAllowThreads(__tstate);
18501 if (PyErr_Occurred()) SWIG_fail;
18502 }
18503 {
18504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18505 }
18506 return resultobj;
18507 fail:
18508 return NULL;
18509 }
18510
18511
18512 static PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18513 PyObject *resultobj;
18514 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18515 int result;
18516 PyObject * obj0 = 0 ;
18517 char *kwnames[] = {
18518 (char *) "self", NULL
18519 };
18520
18521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetKeyCode",kwnames,&obj0)) goto fail;
18522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18523 if (SWIG_arg_fail(1)) SWIG_fail;
18524 {
18525 PyThreadState* __tstate = wxPyBeginAllowThreads();
18526 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
18527
18528 wxPyEndAllowThreads(__tstate);
18529 if (PyErr_Occurred()) SWIG_fail;
18530 }
18531 {
18532 resultobj = SWIG_From_int((int)(result));
18533 }
18534 return resultobj;
18535 fail:
18536 return NULL;
18537 }
18538
18539
18540 static PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *, PyObject *args, PyObject *kwargs) {
18541 PyObject *resultobj;
18542 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18543 int result;
18544 PyObject * obj0 = 0 ;
18545 char *kwnames[] = {
18546 (char *) "self", NULL
18547 };
18548
18549 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetUnicodeKey",kwnames,&obj0)) goto fail;
18550 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18551 if (SWIG_arg_fail(1)) SWIG_fail;
18552 {
18553 PyThreadState* __tstate = wxPyBeginAllowThreads();
18554 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
18555
18556 wxPyEndAllowThreads(__tstate);
18557 if (PyErr_Occurred()) SWIG_fail;
18558 }
18559 {
18560 resultobj = SWIG_From_int((int)(result));
18561 }
18562 return resultobj;
18563 fail:
18564 return NULL;
18565 }
18566
18567
18568 static PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
18569 PyObject *resultobj;
18570 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18571 unsigned int result;
18572 PyObject * obj0 = 0 ;
18573 char *kwnames[] = {
18574 (char *) "self", NULL
18575 };
18576
18577 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyCode",kwnames,&obj0)) goto fail;
18578 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18579 if (SWIG_arg_fail(1)) SWIG_fail;
18580 {
18581 PyThreadState* __tstate = wxPyBeginAllowThreads();
18582 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
18583
18584 wxPyEndAllowThreads(__tstate);
18585 if (PyErr_Occurred()) SWIG_fail;
18586 }
18587 {
18588 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18589 }
18590 return resultobj;
18591 fail:
18592 return NULL;
18593 }
18594
18595
18596 static PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *, PyObject *args, PyObject *kwargs) {
18597 PyObject *resultobj;
18598 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18599 unsigned int result;
18600 PyObject * obj0 = 0 ;
18601 char *kwnames[] = {
18602 (char *) "self", NULL
18603 };
18604
18605 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetRawKeyFlags",kwnames,&obj0)) goto fail;
18606 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18607 if (SWIG_arg_fail(1)) SWIG_fail;
18608 {
18609 PyThreadState* __tstate = wxPyBeginAllowThreads();
18610 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
18611
18612 wxPyEndAllowThreads(__tstate);
18613 if (PyErr_Occurred()) SWIG_fail;
18614 }
18615 {
18616 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
18617 }
18618 return resultobj;
18619 fail:
18620 return NULL;
18621 }
18622
18623
18624 static PyObject *_wrap_KeyEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
18625 PyObject *resultobj;
18626 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18627 wxPoint result;
18628 PyObject * obj0 = 0 ;
18629 char *kwnames[] = {
18630 (char *) "self", NULL
18631 };
18632
18633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPosition",kwnames,&obj0)) goto fail;
18634 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18635 if (SWIG_arg_fail(1)) SWIG_fail;
18636 {
18637 PyThreadState* __tstate = wxPyBeginAllowThreads();
18638 result = (arg1)->GetPosition();
18639
18640 wxPyEndAllowThreads(__tstate);
18641 if (PyErr_Occurred()) SWIG_fail;
18642 }
18643 {
18644 wxPoint * resultptr;
18645 resultptr = new wxPoint((wxPoint &)(result));
18646 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
18647 }
18648 return resultobj;
18649 fail:
18650 return NULL;
18651 }
18652
18653
18654 static PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
18655 PyObject *resultobj;
18656 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18657 long *arg2 = (long *) 0 ;
18658 long *arg3 = (long *) 0 ;
18659 long temp2 ;
18660 int res2 = 0 ;
18661 long temp3 ;
18662 int res3 = 0 ;
18663 PyObject * obj0 = 0 ;
18664 char *kwnames[] = {
18665 (char *) "self", NULL
18666 };
18667
18668 arg2 = &temp2; res2 = SWIG_NEWOBJ;
18669 arg3 = &temp3; res3 = SWIG_NEWOBJ;
18670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetPositionTuple",kwnames,&obj0)) goto fail;
18671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18672 if (SWIG_arg_fail(1)) SWIG_fail;
18673 {
18674 PyThreadState* __tstate = wxPyBeginAllowThreads();
18675 (arg1)->GetPosition(arg2,arg3);
18676
18677 wxPyEndAllowThreads(__tstate);
18678 if (PyErr_Occurred()) SWIG_fail;
18679 }
18680 Py_INCREF(Py_None); resultobj = Py_None;
18681 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
18682 SWIG_From_long((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, 0)));
18683 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
18684 SWIG_From_long((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, 0)));
18685 return resultobj;
18686 fail:
18687 return NULL;
18688 }
18689
18690
18691 static PyObject *_wrap_KeyEvent_GetX(PyObject *, PyObject *args, PyObject *kwargs) {
18692 PyObject *resultobj;
18693 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18694 int result;
18695 PyObject * obj0 = 0 ;
18696 char *kwnames[] = {
18697 (char *) "self", NULL
18698 };
18699
18700 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetX",kwnames,&obj0)) goto fail;
18701 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18702 if (SWIG_arg_fail(1)) SWIG_fail;
18703 {
18704 PyThreadState* __tstate = wxPyBeginAllowThreads();
18705 result = (int)((wxKeyEvent const *)arg1)->GetX();
18706
18707 wxPyEndAllowThreads(__tstate);
18708 if (PyErr_Occurred()) SWIG_fail;
18709 }
18710 {
18711 resultobj = SWIG_From_int((int)(result));
18712 }
18713 return resultobj;
18714 fail:
18715 return NULL;
18716 }
18717
18718
18719 static PyObject *_wrap_KeyEvent_GetY(PyObject *, PyObject *args, PyObject *kwargs) {
18720 PyObject *resultobj;
18721 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18722 int result;
18723 PyObject * obj0 = 0 ;
18724 char *kwnames[] = {
18725 (char *) "self", NULL
18726 };
18727
18728 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_GetY",kwnames,&obj0)) goto fail;
18729 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18730 if (SWIG_arg_fail(1)) SWIG_fail;
18731 {
18732 PyThreadState* __tstate = wxPyBeginAllowThreads();
18733 result = (int)((wxKeyEvent const *)arg1)->GetY();
18734
18735 wxPyEndAllowThreads(__tstate);
18736 if (PyErr_Occurred()) SWIG_fail;
18737 }
18738 {
18739 resultobj = SWIG_From_int((int)(result));
18740 }
18741 return resultobj;
18742 fail:
18743 return NULL;
18744 }
18745
18746
18747 static PyObject *_wrap_KeyEvent_m_x_set(PyObject *, PyObject *args, PyObject *kwargs) {
18748 PyObject *resultobj;
18749 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18750 int arg2 ;
18751 PyObject * obj0 = 0 ;
18752 PyObject * obj1 = 0 ;
18753 char *kwnames[] = {
18754 (char *) "self",(char *) "m_x", NULL
18755 };
18756
18757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_x_set",kwnames,&obj0,&obj1)) goto fail;
18758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18759 if (SWIG_arg_fail(1)) SWIG_fail;
18760 {
18761 arg2 = (int)(SWIG_As_int(obj1));
18762 if (SWIG_arg_fail(2)) SWIG_fail;
18763 }
18764 if (arg1) (arg1)->m_x = arg2;
18765
18766 Py_INCREF(Py_None); resultobj = Py_None;
18767 return resultobj;
18768 fail:
18769 return NULL;
18770 }
18771
18772
18773 static PyObject *_wrap_KeyEvent_m_x_get(PyObject *, PyObject *args, PyObject *kwargs) {
18774 PyObject *resultobj;
18775 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18776 int result;
18777 PyObject * obj0 = 0 ;
18778 char *kwnames[] = {
18779 (char *) "self", NULL
18780 };
18781
18782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_x_get",kwnames,&obj0)) goto fail;
18783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18784 if (SWIG_arg_fail(1)) SWIG_fail;
18785 result = (int) ((arg1)->m_x);
18786
18787 {
18788 resultobj = SWIG_From_int((int)(result));
18789 }
18790 return resultobj;
18791 fail:
18792 return NULL;
18793 }
18794
18795
18796 static PyObject *_wrap_KeyEvent_m_y_set(PyObject *, PyObject *args, PyObject *kwargs) {
18797 PyObject *resultobj;
18798 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18799 int arg2 ;
18800 PyObject * obj0 = 0 ;
18801 PyObject * obj1 = 0 ;
18802 char *kwnames[] = {
18803 (char *) "self",(char *) "m_y", NULL
18804 };
18805
18806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_y_set",kwnames,&obj0,&obj1)) goto fail;
18807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18808 if (SWIG_arg_fail(1)) SWIG_fail;
18809 {
18810 arg2 = (int)(SWIG_As_int(obj1));
18811 if (SWIG_arg_fail(2)) SWIG_fail;
18812 }
18813 if (arg1) (arg1)->m_y = arg2;
18814
18815 Py_INCREF(Py_None); resultobj = Py_None;
18816 return resultobj;
18817 fail:
18818 return NULL;
18819 }
18820
18821
18822 static PyObject *_wrap_KeyEvent_m_y_get(PyObject *, PyObject *args, PyObject *kwargs) {
18823 PyObject *resultobj;
18824 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18825 int result;
18826 PyObject * obj0 = 0 ;
18827 char *kwnames[] = {
18828 (char *) "self", NULL
18829 };
18830
18831 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_y_get",kwnames,&obj0)) goto fail;
18832 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18833 if (SWIG_arg_fail(1)) SWIG_fail;
18834 result = (int) ((arg1)->m_y);
18835
18836 {
18837 resultobj = SWIG_From_int((int)(result));
18838 }
18839 return resultobj;
18840 fail:
18841 return NULL;
18842 }
18843
18844
18845 static PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
18846 PyObject *resultobj;
18847 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18848 long arg2 ;
18849 PyObject * obj0 = 0 ;
18850 PyObject * obj1 = 0 ;
18851 char *kwnames[] = {
18852 (char *) "self",(char *) "m_keyCode", NULL
18853 };
18854
18855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_keyCode_set",kwnames,&obj0,&obj1)) goto fail;
18856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18857 if (SWIG_arg_fail(1)) SWIG_fail;
18858 {
18859 arg2 = (long)(SWIG_As_long(obj1));
18860 if (SWIG_arg_fail(2)) SWIG_fail;
18861 }
18862 if (arg1) (arg1)->m_keyCode = arg2;
18863
18864 Py_INCREF(Py_None); resultobj = Py_None;
18865 return resultobj;
18866 fail:
18867 return NULL;
18868 }
18869
18870
18871 static PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
18872 PyObject *resultobj;
18873 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18874 long result;
18875 PyObject * obj0 = 0 ;
18876 char *kwnames[] = {
18877 (char *) "self", NULL
18878 };
18879
18880 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_keyCode_get",kwnames,&obj0)) goto fail;
18881 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18882 if (SWIG_arg_fail(1)) SWIG_fail;
18883 result = (long) ((arg1)->m_keyCode);
18884
18885 {
18886 resultobj = SWIG_From_long((long)(result));
18887 }
18888 return resultobj;
18889 fail:
18890 return NULL;
18891 }
18892
18893
18894 static PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18895 PyObject *resultobj;
18896 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18897 bool arg2 ;
18898 PyObject * obj0 = 0 ;
18899 PyObject * obj1 = 0 ;
18900 char *kwnames[] = {
18901 (char *) "self",(char *) "m_controlDown", NULL
18902 };
18903
18904 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_controlDown_set",kwnames,&obj0,&obj1)) goto fail;
18905 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18906 if (SWIG_arg_fail(1)) SWIG_fail;
18907 {
18908 arg2 = (bool)(SWIG_As_bool(obj1));
18909 if (SWIG_arg_fail(2)) SWIG_fail;
18910 }
18911 if (arg1) (arg1)->m_controlDown = arg2;
18912
18913 Py_INCREF(Py_None); resultobj = Py_None;
18914 return resultobj;
18915 fail:
18916 return NULL;
18917 }
18918
18919
18920 static PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18921 PyObject *resultobj;
18922 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18923 bool result;
18924 PyObject * obj0 = 0 ;
18925 char *kwnames[] = {
18926 (char *) "self", NULL
18927 };
18928
18929 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_controlDown_get",kwnames,&obj0)) goto fail;
18930 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18931 if (SWIG_arg_fail(1)) SWIG_fail;
18932 result = (bool) ((arg1)->m_controlDown);
18933
18934 {
18935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18936 }
18937 return resultobj;
18938 fail:
18939 return NULL;
18940 }
18941
18942
18943 static PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18944 PyObject *resultobj;
18945 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18946 bool arg2 ;
18947 PyObject * obj0 = 0 ;
18948 PyObject * obj1 = 0 ;
18949 char *kwnames[] = {
18950 (char *) "self",(char *) "m_shiftDown", NULL
18951 };
18952
18953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_shiftDown_set",kwnames,&obj0,&obj1)) goto fail;
18954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18955 if (SWIG_arg_fail(1)) SWIG_fail;
18956 {
18957 arg2 = (bool)(SWIG_As_bool(obj1));
18958 if (SWIG_arg_fail(2)) SWIG_fail;
18959 }
18960 if (arg1) (arg1)->m_shiftDown = arg2;
18961
18962 Py_INCREF(Py_None); resultobj = Py_None;
18963 return resultobj;
18964 fail:
18965 return NULL;
18966 }
18967
18968
18969 static PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
18970 PyObject *resultobj;
18971 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18972 bool result;
18973 PyObject * obj0 = 0 ;
18974 char *kwnames[] = {
18975 (char *) "self", NULL
18976 };
18977
18978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_shiftDown_get",kwnames,&obj0)) goto fail;
18979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
18980 if (SWIG_arg_fail(1)) SWIG_fail;
18981 result = (bool) ((arg1)->m_shiftDown);
18982
18983 {
18984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18985 }
18986 return resultobj;
18987 fail:
18988 return NULL;
18989 }
18990
18991
18992 static PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
18993 PyObject *resultobj;
18994 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
18995 bool arg2 ;
18996 PyObject * obj0 = 0 ;
18997 PyObject * obj1 = 0 ;
18998 char *kwnames[] = {
18999 (char *) "self",(char *) "m_altDown", NULL
19000 };
19001
19002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_altDown_set",kwnames,&obj0,&obj1)) goto fail;
19003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19004 if (SWIG_arg_fail(1)) SWIG_fail;
19005 {
19006 arg2 = (bool)(SWIG_As_bool(obj1));
19007 if (SWIG_arg_fail(2)) SWIG_fail;
19008 }
19009 if (arg1) (arg1)->m_altDown = arg2;
19010
19011 Py_INCREF(Py_None); resultobj = Py_None;
19012 return resultobj;
19013 fail:
19014 return NULL;
19015 }
19016
19017
19018 static PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19019 PyObject *resultobj;
19020 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19021 bool result;
19022 PyObject * obj0 = 0 ;
19023 char *kwnames[] = {
19024 (char *) "self", NULL
19025 };
19026
19027 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_altDown_get",kwnames,&obj0)) goto fail;
19028 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19029 if (SWIG_arg_fail(1)) SWIG_fail;
19030 result = (bool) ((arg1)->m_altDown);
19031
19032 {
19033 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19034 }
19035 return resultobj;
19036 fail:
19037 return NULL;
19038 }
19039
19040
19041 static PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *, PyObject *args, PyObject *kwargs) {
19042 PyObject *resultobj;
19043 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19044 bool arg2 ;
19045 PyObject * obj0 = 0 ;
19046 PyObject * obj1 = 0 ;
19047 char *kwnames[] = {
19048 (char *) "self",(char *) "m_metaDown", NULL
19049 };
19050
19051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_metaDown_set",kwnames,&obj0,&obj1)) goto fail;
19052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19053 if (SWIG_arg_fail(1)) SWIG_fail;
19054 {
19055 arg2 = (bool)(SWIG_As_bool(obj1));
19056 if (SWIG_arg_fail(2)) SWIG_fail;
19057 }
19058 if (arg1) (arg1)->m_metaDown = arg2;
19059
19060 Py_INCREF(Py_None); resultobj = Py_None;
19061 return resultobj;
19062 fail:
19063 return NULL;
19064 }
19065
19066
19067 static PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *, PyObject *args, PyObject *kwargs) {
19068 PyObject *resultobj;
19069 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19070 bool result;
19071 PyObject * obj0 = 0 ;
19072 char *kwnames[] = {
19073 (char *) "self", NULL
19074 };
19075
19076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_metaDown_get",kwnames,&obj0)) goto fail;
19077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19078 if (SWIG_arg_fail(1)) SWIG_fail;
19079 result = (bool) ((arg1)->m_metaDown);
19080
19081 {
19082 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19083 }
19084 return resultobj;
19085 fail:
19086 return NULL;
19087 }
19088
19089
19090 static PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19091 PyObject *resultobj;
19092 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19093 bool arg2 ;
19094 PyObject * obj0 = 0 ;
19095 PyObject * obj1 = 0 ;
19096 char *kwnames[] = {
19097 (char *) "self",(char *) "m_scanCode", NULL
19098 };
19099
19100 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_scanCode_set",kwnames,&obj0,&obj1)) goto fail;
19101 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19102 if (SWIG_arg_fail(1)) SWIG_fail;
19103 {
19104 arg2 = (bool)(SWIG_As_bool(obj1));
19105 if (SWIG_arg_fail(2)) SWIG_fail;
19106 }
19107 if (arg1) (arg1)->m_scanCode = arg2;
19108
19109 Py_INCREF(Py_None); resultobj = Py_None;
19110 return resultobj;
19111 fail:
19112 return NULL;
19113 }
19114
19115
19116 static PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19117 PyObject *resultobj;
19118 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19119 bool result;
19120 PyObject * obj0 = 0 ;
19121 char *kwnames[] = {
19122 (char *) "self", NULL
19123 };
19124
19125 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_scanCode_get",kwnames,&obj0)) goto fail;
19126 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19127 if (SWIG_arg_fail(1)) SWIG_fail;
19128 result = (bool) ((arg1)->m_scanCode);
19129
19130 {
19131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19132 }
19133 return resultobj;
19134 fail:
19135 return NULL;
19136 }
19137
19138
19139 static PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *, PyObject *args, PyObject *kwargs) {
19140 PyObject *resultobj;
19141 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19142 unsigned int arg2 ;
19143 PyObject * obj0 = 0 ;
19144 PyObject * obj1 = 0 ;
19145 char *kwnames[] = {
19146 (char *) "self",(char *) "m_rawCode", NULL
19147 };
19148
19149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawCode_set",kwnames,&obj0,&obj1)) goto fail;
19150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19151 if (SWIG_arg_fail(1)) SWIG_fail;
19152 {
19153 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19154 if (SWIG_arg_fail(2)) SWIG_fail;
19155 }
19156 if (arg1) (arg1)->m_rawCode = arg2;
19157
19158 Py_INCREF(Py_None); resultobj = Py_None;
19159 return resultobj;
19160 fail:
19161 return NULL;
19162 }
19163
19164
19165 static PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *, PyObject *args, PyObject *kwargs) {
19166 PyObject *resultobj;
19167 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19168 unsigned int result;
19169 PyObject * obj0 = 0 ;
19170 char *kwnames[] = {
19171 (char *) "self", NULL
19172 };
19173
19174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawCode_get",kwnames,&obj0)) goto fail;
19175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19176 if (SWIG_arg_fail(1)) SWIG_fail;
19177 result = (unsigned int) ((arg1)->m_rawCode);
19178
19179 {
19180 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19181 }
19182 return resultobj;
19183 fail:
19184 return NULL;
19185 }
19186
19187
19188 static PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *, PyObject *args, PyObject *kwargs) {
19189 PyObject *resultobj;
19190 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19191 unsigned int arg2 ;
19192 PyObject * obj0 = 0 ;
19193 PyObject * obj1 = 0 ;
19194 char *kwnames[] = {
19195 (char *) "self",(char *) "m_rawFlags", NULL
19196 };
19197
19198 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_m_rawFlags_set",kwnames,&obj0,&obj1)) goto fail;
19199 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19200 if (SWIG_arg_fail(1)) SWIG_fail;
19201 {
19202 arg2 = (unsigned int)(SWIG_As_unsigned_SS_int(obj1));
19203 if (SWIG_arg_fail(2)) SWIG_fail;
19204 }
19205 if (arg1) (arg1)->m_rawFlags = arg2;
19206
19207 Py_INCREF(Py_None); resultobj = Py_None;
19208 return resultobj;
19209 fail:
19210 return NULL;
19211 }
19212
19213
19214 static PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *, PyObject *args, PyObject *kwargs) {
19215 PyObject *resultobj;
19216 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
19217 unsigned int result;
19218 PyObject * obj0 = 0 ;
19219 char *kwnames[] = {
19220 (char *) "self", NULL
19221 };
19222
19223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:KeyEvent_m_rawFlags_get",kwnames,&obj0)) goto fail;
19224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_EXCEPTION | 0);
19225 if (SWIG_arg_fail(1)) SWIG_fail;
19226 result = (unsigned int) ((arg1)->m_rawFlags);
19227
19228 {
19229 resultobj = SWIG_From_unsigned_SS_int((unsigned int)(result));
19230 }
19231 return resultobj;
19232 fail:
19233 return NULL;
19234 }
19235
19236
19237 static PyObject * KeyEvent_swigregister(PyObject *, PyObject *args) {
19238 PyObject *obj;
19239 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19240 SWIG_TypeClientData(SWIGTYPE_p_wxKeyEvent, obj);
19241 Py_INCREF(obj);
19242 return Py_BuildValue((char *)"");
19243 }
19244 static PyObject *_wrap_new_SizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19245 PyObject *resultobj;
19246 wxSize const &arg1_defvalue = wxDefaultSize ;
19247 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
19248 int arg2 = (int) 0 ;
19249 wxSizeEvent *result;
19250 wxSize temp1 ;
19251 PyObject * obj0 = 0 ;
19252 PyObject * obj1 = 0 ;
19253 char *kwnames[] = {
19254 (char *) "sz",(char *) "winid", NULL
19255 };
19256
19257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) goto fail;
19258 if (obj0) {
19259 {
19260 arg1 = &temp1;
19261 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
19262 }
19263 }
19264 if (obj1) {
19265 {
19266 arg2 = (int)(SWIG_As_int(obj1));
19267 if (SWIG_arg_fail(2)) SWIG_fail;
19268 }
19269 }
19270 {
19271 PyThreadState* __tstate = wxPyBeginAllowThreads();
19272 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
19273
19274 wxPyEndAllowThreads(__tstate);
19275 if (PyErr_Occurred()) SWIG_fail;
19276 }
19277 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizeEvent, 1);
19278 return resultobj;
19279 fail:
19280 return NULL;
19281 }
19282
19283
19284 static PyObject *_wrap_SizeEvent_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19285 PyObject *resultobj;
19286 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19287 wxSize result;
19288 PyObject * obj0 = 0 ;
19289 char *kwnames[] = {
19290 (char *) "self", NULL
19291 };
19292
19293 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetSize",kwnames,&obj0)) goto fail;
19294 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19295 if (SWIG_arg_fail(1)) SWIG_fail;
19296 {
19297 PyThreadState* __tstate = wxPyBeginAllowThreads();
19298 result = ((wxSizeEvent const *)arg1)->GetSize();
19299
19300 wxPyEndAllowThreads(__tstate);
19301 if (PyErr_Occurred()) SWIG_fail;
19302 }
19303 {
19304 wxSize * resultptr;
19305 resultptr = new wxSize((wxSize &)(result));
19306 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
19307 }
19308 return resultobj;
19309 fail:
19310 return NULL;
19311 }
19312
19313
19314 static PyObject *_wrap_SizeEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19315 PyObject *resultobj;
19316 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19317 wxRect result;
19318 PyObject * obj0 = 0 ;
19319 char *kwnames[] = {
19320 (char *) "self", NULL
19321 };
19322
19323 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_GetRect",kwnames,&obj0)) goto fail;
19324 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19325 if (SWIG_arg_fail(1)) SWIG_fail;
19326 {
19327 PyThreadState* __tstate = wxPyBeginAllowThreads();
19328 result = ((wxSizeEvent const *)arg1)->GetRect();
19329
19330 wxPyEndAllowThreads(__tstate);
19331 if (PyErr_Occurred()) SWIG_fail;
19332 }
19333 {
19334 wxRect * resultptr;
19335 resultptr = new wxRect((wxRect &)(result));
19336 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19337 }
19338 return resultobj;
19339 fail:
19340 return NULL;
19341 }
19342
19343
19344 static PyObject *_wrap_SizeEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19345 PyObject *resultobj;
19346 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19347 wxRect arg2 ;
19348 PyObject * obj0 = 0 ;
19349 PyObject * obj1 = 0 ;
19350 char *kwnames[] = {
19351 (char *) "self",(char *) "rect", NULL
19352 };
19353
19354 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19355 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19356 if (SWIG_arg_fail(1)) SWIG_fail;
19357 {
19358 wxRect * argp;
19359 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION);
19360 if (SWIG_arg_fail(2)) SWIG_fail;
19361 if (argp == NULL) {
19362 SWIG_null_ref("wxRect");
19363 }
19364 if (SWIG_arg_fail(2)) SWIG_fail;
19365 arg2 = *argp;
19366 }
19367 {
19368 PyThreadState* __tstate = wxPyBeginAllowThreads();
19369 (arg1)->SetRect(arg2);
19370
19371 wxPyEndAllowThreads(__tstate);
19372 if (PyErr_Occurred()) SWIG_fail;
19373 }
19374 Py_INCREF(Py_None); resultobj = Py_None;
19375 return resultobj;
19376 fail:
19377 return NULL;
19378 }
19379
19380
19381 static PyObject *_wrap_SizeEvent_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
19382 PyObject *resultobj;
19383 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19384 wxSize arg2 ;
19385 PyObject * obj0 = 0 ;
19386 PyObject * obj1 = 0 ;
19387 char *kwnames[] = {
19388 (char *) "self",(char *) "size", NULL
19389 };
19390
19391 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) goto fail;
19392 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19393 if (SWIG_arg_fail(1)) SWIG_fail;
19394 {
19395 wxSize * argp;
19396 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
19397 if (SWIG_arg_fail(2)) SWIG_fail;
19398 if (argp == NULL) {
19399 SWIG_null_ref("wxSize");
19400 }
19401 if (SWIG_arg_fail(2)) SWIG_fail;
19402 arg2 = *argp;
19403 }
19404 {
19405 PyThreadState* __tstate = wxPyBeginAllowThreads();
19406 wxSizeEvent_SetSize(arg1,arg2);
19407
19408 wxPyEndAllowThreads(__tstate);
19409 if (PyErr_Occurred()) SWIG_fail;
19410 }
19411 Py_INCREF(Py_None); resultobj = Py_None;
19412 return resultobj;
19413 fail:
19414 return NULL;
19415 }
19416
19417
19418 static PyObject *_wrap_SizeEvent_m_size_set(PyObject *, PyObject *args, PyObject *kwargs) {
19419 PyObject *resultobj;
19420 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19421 wxSize *arg2 = (wxSize *) 0 ;
19422 PyObject * obj0 = 0 ;
19423 PyObject * obj1 = 0 ;
19424 char *kwnames[] = {
19425 (char *) "self",(char *) "m_size", NULL
19426 };
19427
19428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_size_set",kwnames,&obj0,&obj1)) goto fail;
19429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19430 if (SWIG_arg_fail(1)) SWIG_fail;
19431 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION | 0);
19432 if (SWIG_arg_fail(2)) SWIG_fail;
19433 if (arg1) (arg1)->m_size = *arg2;
19434
19435 Py_INCREF(Py_None); resultobj = Py_None;
19436 return resultobj;
19437 fail:
19438 return NULL;
19439 }
19440
19441
19442 static PyObject *_wrap_SizeEvent_m_size_get(PyObject *, PyObject *args, PyObject *kwargs) {
19443 PyObject *resultobj;
19444 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19445 wxSize *result;
19446 PyObject * obj0 = 0 ;
19447 char *kwnames[] = {
19448 (char *) "self", NULL
19449 };
19450
19451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_size_get",kwnames,&obj0)) goto fail;
19452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19453 if (SWIG_arg_fail(1)) SWIG_fail;
19454 result = (wxSize *)& ((arg1)->m_size);
19455
19456 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
19457 return resultobj;
19458 fail:
19459 return NULL;
19460 }
19461
19462
19463 static PyObject *_wrap_SizeEvent_m_rect_set(PyObject *, PyObject *args, PyObject *kwargs) {
19464 PyObject *resultobj;
19465 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19466 wxRect *arg2 = (wxRect *) 0 ;
19467 PyObject * obj0 = 0 ;
19468 PyObject * obj1 = 0 ;
19469 char *kwnames[] = {
19470 (char *) "self",(char *) "m_rect", NULL
19471 };
19472
19473 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_m_rect_set",kwnames,&obj0,&obj1)) goto fail;
19474 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19475 if (SWIG_arg_fail(1)) SWIG_fail;
19476 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
19477 if (SWIG_arg_fail(2)) SWIG_fail;
19478 if (arg1) (arg1)->m_rect = *arg2;
19479
19480 Py_INCREF(Py_None); resultobj = Py_None;
19481 return resultobj;
19482 fail:
19483 return NULL;
19484 }
19485
19486
19487 static PyObject *_wrap_SizeEvent_m_rect_get(PyObject *, PyObject *args, PyObject *kwargs) {
19488 PyObject *resultobj;
19489 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
19490 wxRect *result;
19491 PyObject * obj0 = 0 ;
19492 char *kwnames[] = {
19493 (char *) "self", NULL
19494 };
19495
19496 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizeEvent_m_rect_get",kwnames,&obj0)) goto fail;
19497 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_EXCEPTION | 0);
19498 if (SWIG_arg_fail(1)) SWIG_fail;
19499 result = (wxRect *)& ((arg1)->m_rect);
19500
19501 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRect, 0);
19502 return resultobj;
19503 fail:
19504 return NULL;
19505 }
19506
19507
19508 static PyObject * SizeEvent_swigregister(PyObject *, PyObject *args) {
19509 PyObject *obj;
19510 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19511 SWIG_TypeClientData(SWIGTYPE_p_wxSizeEvent, obj);
19512 Py_INCREF(obj);
19513 return Py_BuildValue((char *)"");
19514 }
19515 static PyObject *_wrap_new_MoveEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19516 PyObject *resultobj;
19517 wxPoint const &arg1_defvalue = wxDefaultPosition ;
19518 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
19519 int arg2 = (int) 0 ;
19520 wxMoveEvent *result;
19521 wxPoint temp1 ;
19522 PyObject * obj0 = 0 ;
19523 PyObject * obj1 = 0 ;
19524 char *kwnames[] = {
19525 (char *) "pos",(char *) "winid", NULL
19526 };
19527
19528 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) goto fail;
19529 if (obj0) {
19530 {
19531 arg1 = &temp1;
19532 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
19533 }
19534 }
19535 if (obj1) {
19536 {
19537 arg2 = (int)(SWIG_As_int(obj1));
19538 if (SWIG_arg_fail(2)) SWIG_fail;
19539 }
19540 }
19541 {
19542 PyThreadState* __tstate = wxPyBeginAllowThreads();
19543 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
19544
19545 wxPyEndAllowThreads(__tstate);
19546 if (PyErr_Occurred()) SWIG_fail;
19547 }
19548 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMoveEvent, 1);
19549 return resultobj;
19550 fail:
19551 return NULL;
19552 }
19553
19554
19555 static PyObject *_wrap_MoveEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19556 PyObject *resultobj;
19557 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19558 wxPoint result;
19559 PyObject * obj0 = 0 ;
19560 char *kwnames[] = {
19561 (char *) "self", NULL
19562 };
19563
19564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetPosition",kwnames,&obj0)) goto fail;
19565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19566 if (SWIG_arg_fail(1)) SWIG_fail;
19567 {
19568 PyThreadState* __tstate = wxPyBeginAllowThreads();
19569 result = ((wxMoveEvent const *)arg1)->GetPosition();
19570
19571 wxPyEndAllowThreads(__tstate);
19572 if (PyErr_Occurred()) SWIG_fail;
19573 }
19574 {
19575 wxPoint * resultptr;
19576 resultptr = new wxPoint((wxPoint &)(result));
19577 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
19578 }
19579 return resultobj;
19580 fail:
19581 return NULL;
19582 }
19583
19584
19585 static PyObject *_wrap_MoveEvent_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19586 PyObject *resultobj;
19587 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19588 wxRect result;
19589 PyObject * obj0 = 0 ;
19590 char *kwnames[] = {
19591 (char *) "self", NULL
19592 };
19593
19594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MoveEvent_GetRect",kwnames,&obj0)) goto fail;
19595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19596 if (SWIG_arg_fail(1)) SWIG_fail;
19597 {
19598 PyThreadState* __tstate = wxPyBeginAllowThreads();
19599 result = ((wxMoveEvent const *)arg1)->GetRect();
19600
19601 wxPyEndAllowThreads(__tstate);
19602 if (PyErr_Occurred()) SWIG_fail;
19603 }
19604 {
19605 wxRect * resultptr;
19606 resultptr = new wxRect((wxRect &)(result));
19607 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
19608 }
19609 return resultobj;
19610 fail:
19611 return NULL;
19612 }
19613
19614
19615 static PyObject *_wrap_MoveEvent_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
19616 PyObject *resultobj;
19617 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19618 wxRect *arg2 = 0 ;
19619 wxRect temp2 ;
19620 PyObject * obj0 = 0 ;
19621 PyObject * obj1 = 0 ;
19622 char *kwnames[] = {
19623 (char *) "self",(char *) "rect", NULL
19624 };
19625
19626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) goto fail;
19627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19628 if (SWIG_arg_fail(1)) SWIG_fail;
19629 {
19630 arg2 = &temp2;
19631 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
19632 }
19633 {
19634 PyThreadState* __tstate = wxPyBeginAllowThreads();
19635 (arg1)->SetRect((wxRect const &)*arg2);
19636
19637 wxPyEndAllowThreads(__tstate);
19638 if (PyErr_Occurred()) SWIG_fail;
19639 }
19640 Py_INCREF(Py_None); resultobj = Py_None;
19641 return resultobj;
19642 fail:
19643 return NULL;
19644 }
19645
19646
19647 static PyObject *_wrap_MoveEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
19648 PyObject *resultobj;
19649 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
19650 wxPoint *arg2 = 0 ;
19651 wxPoint temp2 ;
19652 PyObject * obj0 = 0 ;
19653 PyObject * obj1 = 0 ;
19654 char *kwnames[] = {
19655 (char *) "self",(char *) "pos", NULL
19656 };
19657
19658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
19659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_EXCEPTION | 0);
19660 if (SWIG_arg_fail(1)) SWIG_fail;
19661 {
19662 arg2 = &temp2;
19663 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
19664 }
19665 {
19666 PyThreadState* __tstate = wxPyBeginAllowThreads();
19667 (arg1)->SetPosition((wxPoint const &)*arg2);
19668
19669 wxPyEndAllowThreads(__tstate);
19670 if (PyErr_Occurred()) SWIG_fail;
19671 }
19672 Py_INCREF(Py_None); resultobj = Py_None;
19673 return resultobj;
19674 fail:
19675 return NULL;
19676 }
19677
19678
19679 static PyObject * MoveEvent_swigregister(PyObject *, PyObject *args) {
19680 PyObject *obj;
19681 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19682 SWIG_TypeClientData(SWIGTYPE_p_wxMoveEvent, obj);
19683 Py_INCREF(obj);
19684 return Py_BuildValue((char *)"");
19685 }
19686 static PyObject *_wrap_new_PaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19687 PyObject *resultobj;
19688 int arg1 = (int) 0 ;
19689 wxPaintEvent *result;
19690 PyObject * obj0 = 0 ;
19691 char *kwnames[] = {
19692 (char *) "Id", NULL
19693 };
19694
19695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) goto fail;
19696 if (obj0) {
19697 {
19698 arg1 = (int)(SWIG_As_int(obj0));
19699 if (SWIG_arg_fail(1)) SWIG_fail;
19700 }
19701 }
19702 {
19703 PyThreadState* __tstate = wxPyBeginAllowThreads();
19704 result = (wxPaintEvent *)new wxPaintEvent(arg1);
19705
19706 wxPyEndAllowThreads(__tstate);
19707 if (PyErr_Occurred()) SWIG_fail;
19708 }
19709 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaintEvent, 1);
19710 return resultobj;
19711 fail:
19712 return NULL;
19713 }
19714
19715
19716 static PyObject * PaintEvent_swigregister(PyObject *, PyObject *args) {
19717 PyObject *obj;
19718 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19719 SWIG_TypeClientData(SWIGTYPE_p_wxPaintEvent, obj);
19720 Py_INCREF(obj);
19721 return Py_BuildValue((char *)"");
19722 }
19723 static PyObject *_wrap_new_NcPaintEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19724 PyObject *resultobj;
19725 int arg1 = (int) 0 ;
19726 wxNcPaintEvent *result;
19727 PyObject * obj0 = 0 ;
19728 char *kwnames[] = {
19729 (char *) "winid", NULL
19730 };
19731
19732 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) goto fail;
19733 if (obj0) {
19734 {
19735 arg1 = (int)(SWIG_As_int(obj0));
19736 if (SWIG_arg_fail(1)) SWIG_fail;
19737 }
19738 }
19739 {
19740 PyThreadState* __tstate = wxPyBeginAllowThreads();
19741 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
19742
19743 wxPyEndAllowThreads(__tstate);
19744 if (PyErr_Occurred()) SWIG_fail;
19745 }
19746 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNcPaintEvent, 1);
19747 return resultobj;
19748 fail:
19749 return NULL;
19750 }
19751
19752
19753 static PyObject * NcPaintEvent_swigregister(PyObject *, PyObject *args) {
19754 PyObject *obj;
19755 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19756 SWIG_TypeClientData(SWIGTYPE_p_wxNcPaintEvent, obj);
19757 Py_INCREF(obj);
19758 return Py_BuildValue((char *)"");
19759 }
19760 static PyObject *_wrap_new_EraseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19761 PyObject *resultobj;
19762 int arg1 = (int) 0 ;
19763 wxDC *arg2 = (wxDC *) (wxDC *) NULL ;
19764 wxEraseEvent *result;
19765 PyObject * obj0 = 0 ;
19766 PyObject * obj1 = 0 ;
19767 char *kwnames[] = {
19768 (char *) "Id",(char *) "dc", NULL
19769 };
19770
19771 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) goto fail;
19772 if (obj0) {
19773 {
19774 arg1 = (int)(SWIG_As_int(obj0));
19775 if (SWIG_arg_fail(1)) SWIG_fail;
19776 }
19777 }
19778 if (obj1) {
19779 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
19780 if (SWIG_arg_fail(2)) SWIG_fail;
19781 }
19782 {
19783 PyThreadState* __tstate = wxPyBeginAllowThreads();
19784 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
19785
19786 wxPyEndAllowThreads(__tstate);
19787 if (PyErr_Occurred()) SWIG_fail;
19788 }
19789 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEraseEvent, 1);
19790 return resultobj;
19791 fail:
19792 return NULL;
19793 }
19794
19795
19796 static PyObject *_wrap_EraseEvent_GetDC(PyObject *, PyObject *args, PyObject *kwargs) {
19797 PyObject *resultobj;
19798 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
19799 wxDC *result;
19800 PyObject * obj0 = 0 ;
19801 char *kwnames[] = {
19802 (char *) "self", NULL
19803 };
19804
19805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EraseEvent_GetDC",kwnames,&obj0)) goto fail;
19806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_EXCEPTION | 0);
19807 if (SWIG_arg_fail(1)) SWIG_fail;
19808 {
19809 PyThreadState* __tstate = wxPyBeginAllowThreads();
19810 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
19811
19812 wxPyEndAllowThreads(__tstate);
19813 if (PyErr_Occurred()) SWIG_fail;
19814 }
19815 {
19816 resultobj = wxPyMake_wxObject(result, 0);
19817 }
19818 return resultobj;
19819 fail:
19820 return NULL;
19821 }
19822
19823
19824 static PyObject * EraseEvent_swigregister(PyObject *, PyObject *args) {
19825 PyObject *obj;
19826 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19827 SWIG_TypeClientData(SWIGTYPE_p_wxEraseEvent, obj);
19828 Py_INCREF(obj);
19829 return Py_BuildValue((char *)"");
19830 }
19831 static PyObject *_wrap_new_FocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19832 PyObject *resultobj;
19833 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19834 int arg2 = (int) 0 ;
19835 wxFocusEvent *result;
19836 PyObject * obj0 = 0 ;
19837 PyObject * obj1 = 0 ;
19838 char *kwnames[] = {
19839 (char *) "type",(char *) "winid", NULL
19840 };
19841
19842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) goto fail;
19843 if (obj0) {
19844 {
19845 arg1 = (wxEventType)(SWIG_As_int(obj0));
19846 if (SWIG_arg_fail(1)) SWIG_fail;
19847 }
19848 }
19849 if (obj1) {
19850 {
19851 arg2 = (int)(SWIG_As_int(obj1));
19852 if (SWIG_arg_fail(2)) SWIG_fail;
19853 }
19854 }
19855 {
19856 PyThreadState* __tstate = wxPyBeginAllowThreads();
19857 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
19858
19859 wxPyEndAllowThreads(__tstate);
19860 if (PyErr_Occurred()) SWIG_fail;
19861 }
19862 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFocusEvent, 1);
19863 return resultobj;
19864 fail:
19865 return NULL;
19866 }
19867
19868
19869 static PyObject *_wrap_FocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19870 PyObject *resultobj;
19871 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19872 wxWindow *result;
19873 PyObject * obj0 = 0 ;
19874 char *kwnames[] = {
19875 (char *) "self", NULL
19876 };
19877
19878 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19879 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19880 if (SWIG_arg_fail(1)) SWIG_fail;
19881 {
19882 PyThreadState* __tstate = wxPyBeginAllowThreads();
19883 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
19884
19885 wxPyEndAllowThreads(__tstate);
19886 if (PyErr_Occurred()) SWIG_fail;
19887 }
19888 {
19889 resultobj = wxPyMake_wxObject(result, 0);
19890 }
19891 return resultobj;
19892 fail:
19893 return NULL;
19894 }
19895
19896
19897 static PyObject *_wrap_FocusEvent_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19898 PyObject *resultobj;
19899 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
19900 wxWindow *arg2 = (wxWindow *) 0 ;
19901 PyObject * obj0 = 0 ;
19902 PyObject * obj1 = 0 ;
19903 char *kwnames[] = {
19904 (char *) "self",(char *) "win", NULL
19905 };
19906
19907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) goto fail;
19908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19909 if (SWIG_arg_fail(1)) SWIG_fail;
19910 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19911 if (SWIG_arg_fail(2)) SWIG_fail;
19912 {
19913 PyThreadState* __tstate = wxPyBeginAllowThreads();
19914 (arg1)->SetWindow(arg2);
19915
19916 wxPyEndAllowThreads(__tstate);
19917 if (PyErr_Occurred()) SWIG_fail;
19918 }
19919 Py_INCREF(Py_None); resultobj = Py_None;
19920 return resultobj;
19921 fail:
19922 return NULL;
19923 }
19924
19925
19926 static PyObject * FocusEvent_swigregister(PyObject *, PyObject *args) {
19927 PyObject *obj;
19928 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19929 SWIG_TypeClientData(SWIGTYPE_p_wxFocusEvent, obj);
19930 Py_INCREF(obj);
19931 return Py_BuildValue((char *)"");
19932 }
19933 static PyObject *_wrap_new_ChildFocusEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19934 PyObject *resultobj;
19935 wxWindow *arg1 = (wxWindow *) NULL ;
19936 wxChildFocusEvent *result;
19937 PyObject * obj0 = 0 ;
19938 char *kwnames[] = {
19939 (char *) "win", NULL
19940 };
19941
19942 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) goto fail;
19943 if (obj0) {
19944 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
19945 if (SWIG_arg_fail(1)) SWIG_fail;
19946 }
19947 {
19948 PyThreadState* __tstate = wxPyBeginAllowThreads();
19949 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
19950
19951 wxPyEndAllowThreads(__tstate);
19952 if (PyErr_Occurred()) SWIG_fail;
19953 }
19954 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxChildFocusEvent, 1);
19955 return resultobj;
19956 fail:
19957 return NULL;
19958 }
19959
19960
19961 static PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
19962 PyObject *resultobj;
19963 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
19964 wxWindow *result;
19965 PyObject * obj0 = 0 ;
19966 char *kwnames[] = {
19967 (char *) "self", NULL
19968 };
19969
19970 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ChildFocusEvent_GetWindow",kwnames,&obj0)) goto fail;
19971 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_EXCEPTION | 0);
19972 if (SWIG_arg_fail(1)) SWIG_fail;
19973 {
19974 PyThreadState* __tstate = wxPyBeginAllowThreads();
19975 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
19976
19977 wxPyEndAllowThreads(__tstate);
19978 if (PyErr_Occurred()) SWIG_fail;
19979 }
19980 {
19981 resultobj = wxPyMake_wxObject(result, 0);
19982 }
19983 return resultobj;
19984 fail:
19985 return NULL;
19986 }
19987
19988
19989 static PyObject * ChildFocusEvent_swigregister(PyObject *, PyObject *args) {
19990 PyObject *obj;
19991 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
19992 SWIG_TypeClientData(SWIGTYPE_p_wxChildFocusEvent, obj);
19993 Py_INCREF(obj);
19994 return Py_BuildValue((char *)"");
19995 }
19996 static PyObject *_wrap_new_ActivateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
19997 PyObject *resultobj;
19998 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19999 bool arg2 = (bool) true ;
20000 int arg3 = (int) 0 ;
20001 wxActivateEvent *result;
20002 PyObject * obj0 = 0 ;
20003 PyObject * obj1 = 0 ;
20004 PyObject * obj2 = 0 ;
20005 char *kwnames[] = {
20006 (char *) "type",(char *) "active",(char *) "Id", NULL
20007 };
20008
20009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20010 if (obj0) {
20011 {
20012 arg1 = (wxEventType)(SWIG_As_int(obj0));
20013 if (SWIG_arg_fail(1)) SWIG_fail;
20014 }
20015 }
20016 if (obj1) {
20017 {
20018 arg2 = (bool)(SWIG_As_bool(obj1));
20019 if (SWIG_arg_fail(2)) SWIG_fail;
20020 }
20021 }
20022 if (obj2) {
20023 {
20024 arg3 = (int)(SWIG_As_int(obj2));
20025 if (SWIG_arg_fail(3)) SWIG_fail;
20026 }
20027 }
20028 {
20029 PyThreadState* __tstate = wxPyBeginAllowThreads();
20030 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
20031
20032 wxPyEndAllowThreads(__tstate);
20033 if (PyErr_Occurred()) SWIG_fail;
20034 }
20035 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxActivateEvent, 1);
20036 return resultobj;
20037 fail:
20038 return NULL;
20039 }
20040
20041
20042 static PyObject *_wrap_ActivateEvent_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
20043 PyObject *resultobj;
20044 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
20045 bool result;
20046 PyObject * obj0 = 0 ;
20047 char *kwnames[] = {
20048 (char *) "self", NULL
20049 };
20050
20051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ActivateEvent_GetActive",kwnames,&obj0)) goto fail;
20052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_EXCEPTION | 0);
20053 if (SWIG_arg_fail(1)) SWIG_fail;
20054 {
20055 PyThreadState* __tstate = wxPyBeginAllowThreads();
20056 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
20057
20058 wxPyEndAllowThreads(__tstate);
20059 if (PyErr_Occurred()) SWIG_fail;
20060 }
20061 {
20062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20063 }
20064 return resultobj;
20065 fail:
20066 return NULL;
20067 }
20068
20069
20070 static PyObject * ActivateEvent_swigregister(PyObject *, PyObject *args) {
20071 PyObject *obj;
20072 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20073 SWIG_TypeClientData(SWIGTYPE_p_wxActivateEvent, obj);
20074 Py_INCREF(obj);
20075 return Py_BuildValue((char *)"");
20076 }
20077 static PyObject *_wrap_new_InitDialogEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20078 PyObject *resultobj;
20079 int arg1 = (int) 0 ;
20080 wxInitDialogEvent *result;
20081 PyObject * obj0 = 0 ;
20082 char *kwnames[] = {
20083 (char *) "Id", NULL
20084 };
20085
20086 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) goto fail;
20087 if (obj0) {
20088 {
20089 arg1 = (int)(SWIG_As_int(obj0));
20090 if (SWIG_arg_fail(1)) SWIG_fail;
20091 }
20092 }
20093 {
20094 PyThreadState* __tstate = wxPyBeginAllowThreads();
20095 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
20096
20097 wxPyEndAllowThreads(__tstate);
20098 if (PyErr_Occurred()) SWIG_fail;
20099 }
20100 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxInitDialogEvent, 1);
20101 return resultobj;
20102 fail:
20103 return NULL;
20104 }
20105
20106
20107 static PyObject * InitDialogEvent_swigregister(PyObject *, PyObject *args) {
20108 PyObject *obj;
20109 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20110 SWIG_TypeClientData(SWIGTYPE_p_wxInitDialogEvent, obj);
20111 Py_INCREF(obj);
20112 return Py_BuildValue((char *)"");
20113 }
20114 static PyObject *_wrap_new_MenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20115 PyObject *resultobj;
20116 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20117 int arg2 = (int) 0 ;
20118 wxMenu *arg3 = (wxMenu *) NULL ;
20119 wxMenuEvent *result;
20120 PyObject * obj0 = 0 ;
20121 PyObject * obj1 = 0 ;
20122 PyObject * obj2 = 0 ;
20123 char *kwnames[] = {
20124 (char *) "type",(char *) "winid",(char *) "menu", NULL
20125 };
20126
20127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
20128 if (obj0) {
20129 {
20130 arg1 = (wxEventType)(SWIG_As_int(obj0));
20131 if (SWIG_arg_fail(1)) SWIG_fail;
20132 }
20133 }
20134 if (obj1) {
20135 {
20136 arg2 = (int)(SWIG_As_int(obj1));
20137 if (SWIG_arg_fail(2)) SWIG_fail;
20138 }
20139 }
20140 if (obj2) {
20141 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
20142 if (SWIG_arg_fail(3)) SWIG_fail;
20143 }
20144 {
20145 PyThreadState* __tstate = wxPyBeginAllowThreads();
20146 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
20147
20148 wxPyEndAllowThreads(__tstate);
20149 if (PyErr_Occurred()) SWIG_fail;
20150 }
20151 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuEvent, 1);
20152 return resultobj;
20153 fail:
20154 return NULL;
20155 }
20156
20157
20158 static PyObject *_wrap_MenuEvent_GetMenuId(PyObject *, PyObject *args, PyObject *kwargs) {
20159 PyObject *resultobj;
20160 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20161 int result;
20162 PyObject * obj0 = 0 ;
20163 char *kwnames[] = {
20164 (char *) "self", NULL
20165 };
20166
20167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenuId",kwnames,&obj0)) goto fail;
20168 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20169 if (SWIG_arg_fail(1)) SWIG_fail;
20170 {
20171 PyThreadState* __tstate = wxPyBeginAllowThreads();
20172 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
20173
20174 wxPyEndAllowThreads(__tstate);
20175 if (PyErr_Occurred()) SWIG_fail;
20176 }
20177 {
20178 resultobj = SWIG_From_int((int)(result));
20179 }
20180 return resultobj;
20181 fail:
20182 return NULL;
20183 }
20184
20185
20186 static PyObject *_wrap_MenuEvent_IsPopup(PyObject *, PyObject *args, PyObject *kwargs) {
20187 PyObject *resultobj;
20188 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20189 bool result;
20190 PyObject * obj0 = 0 ;
20191 char *kwnames[] = {
20192 (char *) "self", NULL
20193 };
20194
20195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_IsPopup",kwnames,&obj0)) goto fail;
20196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20197 if (SWIG_arg_fail(1)) SWIG_fail;
20198 {
20199 PyThreadState* __tstate = wxPyBeginAllowThreads();
20200 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
20201
20202 wxPyEndAllowThreads(__tstate);
20203 if (PyErr_Occurred()) SWIG_fail;
20204 }
20205 {
20206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20207 }
20208 return resultobj;
20209 fail:
20210 return NULL;
20211 }
20212
20213
20214 static PyObject *_wrap_MenuEvent_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
20215 PyObject *resultobj;
20216 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
20217 wxMenu *result;
20218 PyObject * obj0 = 0 ;
20219 char *kwnames[] = {
20220 (char *) "self", NULL
20221 };
20222
20223 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuEvent_GetMenu",kwnames,&obj0)) goto fail;
20224 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_EXCEPTION | 0);
20225 if (SWIG_arg_fail(1)) SWIG_fail;
20226 {
20227 PyThreadState* __tstate = wxPyBeginAllowThreads();
20228 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
20229
20230 wxPyEndAllowThreads(__tstate);
20231 if (PyErr_Occurred()) SWIG_fail;
20232 }
20233 {
20234 resultobj = wxPyMake_wxObject(result, 0);
20235 }
20236 return resultobj;
20237 fail:
20238 return NULL;
20239 }
20240
20241
20242 static PyObject * MenuEvent_swigregister(PyObject *, PyObject *args) {
20243 PyObject *obj;
20244 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20245 SWIG_TypeClientData(SWIGTYPE_p_wxMenuEvent, obj);
20246 Py_INCREF(obj);
20247 return Py_BuildValue((char *)"");
20248 }
20249 static PyObject *_wrap_new_CloseEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20250 PyObject *resultobj;
20251 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
20252 int arg2 = (int) 0 ;
20253 wxCloseEvent *result;
20254 PyObject * obj0 = 0 ;
20255 PyObject * obj1 = 0 ;
20256 char *kwnames[] = {
20257 (char *) "type",(char *) "winid", NULL
20258 };
20259
20260 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) goto fail;
20261 if (obj0) {
20262 {
20263 arg1 = (wxEventType)(SWIG_As_int(obj0));
20264 if (SWIG_arg_fail(1)) SWIG_fail;
20265 }
20266 }
20267 if (obj1) {
20268 {
20269 arg2 = (int)(SWIG_As_int(obj1));
20270 if (SWIG_arg_fail(2)) SWIG_fail;
20271 }
20272 }
20273 {
20274 PyThreadState* __tstate = wxPyBeginAllowThreads();
20275 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
20276
20277 wxPyEndAllowThreads(__tstate);
20278 if (PyErr_Occurred()) SWIG_fail;
20279 }
20280 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCloseEvent, 1);
20281 return resultobj;
20282 fail:
20283 return NULL;
20284 }
20285
20286
20287 static PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20288 PyObject *resultobj;
20289 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20290 bool arg2 ;
20291 PyObject * obj0 = 0 ;
20292 PyObject * obj1 = 0 ;
20293 char *kwnames[] = {
20294 (char *) "self",(char *) "logOff", NULL
20295 };
20296
20297 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) goto fail;
20298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20299 if (SWIG_arg_fail(1)) SWIG_fail;
20300 {
20301 arg2 = (bool)(SWIG_As_bool(obj1));
20302 if (SWIG_arg_fail(2)) SWIG_fail;
20303 }
20304 {
20305 PyThreadState* __tstate = wxPyBeginAllowThreads();
20306 (arg1)->SetLoggingOff(arg2);
20307
20308 wxPyEndAllowThreads(__tstate);
20309 if (PyErr_Occurred()) SWIG_fail;
20310 }
20311 Py_INCREF(Py_None); resultobj = Py_None;
20312 return resultobj;
20313 fail:
20314 return NULL;
20315 }
20316
20317
20318 static PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *, PyObject *args, PyObject *kwargs) {
20319 PyObject *resultobj;
20320 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20321 bool result;
20322 PyObject * obj0 = 0 ;
20323 char *kwnames[] = {
20324 (char *) "self", NULL
20325 };
20326
20327 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetLoggingOff",kwnames,&obj0)) goto fail;
20328 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20329 if (SWIG_arg_fail(1)) SWIG_fail;
20330 {
20331 PyThreadState* __tstate = wxPyBeginAllowThreads();
20332 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
20333
20334 wxPyEndAllowThreads(__tstate);
20335 if (PyErr_Occurred()) SWIG_fail;
20336 }
20337 {
20338 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20339 }
20340 return resultobj;
20341 fail:
20342 return NULL;
20343 }
20344
20345
20346 static PyObject *_wrap_CloseEvent_Veto(PyObject *, PyObject *args, PyObject *kwargs) {
20347 PyObject *resultobj;
20348 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20349 bool arg2 = (bool) true ;
20350 PyObject * obj0 = 0 ;
20351 PyObject * obj1 = 0 ;
20352 char *kwnames[] = {
20353 (char *) "self",(char *) "veto", NULL
20354 };
20355
20356 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) goto fail;
20357 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20358 if (SWIG_arg_fail(1)) SWIG_fail;
20359 if (obj1) {
20360 {
20361 arg2 = (bool)(SWIG_As_bool(obj1));
20362 if (SWIG_arg_fail(2)) SWIG_fail;
20363 }
20364 }
20365 {
20366 PyThreadState* __tstate = wxPyBeginAllowThreads();
20367 (arg1)->Veto(arg2);
20368
20369 wxPyEndAllowThreads(__tstate);
20370 if (PyErr_Occurred()) SWIG_fail;
20371 }
20372 Py_INCREF(Py_None); resultobj = Py_None;
20373 return resultobj;
20374 fail:
20375 return NULL;
20376 }
20377
20378
20379 static PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20380 PyObject *resultobj;
20381 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20382 bool arg2 ;
20383 PyObject * obj0 = 0 ;
20384 PyObject * obj1 = 0 ;
20385 char *kwnames[] = {
20386 (char *) "self",(char *) "canVeto", NULL
20387 };
20388
20389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) goto fail;
20390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20391 if (SWIG_arg_fail(1)) SWIG_fail;
20392 {
20393 arg2 = (bool)(SWIG_As_bool(obj1));
20394 if (SWIG_arg_fail(2)) SWIG_fail;
20395 }
20396 {
20397 PyThreadState* __tstate = wxPyBeginAllowThreads();
20398 (arg1)->SetCanVeto(arg2);
20399
20400 wxPyEndAllowThreads(__tstate);
20401 if (PyErr_Occurred()) SWIG_fail;
20402 }
20403 Py_INCREF(Py_None); resultobj = Py_None;
20404 return resultobj;
20405 fail:
20406 return NULL;
20407 }
20408
20409
20410 static PyObject *_wrap_CloseEvent_CanVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20411 PyObject *resultobj;
20412 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20413 bool result;
20414 PyObject * obj0 = 0 ;
20415 char *kwnames[] = {
20416 (char *) "self", NULL
20417 };
20418
20419 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_CanVeto",kwnames,&obj0)) goto fail;
20420 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20421 if (SWIG_arg_fail(1)) SWIG_fail;
20422 {
20423 PyThreadState* __tstate = wxPyBeginAllowThreads();
20424 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
20425
20426 wxPyEndAllowThreads(__tstate);
20427 if (PyErr_Occurred()) SWIG_fail;
20428 }
20429 {
20430 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20431 }
20432 return resultobj;
20433 fail:
20434 return NULL;
20435 }
20436
20437
20438 static PyObject *_wrap_CloseEvent_GetVeto(PyObject *, PyObject *args, PyObject *kwargs) {
20439 PyObject *resultobj;
20440 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
20441 bool result;
20442 PyObject * obj0 = 0 ;
20443 char *kwnames[] = {
20444 (char *) "self", NULL
20445 };
20446
20447 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:CloseEvent_GetVeto",kwnames,&obj0)) goto fail;
20448 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_EXCEPTION | 0);
20449 if (SWIG_arg_fail(1)) SWIG_fail;
20450 {
20451 PyThreadState* __tstate = wxPyBeginAllowThreads();
20452 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
20453
20454 wxPyEndAllowThreads(__tstate);
20455 if (PyErr_Occurred()) SWIG_fail;
20456 }
20457 {
20458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20459 }
20460 return resultobj;
20461 fail:
20462 return NULL;
20463 }
20464
20465
20466 static PyObject * CloseEvent_swigregister(PyObject *, PyObject *args) {
20467 PyObject *obj;
20468 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20469 SWIG_TypeClientData(SWIGTYPE_p_wxCloseEvent, obj);
20470 Py_INCREF(obj);
20471 return Py_BuildValue((char *)"");
20472 }
20473 static PyObject *_wrap_new_ShowEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20474 PyObject *resultobj;
20475 int arg1 = (int) 0 ;
20476 bool arg2 = (bool) false ;
20477 wxShowEvent *result;
20478 PyObject * obj0 = 0 ;
20479 PyObject * obj1 = 0 ;
20480 char *kwnames[] = {
20481 (char *) "winid",(char *) "show", NULL
20482 };
20483
20484 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) goto fail;
20485 if (obj0) {
20486 {
20487 arg1 = (int)(SWIG_As_int(obj0));
20488 if (SWIG_arg_fail(1)) SWIG_fail;
20489 }
20490 }
20491 if (obj1) {
20492 {
20493 arg2 = (bool)(SWIG_As_bool(obj1));
20494 if (SWIG_arg_fail(2)) SWIG_fail;
20495 }
20496 }
20497 {
20498 PyThreadState* __tstate = wxPyBeginAllowThreads();
20499 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
20500
20501 wxPyEndAllowThreads(__tstate);
20502 if (PyErr_Occurred()) SWIG_fail;
20503 }
20504 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxShowEvent, 1);
20505 return resultobj;
20506 fail:
20507 return NULL;
20508 }
20509
20510
20511 static PyObject *_wrap_ShowEvent_SetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20512 PyObject *resultobj;
20513 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20514 bool arg2 ;
20515 PyObject * obj0 = 0 ;
20516 PyObject * obj1 = 0 ;
20517 char *kwnames[] = {
20518 (char *) "self",(char *) "show", NULL
20519 };
20520
20521 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) goto fail;
20522 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20523 if (SWIG_arg_fail(1)) SWIG_fail;
20524 {
20525 arg2 = (bool)(SWIG_As_bool(obj1));
20526 if (SWIG_arg_fail(2)) SWIG_fail;
20527 }
20528 {
20529 PyThreadState* __tstate = wxPyBeginAllowThreads();
20530 (arg1)->SetShow(arg2);
20531
20532 wxPyEndAllowThreads(__tstate);
20533 if (PyErr_Occurred()) SWIG_fail;
20534 }
20535 Py_INCREF(Py_None); resultobj = Py_None;
20536 return resultobj;
20537 fail:
20538 return NULL;
20539 }
20540
20541
20542 static PyObject *_wrap_ShowEvent_GetShow(PyObject *, PyObject *args, PyObject *kwargs) {
20543 PyObject *resultobj;
20544 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
20545 bool result;
20546 PyObject * obj0 = 0 ;
20547 char *kwnames[] = {
20548 (char *) "self", NULL
20549 };
20550
20551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ShowEvent_GetShow",kwnames,&obj0)) goto fail;
20552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxShowEvent, SWIG_POINTER_EXCEPTION | 0);
20553 if (SWIG_arg_fail(1)) SWIG_fail;
20554 {
20555 PyThreadState* __tstate = wxPyBeginAllowThreads();
20556 result = (bool)((wxShowEvent const *)arg1)->GetShow();
20557
20558 wxPyEndAllowThreads(__tstate);
20559 if (PyErr_Occurred()) SWIG_fail;
20560 }
20561 {
20562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20563 }
20564 return resultobj;
20565 fail:
20566 return NULL;
20567 }
20568
20569
20570 static PyObject * ShowEvent_swigregister(PyObject *, PyObject *args) {
20571 PyObject *obj;
20572 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20573 SWIG_TypeClientData(SWIGTYPE_p_wxShowEvent, obj);
20574 Py_INCREF(obj);
20575 return Py_BuildValue((char *)"");
20576 }
20577 static PyObject *_wrap_new_IconizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20578 PyObject *resultobj;
20579 int arg1 = (int) 0 ;
20580 bool arg2 = (bool) true ;
20581 wxIconizeEvent *result;
20582 PyObject * obj0 = 0 ;
20583 PyObject * obj1 = 0 ;
20584 char *kwnames[] = {
20585 (char *) "id",(char *) "iconized", NULL
20586 };
20587
20588 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) goto fail;
20589 if (obj0) {
20590 {
20591 arg1 = (int)(SWIG_As_int(obj0));
20592 if (SWIG_arg_fail(1)) SWIG_fail;
20593 }
20594 }
20595 if (obj1) {
20596 {
20597 arg2 = (bool)(SWIG_As_bool(obj1));
20598 if (SWIG_arg_fail(2)) SWIG_fail;
20599 }
20600 }
20601 {
20602 PyThreadState* __tstate = wxPyBeginAllowThreads();
20603 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
20604
20605 wxPyEndAllowThreads(__tstate);
20606 if (PyErr_Occurred()) SWIG_fail;
20607 }
20608 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIconizeEvent, 1);
20609 return resultobj;
20610 fail:
20611 return NULL;
20612 }
20613
20614
20615 static PyObject *_wrap_IconizeEvent_Iconized(PyObject *, PyObject *args, PyObject *kwargs) {
20616 PyObject *resultobj;
20617 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
20618 bool result;
20619 PyObject * obj0 = 0 ;
20620 char *kwnames[] = {
20621 (char *) "self", NULL
20622 };
20623
20624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IconizeEvent_Iconized",kwnames,&obj0)) goto fail;
20625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_EXCEPTION | 0);
20626 if (SWIG_arg_fail(1)) SWIG_fail;
20627 {
20628 PyThreadState* __tstate = wxPyBeginAllowThreads();
20629 result = (bool)(arg1)->Iconized();
20630
20631 wxPyEndAllowThreads(__tstate);
20632 if (PyErr_Occurred()) SWIG_fail;
20633 }
20634 {
20635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20636 }
20637 return resultobj;
20638 fail:
20639 return NULL;
20640 }
20641
20642
20643 static PyObject * IconizeEvent_swigregister(PyObject *, PyObject *args) {
20644 PyObject *obj;
20645 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20646 SWIG_TypeClientData(SWIGTYPE_p_wxIconizeEvent, obj);
20647 Py_INCREF(obj);
20648 return Py_BuildValue((char *)"");
20649 }
20650 static PyObject *_wrap_new_MaximizeEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20651 PyObject *resultobj;
20652 int arg1 = (int) 0 ;
20653 wxMaximizeEvent *result;
20654 PyObject * obj0 = 0 ;
20655 char *kwnames[] = {
20656 (char *) "id", NULL
20657 };
20658
20659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) goto fail;
20660 if (obj0) {
20661 {
20662 arg1 = (int)(SWIG_As_int(obj0));
20663 if (SWIG_arg_fail(1)) SWIG_fail;
20664 }
20665 }
20666 {
20667 PyThreadState* __tstate = wxPyBeginAllowThreads();
20668 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
20669
20670 wxPyEndAllowThreads(__tstate);
20671 if (PyErr_Occurred()) SWIG_fail;
20672 }
20673 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMaximizeEvent, 1);
20674 return resultobj;
20675 fail:
20676 return NULL;
20677 }
20678
20679
20680 static PyObject * MaximizeEvent_swigregister(PyObject *, PyObject *args) {
20681 PyObject *obj;
20682 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20683 SWIG_TypeClientData(SWIGTYPE_p_wxMaximizeEvent, obj);
20684 Py_INCREF(obj);
20685 return Py_BuildValue((char *)"");
20686 }
20687 static PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
20688 PyObject *resultobj;
20689 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20690 wxPoint result;
20691 PyObject * obj0 = 0 ;
20692 char *kwnames[] = {
20693 (char *) "self", NULL
20694 };
20695
20696 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetPosition",kwnames,&obj0)) goto fail;
20697 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20698 if (SWIG_arg_fail(1)) SWIG_fail;
20699 {
20700 PyThreadState* __tstate = wxPyBeginAllowThreads();
20701 result = (arg1)->GetPosition();
20702
20703 wxPyEndAllowThreads(__tstate);
20704 if (PyErr_Occurred()) SWIG_fail;
20705 }
20706 {
20707 wxPoint * resultptr;
20708 resultptr = new wxPoint((wxPoint &)(result));
20709 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
20710 }
20711 return resultobj;
20712 fail:
20713 return NULL;
20714 }
20715
20716
20717 static PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20718 PyObject *resultobj;
20719 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20720 int result;
20721 PyObject * obj0 = 0 ;
20722 char *kwnames[] = {
20723 (char *) "self", NULL
20724 };
20725
20726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetNumberOfFiles",kwnames,&obj0)) goto fail;
20727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20728 if (SWIG_arg_fail(1)) SWIG_fail;
20729 {
20730 PyThreadState* __tstate = wxPyBeginAllowThreads();
20731 result = (int)(arg1)->GetNumberOfFiles();
20732
20733 wxPyEndAllowThreads(__tstate);
20734 if (PyErr_Occurred()) SWIG_fail;
20735 }
20736 {
20737 resultobj = SWIG_From_int((int)(result));
20738 }
20739 return resultobj;
20740 fail:
20741 return NULL;
20742 }
20743
20744
20745 static PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *, PyObject *args, PyObject *kwargs) {
20746 PyObject *resultobj;
20747 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
20748 PyObject *result;
20749 PyObject * obj0 = 0 ;
20750 char *kwnames[] = {
20751 (char *) "self", NULL
20752 };
20753
20754 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DropFilesEvent_GetFiles",kwnames,&obj0)) goto fail;
20755 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDropFilesEvent, SWIG_POINTER_EXCEPTION | 0);
20756 if (SWIG_arg_fail(1)) SWIG_fail;
20757 {
20758 PyThreadState* __tstate = wxPyBeginAllowThreads();
20759 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
20760
20761 wxPyEndAllowThreads(__tstate);
20762 if (PyErr_Occurred()) SWIG_fail;
20763 }
20764 resultobj = result;
20765 return resultobj;
20766 fail:
20767 return NULL;
20768 }
20769
20770
20771 static PyObject * DropFilesEvent_swigregister(PyObject *, PyObject *args) {
20772 PyObject *obj;
20773 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
20774 SWIG_TypeClientData(SWIGTYPE_p_wxDropFilesEvent, obj);
20775 Py_INCREF(obj);
20776 return Py_BuildValue((char *)"");
20777 }
20778 static PyObject *_wrap_new_UpdateUIEvent(PyObject *, PyObject *args, PyObject *kwargs) {
20779 PyObject *resultobj;
20780 int arg1 = (int) 0 ;
20781 wxUpdateUIEvent *result;
20782 PyObject * obj0 = 0 ;
20783 char *kwnames[] = {
20784 (char *) "commandId", NULL
20785 };
20786
20787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) goto fail;
20788 if (obj0) {
20789 {
20790 arg1 = (int)(SWIG_As_int(obj0));
20791 if (SWIG_arg_fail(1)) SWIG_fail;
20792 }
20793 }
20794 {
20795 PyThreadState* __tstate = wxPyBeginAllowThreads();
20796 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
20797
20798 wxPyEndAllowThreads(__tstate);
20799 if (PyErr_Occurred()) SWIG_fail;
20800 }
20801 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxUpdateUIEvent, 1);
20802 return resultobj;
20803 fail:
20804 return NULL;
20805 }
20806
20807
20808 static PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20809 PyObject *resultobj;
20810 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20811 bool result;
20812 PyObject * obj0 = 0 ;
20813 char *kwnames[] = {
20814 (char *) "self", NULL
20815 };
20816
20817 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetChecked",kwnames,&obj0)) goto fail;
20818 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20819 if (SWIG_arg_fail(1)) SWIG_fail;
20820 {
20821 PyThreadState* __tstate = wxPyBeginAllowThreads();
20822 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
20823
20824 wxPyEndAllowThreads(__tstate);
20825 if (PyErr_Occurred()) SWIG_fail;
20826 }
20827 {
20828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20829 }
20830 return resultobj;
20831 fail:
20832 return NULL;
20833 }
20834
20835
20836 static PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20837 PyObject *resultobj;
20838 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20839 bool result;
20840 PyObject * obj0 = 0 ;
20841 char *kwnames[] = {
20842 (char *) "self", NULL
20843 };
20844
20845 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetEnabled",kwnames,&obj0)) goto fail;
20846 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20847 if (SWIG_arg_fail(1)) SWIG_fail;
20848 {
20849 PyThreadState* __tstate = wxPyBeginAllowThreads();
20850 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
20851
20852 wxPyEndAllowThreads(__tstate);
20853 if (PyErr_Occurred()) SWIG_fail;
20854 }
20855 {
20856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20857 }
20858 return resultobj;
20859 fail:
20860 return NULL;
20861 }
20862
20863
20864 static PyObject *_wrap_UpdateUIEvent_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
20865 PyObject *resultobj;
20866 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20867 wxString result;
20868 PyObject * obj0 = 0 ;
20869 char *kwnames[] = {
20870 (char *) "self", NULL
20871 };
20872
20873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetText",kwnames,&obj0)) goto fail;
20874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20875 if (SWIG_arg_fail(1)) SWIG_fail;
20876 {
20877 PyThreadState* __tstate = wxPyBeginAllowThreads();
20878 result = ((wxUpdateUIEvent const *)arg1)->GetText();
20879
20880 wxPyEndAllowThreads(__tstate);
20881 if (PyErr_Occurred()) SWIG_fail;
20882 }
20883 {
20884 #if wxUSE_UNICODE
20885 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
20886 #else
20887 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
20888 #endif
20889 }
20890 return resultobj;
20891 fail:
20892 return NULL;
20893 }
20894
20895
20896 static PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *, PyObject *args, PyObject *kwargs) {
20897 PyObject *resultobj;
20898 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 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:UpdateUIEvent_GetSetText",kwnames,&obj0)) goto fail;
20906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20907 if (SWIG_arg_fail(1)) SWIG_fail;
20908 {
20909 PyThreadState* __tstate = wxPyBeginAllowThreads();
20910 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
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_UpdateUIEvent_GetSetChecked(PyObject *, PyObject *args, PyObject *kwargs) {
20925 PyObject *resultobj;
20926 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20927 bool result;
20928 PyObject * obj0 = 0 ;
20929 char *kwnames[] = {
20930 (char *) "self", NULL
20931 };
20932
20933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetChecked",kwnames,&obj0)) goto fail;
20934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20935 if (SWIG_arg_fail(1)) SWIG_fail;
20936 {
20937 PyThreadState* __tstate = wxPyBeginAllowThreads();
20938 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
20939
20940 wxPyEndAllowThreads(__tstate);
20941 if (PyErr_Occurred()) SWIG_fail;
20942 }
20943 {
20944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20945 }
20946 return resultobj;
20947 fail:
20948 return NULL;
20949 }
20950
20951
20952 static PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
20953 PyObject *resultobj;
20954 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20955 bool result;
20956 PyObject * obj0 = 0 ;
20957 char *kwnames[] = {
20958 (char *) "self", NULL
20959 };
20960
20961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_GetSetEnabled",kwnames,&obj0)) goto fail;
20962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20963 if (SWIG_arg_fail(1)) SWIG_fail;
20964 {
20965 PyThreadState* __tstate = wxPyBeginAllowThreads();
20966 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
20967
20968 wxPyEndAllowThreads(__tstate);
20969 if (PyErr_Occurred()) SWIG_fail;
20970 }
20971 {
20972 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20973 }
20974 return resultobj;
20975 fail:
20976 return NULL;
20977 }
20978
20979
20980 static PyObject *_wrap_UpdateUIEvent_Check(PyObject *, PyObject *args, PyObject *kwargs) {
20981 PyObject *resultobj;
20982 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
20983 bool arg2 ;
20984 PyObject * obj0 = 0 ;
20985 PyObject * obj1 = 0 ;
20986 char *kwnames[] = {
20987 (char *) "self",(char *) "check", NULL
20988 };
20989
20990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) goto fail;
20991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
20992 if (SWIG_arg_fail(1)) SWIG_fail;
20993 {
20994 arg2 = (bool)(SWIG_As_bool(obj1));
20995 if (SWIG_arg_fail(2)) SWIG_fail;
20996 }
20997 {
20998 PyThreadState* __tstate = wxPyBeginAllowThreads();
20999 (arg1)->Check(arg2);
21000
21001 wxPyEndAllowThreads(__tstate);
21002 if (PyErr_Occurred()) SWIG_fail;
21003 }
21004 Py_INCREF(Py_None); resultobj = Py_None;
21005 return resultobj;
21006 fail:
21007 return NULL;
21008 }
21009
21010
21011 static PyObject *_wrap_UpdateUIEvent_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
21012 PyObject *resultobj;
21013 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21014 bool arg2 ;
21015 PyObject * obj0 = 0 ;
21016 PyObject * obj1 = 0 ;
21017 char *kwnames[] = {
21018 (char *) "self",(char *) "enable", NULL
21019 };
21020
21021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) goto fail;
21022 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21023 if (SWIG_arg_fail(1)) SWIG_fail;
21024 {
21025 arg2 = (bool)(SWIG_As_bool(obj1));
21026 if (SWIG_arg_fail(2)) SWIG_fail;
21027 }
21028 {
21029 PyThreadState* __tstate = wxPyBeginAllowThreads();
21030 (arg1)->Enable(arg2);
21031
21032 wxPyEndAllowThreads(__tstate);
21033 if (PyErr_Occurred()) SWIG_fail;
21034 }
21035 Py_INCREF(Py_None); resultobj = Py_None;
21036 return resultobj;
21037 fail:
21038 return NULL;
21039 }
21040
21041
21042 static PyObject *_wrap_UpdateUIEvent_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
21043 PyObject *resultobj;
21044 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
21045 wxString *arg2 = 0 ;
21046 bool temp2 = false ;
21047 PyObject * obj0 = 0 ;
21048 PyObject * obj1 = 0 ;
21049 char *kwnames[] = {
21050 (char *) "self",(char *) "text", NULL
21051 };
21052
21053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) goto fail;
21054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_EXCEPTION | 0);
21055 if (SWIG_arg_fail(1)) SWIG_fail;
21056 {
21057 arg2 = wxString_in_helper(obj1);
21058 if (arg2 == NULL) SWIG_fail;
21059 temp2 = true;
21060 }
21061 {
21062 PyThreadState* __tstate = wxPyBeginAllowThreads();
21063 (arg1)->SetText((wxString const &)*arg2);
21064
21065 wxPyEndAllowThreads(__tstate);
21066 if (PyErr_Occurred()) SWIG_fail;
21067 }
21068 Py_INCREF(Py_None); resultobj = Py_None;
21069 {
21070 if (temp2)
21071 delete arg2;
21072 }
21073 return resultobj;
21074 fail:
21075 {
21076 if (temp2)
21077 delete arg2;
21078 }
21079 return NULL;
21080 }
21081
21082
21083 static PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21084 PyObject *resultobj;
21085 long arg1 ;
21086 PyObject * obj0 = 0 ;
21087 char *kwnames[] = {
21088 (char *) "updateInterval", NULL
21089 };
21090
21091 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) goto fail;
21092 {
21093 arg1 = (long)(SWIG_As_long(obj0));
21094 if (SWIG_arg_fail(1)) SWIG_fail;
21095 }
21096 {
21097 PyThreadState* __tstate = wxPyBeginAllowThreads();
21098 wxUpdateUIEvent::SetUpdateInterval(arg1);
21099
21100 wxPyEndAllowThreads(__tstate);
21101 if (PyErr_Occurred()) SWIG_fail;
21102 }
21103 Py_INCREF(Py_None); resultobj = Py_None;
21104 return resultobj;
21105 fail:
21106 return NULL;
21107 }
21108
21109
21110 static PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *, PyObject *args, PyObject *kwargs) {
21111 PyObject *resultobj;
21112 long result;
21113 char *kwnames[] = {
21114 NULL
21115 };
21116
21117 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetUpdateInterval",kwnames)) goto fail;
21118 {
21119 PyThreadState* __tstate = wxPyBeginAllowThreads();
21120 result = (long)wxUpdateUIEvent::GetUpdateInterval();
21121
21122 wxPyEndAllowThreads(__tstate);
21123 if (PyErr_Occurred()) SWIG_fail;
21124 }
21125 {
21126 resultobj = SWIG_From_long((long)(result));
21127 }
21128 return resultobj;
21129 fail:
21130 return NULL;
21131 }
21132
21133
21134 static PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *, PyObject *args, PyObject *kwargs) {
21135 PyObject *resultobj;
21136 wxWindow *arg1 = (wxWindow *) 0 ;
21137 bool result;
21138 PyObject * obj0 = 0 ;
21139 char *kwnames[] = {
21140 (char *) "win", NULL
21141 };
21142
21143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) goto fail;
21144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21145 if (SWIG_arg_fail(1)) SWIG_fail;
21146 {
21147 PyThreadState* __tstate = wxPyBeginAllowThreads();
21148 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
21149
21150 wxPyEndAllowThreads(__tstate);
21151 if (PyErr_Occurred()) SWIG_fail;
21152 }
21153 {
21154 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21155 }
21156 return resultobj;
21157 fail:
21158 return NULL;
21159 }
21160
21161
21162 static PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *, PyObject *args, PyObject *kwargs) {
21163 PyObject *resultobj;
21164 char *kwnames[] = {
21165 NULL
21166 };
21167
21168 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_ResetUpdateTime",kwnames)) goto fail;
21169 {
21170 PyThreadState* __tstate = wxPyBeginAllowThreads();
21171 wxUpdateUIEvent::ResetUpdateTime();
21172
21173 wxPyEndAllowThreads(__tstate);
21174 if (PyErr_Occurred()) SWIG_fail;
21175 }
21176 Py_INCREF(Py_None); resultobj = Py_None;
21177 return resultobj;
21178 fail:
21179 return NULL;
21180 }
21181
21182
21183 static PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21184 PyObject *resultobj;
21185 wxUpdateUIMode arg1 ;
21186 PyObject * obj0 = 0 ;
21187 char *kwnames[] = {
21188 (char *) "mode", NULL
21189 };
21190
21191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) goto fail;
21192 {
21193 arg1 = (wxUpdateUIMode)(SWIG_As_int(obj0));
21194 if (SWIG_arg_fail(1)) SWIG_fail;
21195 }
21196 {
21197 PyThreadState* __tstate = wxPyBeginAllowThreads();
21198 wxUpdateUIEvent::SetMode((wxUpdateUIMode )arg1);
21199
21200 wxPyEndAllowThreads(__tstate);
21201 if (PyErr_Occurred()) SWIG_fail;
21202 }
21203 Py_INCREF(Py_None); resultobj = Py_None;
21204 return resultobj;
21205 fail:
21206 return NULL;
21207 }
21208
21209
21210 static PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
21211 PyObject *resultobj;
21212 wxUpdateUIMode result;
21213 char *kwnames[] = {
21214 NULL
21215 };
21216
21217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":UpdateUIEvent_GetMode",kwnames)) goto fail;
21218 {
21219 PyThreadState* __tstate = wxPyBeginAllowThreads();
21220 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
21221
21222 wxPyEndAllowThreads(__tstate);
21223 if (PyErr_Occurred()) SWIG_fail;
21224 }
21225 resultobj = SWIG_From_int((result));
21226 return resultobj;
21227 fail:
21228 return NULL;
21229 }
21230
21231
21232 static PyObject * UpdateUIEvent_swigregister(PyObject *, PyObject *args) {
21233 PyObject *obj;
21234 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21235 SWIG_TypeClientData(SWIGTYPE_p_wxUpdateUIEvent, obj);
21236 Py_INCREF(obj);
21237 return Py_BuildValue((char *)"");
21238 }
21239 static PyObject *_wrap_new_SysColourChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21240 PyObject *resultobj;
21241 wxSysColourChangedEvent *result;
21242 char *kwnames[] = {
21243 NULL
21244 };
21245
21246 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SysColourChangedEvent",kwnames)) goto fail;
21247 {
21248 PyThreadState* __tstate = wxPyBeginAllowThreads();
21249 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
21250
21251 wxPyEndAllowThreads(__tstate);
21252 if (PyErr_Occurred()) SWIG_fail;
21253 }
21254 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSysColourChangedEvent, 1);
21255 return resultobj;
21256 fail:
21257 return NULL;
21258 }
21259
21260
21261 static PyObject * SysColourChangedEvent_swigregister(PyObject *, PyObject *args) {
21262 PyObject *obj;
21263 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21264 SWIG_TypeClientData(SWIGTYPE_p_wxSysColourChangedEvent, obj);
21265 Py_INCREF(obj);
21266 return Py_BuildValue((char *)"");
21267 }
21268 static PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21269 PyObject *resultobj;
21270 int arg1 = (int) 0 ;
21271 wxWindow *arg2 = (wxWindow *) NULL ;
21272 wxMouseCaptureChangedEvent *result;
21273 PyObject * obj0 = 0 ;
21274 PyObject * obj1 = 0 ;
21275 char *kwnames[] = {
21276 (char *) "winid",(char *) "gainedCapture", NULL
21277 };
21278
21279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) goto fail;
21280 if (obj0) {
21281 {
21282 arg1 = (int)(SWIG_As_int(obj0));
21283 if (SWIG_arg_fail(1)) SWIG_fail;
21284 }
21285 }
21286 if (obj1) {
21287 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21288 if (SWIG_arg_fail(2)) SWIG_fail;
21289 }
21290 {
21291 PyThreadState* __tstate = wxPyBeginAllowThreads();
21292 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
21293
21294 wxPyEndAllowThreads(__tstate);
21295 if (PyErr_Occurred()) SWIG_fail;
21296 }
21297 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, 1);
21298 return resultobj;
21299 fail:
21300 return NULL;
21301 }
21302
21303
21304 static PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21305 PyObject *resultobj;
21306 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
21307 wxWindow *result;
21308 PyObject * obj0 = 0 ;
21309 char *kwnames[] = {
21310 (char *) "self", NULL
21311 };
21312
21313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MouseCaptureChangedEvent_GetCapturedWindow",kwnames,&obj0)) goto fail;
21314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21315 if (SWIG_arg_fail(1)) SWIG_fail;
21316 {
21317 PyThreadState* __tstate = wxPyBeginAllowThreads();
21318 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
21319
21320 wxPyEndAllowThreads(__tstate);
21321 if (PyErr_Occurred()) SWIG_fail;
21322 }
21323 {
21324 resultobj = wxPyMake_wxObject(result, 0);
21325 }
21326 return resultobj;
21327 fail:
21328 return NULL;
21329 }
21330
21331
21332 static PyObject * MouseCaptureChangedEvent_swigregister(PyObject *, PyObject *args) {
21333 PyObject *obj;
21334 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21335 SWIG_TypeClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, obj);
21336 Py_INCREF(obj);
21337 return Py_BuildValue((char *)"");
21338 }
21339 static PyObject *_wrap_new_DisplayChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21340 PyObject *resultobj;
21341 wxDisplayChangedEvent *result;
21342 char *kwnames[] = {
21343 NULL
21344 };
21345
21346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_DisplayChangedEvent",kwnames)) goto fail;
21347 {
21348 PyThreadState* __tstate = wxPyBeginAllowThreads();
21349 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
21350
21351 wxPyEndAllowThreads(__tstate);
21352 if (PyErr_Occurred()) SWIG_fail;
21353 }
21354 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDisplayChangedEvent, 1);
21355 return resultobj;
21356 fail:
21357 return NULL;
21358 }
21359
21360
21361 static PyObject * DisplayChangedEvent_swigregister(PyObject *, PyObject *args) {
21362 PyObject *obj;
21363 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21364 SWIG_TypeClientData(SWIGTYPE_p_wxDisplayChangedEvent, obj);
21365 Py_INCREF(obj);
21366 return Py_BuildValue((char *)"");
21367 }
21368 static PyObject *_wrap_new_PaletteChangedEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21369 PyObject *resultobj;
21370 int arg1 = (int) 0 ;
21371 wxPaletteChangedEvent *result;
21372 PyObject * obj0 = 0 ;
21373 char *kwnames[] = {
21374 (char *) "id", NULL
21375 };
21376
21377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) goto fail;
21378 if (obj0) {
21379 {
21380 arg1 = (int)(SWIG_As_int(obj0));
21381 if (SWIG_arg_fail(1)) SWIG_fail;
21382 }
21383 }
21384 {
21385 PyThreadState* __tstate = wxPyBeginAllowThreads();
21386 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
21387
21388 wxPyEndAllowThreads(__tstate);
21389 if (PyErr_Occurred()) SWIG_fail;
21390 }
21391 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPaletteChangedEvent, 1);
21392 return resultobj;
21393 fail:
21394 return NULL;
21395 }
21396
21397
21398 static PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21399 PyObject *resultobj;
21400 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21401 wxWindow *arg2 = (wxWindow *) 0 ;
21402 PyObject * obj0 = 0 ;
21403 PyObject * obj1 = 0 ;
21404 char *kwnames[] = {
21405 (char *) "self",(char *) "win", NULL
21406 };
21407
21408 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) goto fail;
21409 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21410 if (SWIG_arg_fail(1)) SWIG_fail;
21411 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21412 if (SWIG_arg_fail(2)) SWIG_fail;
21413 {
21414 PyThreadState* __tstate = wxPyBeginAllowThreads();
21415 (arg1)->SetChangedWindow(arg2);
21416
21417 wxPyEndAllowThreads(__tstate);
21418 if (PyErr_Occurred()) SWIG_fail;
21419 }
21420 Py_INCREF(Py_None); resultobj = Py_None;
21421 return resultobj;
21422 fail:
21423 return NULL;
21424 }
21425
21426
21427 static PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21428 PyObject *resultobj;
21429 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
21430 wxWindow *result;
21431 PyObject * obj0 = 0 ;
21432 char *kwnames[] = {
21433 (char *) "self", NULL
21434 };
21435
21436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PaletteChangedEvent_GetChangedWindow",kwnames,&obj0)) goto fail;
21437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_EXCEPTION | 0);
21438 if (SWIG_arg_fail(1)) SWIG_fail;
21439 {
21440 PyThreadState* __tstate = wxPyBeginAllowThreads();
21441 result = (wxWindow *)(arg1)->GetChangedWindow();
21442
21443 wxPyEndAllowThreads(__tstate);
21444 if (PyErr_Occurred()) SWIG_fail;
21445 }
21446 {
21447 resultobj = wxPyMake_wxObject(result, 0);
21448 }
21449 return resultobj;
21450 fail:
21451 return NULL;
21452 }
21453
21454
21455 static PyObject * PaletteChangedEvent_swigregister(PyObject *, PyObject *args) {
21456 PyObject *obj;
21457 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21458 SWIG_TypeClientData(SWIGTYPE_p_wxPaletteChangedEvent, obj);
21459 Py_INCREF(obj);
21460 return Py_BuildValue((char *)"");
21461 }
21462 static PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21463 PyObject *resultobj;
21464 int arg1 = (int) 0 ;
21465 wxQueryNewPaletteEvent *result;
21466 PyObject * obj0 = 0 ;
21467 char *kwnames[] = {
21468 (char *) "winid", NULL
21469 };
21470
21471 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) goto fail;
21472 if (obj0) {
21473 {
21474 arg1 = (int)(SWIG_As_int(obj0));
21475 if (SWIG_arg_fail(1)) SWIG_fail;
21476 }
21477 }
21478 {
21479 PyThreadState* __tstate = wxPyBeginAllowThreads();
21480 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
21481
21482 wxPyEndAllowThreads(__tstate);
21483 if (PyErr_Occurred()) SWIG_fail;
21484 }
21485 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxQueryNewPaletteEvent, 1);
21486 return resultobj;
21487 fail:
21488 return NULL;
21489 }
21490
21491
21492 static PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21493 PyObject *resultobj;
21494 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21495 bool arg2 ;
21496 PyObject * obj0 = 0 ;
21497 PyObject * obj1 = 0 ;
21498 char *kwnames[] = {
21499 (char *) "self",(char *) "realized", NULL
21500 };
21501
21502 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) goto fail;
21503 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21504 if (SWIG_arg_fail(1)) SWIG_fail;
21505 {
21506 arg2 = (bool)(SWIG_As_bool(obj1));
21507 if (SWIG_arg_fail(2)) SWIG_fail;
21508 }
21509 {
21510 PyThreadState* __tstate = wxPyBeginAllowThreads();
21511 (arg1)->SetPaletteRealized(arg2);
21512
21513 wxPyEndAllowThreads(__tstate);
21514 if (PyErr_Occurred()) SWIG_fail;
21515 }
21516 Py_INCREF(Py_None); resultobj = Py_None;
21517 return resultobj;
21518 fail:
21519 return NULL;
21520 }
21521
21522
21523 static PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *, PyObject *args, PyObject *kwargs) {
21524 PyObject *resultobj;
21525 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
21526 bool result;
21527 PyObject * obj0 = 0 ;
21528 char *kwnames[] = {
21529 (char *) "self", NULL
21530 };
21531
21532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:QueryNewPaletteEvent_GetPaletteRealized",kwnames,&obj0)) goto fail;
21533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_EXCEPTION | 0);
21534 if (SWIG_arg_fail(1)) SWIG_fail;
21535 {
21536 PyThreadState* __tstate = wxPyBeginAllowThreads();
21537 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
21538
21539 wxPyEndAllowThreads(__tstate);
21540 if (PyErr_Occurred()) SWIG_fail;
21541 }
21542 {
21543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21544 }
21545 return resultobj;
21546 fail:
21547 return NULL;
21548 }
21549
21550
21551 static PyObject * QueryNewPaletteEvent_swigregister(PyObject *, PyObject *args) {
21552 PyObject *obj;
21553 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21554 SWIG_TypeClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, obj);
21555 Py_INCREF(obj);
21556 return Py_BuildValue((char *)"");
21557 }
21558 static PyObject *_wrap_new_NavigationKeyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21559 PyObject *resultobj;
21560 wxNavigationKeyEvent *result;
21561 char *kwnames[] = {
21562 NULL
21563 };
21564
21565 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_NavigationKeyEvent",kwnames)) goto fail;
21566 {
21567 PyThreadState* __tstate = wxPyBeginAllowThreads();
21568 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
21569
21570 wxPyEndAllowThreads(__tstate);
21571 if (PyErr_Occurred()) SWIG_fail;
21572 }
21573 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxNavigationKeyEvent, 1);
21574 return resultobj;
21575 fail:
21576 return NULL;
21577 }
21578
21579
21580 static PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21581 PyObject *resultobj;
21582 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21583 bool result;
21584 PyObject * obj0 = 0 ;
21585 char *kwnames[] = {
21586 (char *) "self", NULL
21587 };
21588
21589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetDirection",kwnames,&obj0)) goto fail;
21590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21591 if (SWIG_arg_fail(1)) SWIG_fail;
21592 {
21593 PyThreadState* __tstate = wxPyBeginAllowThreads();
21594 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
21595
21596 wxPyEndAllowThreads(__tstate);
21597 if (PyErr_Occurred()) SWIG_fail;
21598 }
21599 {
21600 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21601 }
21602 return resultobj;
21603 fail:
21604 return NULL;
21605 }
21606
21607
21608 static PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *, PyObject *args, PyObject *kwargs) {
21609 PyObject *resultobj;
21610 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21611 bool arg2 ;
21612 PyObject * obj0 = 0 ;
21613 PyObject * obj1 = 0 ;
21614 char *kwnames[] = {
21615 (char *) "self",(char *) "forward", NULL
21616 };
21617
21618 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) goto fail;
21619 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21620 if (SWIG_arg_fail(1)) SWIG_fail;
21621 {
21622 arg2 = (bool)(SWIG_As_bool(obj1));
21623 if (SWIG_arg_fail(2)) SWIG_fail;
21624 }
21625 {
21626 PyThreadState* __tstate = wxPyBeginAllowThreads();
21627 (arg1)->SetDirection(arg2);
21628
21629 wxPyEndAllowThreads(__tstate);
21630 if (PyErr_Occurred()) SWIG_fail;
21631 }
21632 Py_INCREF(Py_None); resultobj = Py_None;
21633 return resultobj;
21634 fail:
21635 return NULL;
21636 }
21637
21638
21639 static PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21640 PyObject *resultobj;
21641 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21642 bool result;
21643 PyObject * obj0 = 0 ;
21644 char *kwnames[] = {
21645 (char *) "self", NULL
21646 };
21647
21648 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsWindowChange",kwnames,&obj0)) goto fail;
21649 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21650 if (SWIG_arg_fail(1)) SWIG_fail;
21651 {
21652 PyThreadState* __tstate = wxPyBeginAllowThreads();
21653 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
21654
21655 wxPyEndAllowThreads(__tstate);
21656 if (PyErr_Occurred()) SWIG_fail;
21657 }
21658 {
21659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21660 }
21661 return resultobj;
21662 fail:
21663 return NULL;
21664 }
21665
21666
21667 static PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *, PyObject *args, PyObject *kwargs) {
21668 PyObject *resultobj;
21669 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21670 bool arg2 ;
21671 PyObject * obj0 = 0 ;
21672 PyObject * obj1 = 0 ;
21673 char *kwnames[] = {
21674 (char *) "self",(char *) "ischange", NULL
21675 };
21676
21677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) goto fail;
21678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21679 if (SWIG_arg_fail(1)) SWIG_fail;
21680 {
21681 arg2 = (bool)(SWIG_As_bool(obj1));
21682 if (SWIG_arg_fail(2)) SWIG_fail;
21683 }
21684 {
21685 PyThreadState* __tstate = wxPyBeginAllowThreads();
21686 (arg1)->SetWindowChange(arg2);
21687
21688 wxPyEndAllowThreads(__tstate);
21689 if (PyErr_Occurred()) SWIG_fail;
21690 }
21691 Py_INCREF(Py_None); resultobj = Py_None;
21692 return resultobj;
21693 fail:
21694 return NULL;
21695 }
21696
21697
21698 static PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21699 PyObject *resultobj;
21700 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21701 bool result;
21702 PyObject * obj0 = 0 ;
21703 char *kwnames[] = {
21704 (char *) "self", NULL
21705 };
21706
21707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_IsFromTab",kwnames,&obj0)) goto fail;
21708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21709 if (SWIG_arg_fail(1)) SWIG_fail;
21710 {
21711 PyThreadState* __tstate = wxPyBeginAllowThreads();
21712 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
21713
21714 wxPyEndAllowThreads(__tstate);
21715 if (PyErr_Occurred()) SWIG_fail;
21716 }
21717 {
21718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21719 }
21720 return resultobj;
21721 fail:
21722 return NULL;
21723 }
21724
21725
21726 static PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *, PyObject *args, PyObject *kwargs) {
21727 PyObject *resultobj;
21728 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21729 bool arg2 ;
21730 PyObject * obj0 = 0 ;
21731 PyObject * obj1 = 0 ;
21732 char *kwnames[] = {
21733 (char *) "self",(char *) "bIs", NULL
21734 };
21735
21736 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) goto fail;
21737 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21738 if (SWIG_arg_fail(1)) SWIG_fail;
21739 {
21740 arg2 = (bool)(SWIG_As_bool(obj1));
21741 if (SWIG_arg_fail(2)) SWIG_fail;
21742 }
21743 {
21744 PyThreadState* __tstate = wxPyBeginAllowThreads();
21745 (arg1)->SetFromTab(arg2);
21746
21747 wxPyEndAllowThreads(__tstate);
21748 if (PyErr_Occurred()) SWIG_fail;
21749 }
21750 Py_INCREF(Py_None); resultobj = Py_None;
21751 return resultobj;
21752 fail:
21753 return NULL;
21754 }
21755
21756
21757 static PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
21758 PyObject *resultobj;
21759 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21760 long arg2 ;
21761 PyObject * obj0 = 0 ;
21762 PyObject * obj1 = 0 ;
21763 char *kwnames[] = {
21764 (char *) "self",(char *) "flags", NULL
21765 };
21766
21767 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) goto fail;
21768 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21769 if (SWIG_arg_fail(1)) SWIG_fail;
21770 {
21771 arg2 = (long)(SWIG_As_long(obj1));
21772 if (SWIG_arg_fail(2)) SWIG_fail;
21773 }
21774 {
21775 PyThreadState* __tstate = wxPyBeginAllowThreads();
21776 (arg1)->SetFlags(arg2);
21777
21778 wxPyEndAllowThreads(__tstate);
21779 if (PyErr_Occurred()) SWIG_fail;
21780 }
21781 Py_INCREF(Py_None); resultobj = Py_None;
21782 return resultobj;
21783 fail:
21784 return NULL;
21785 }
21786
21787
21788 static PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21789 PyObject *resultobj;
21790 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21791 wxWindow *result;
21792 PyObject * obj0 = 0 ;
21793 char *kwnames[] = {
21794 (char *) "self", NULL
21795 };
21796
21797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NavigationKeyEvent_GetCurrentFocus",kwnames,&obj0)) goto fail;
21798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21799 if (SWIG_arg_fail(1)) SWIG_fail;
21800 {
21801 PyThreadState* __tstate = wxPyBeginAllowThreads();
21802 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
21803
21804 wxPyEndAllowThreads(__tstate);
21805 if (PyErr_Occurred()) SWIG_fail;
21806 }
21807 {
21808 resultobj = wxPyMake_wxObject(result, 0);
21809 }
21810 return resultobj;
21811 fail:
21812 return NULL;
21813 }
21814
21815
21816 static PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *, PyObject *args, PyObject *kwargs) {
21817 PyObject *resultobj;
21818 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
21819 wxWindow *arg2 = (wxWindow *) 0 ;
21820 PyObject * obj0 = 0 ;
21821 PyObject * obj1 = 0 ;
21822 char *kwnames[] = {
21823 (char *) "self",(char *) "win", NULL
21824 };
21825
21826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) goto fail;
21827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_EXCEPTION | 0);
21828 if (SWIG_arg_fail(1)) SWIG_fail;
21829 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21830 if (SWIG_arg_fail(2)) SWIG_fail;
21831 {
21832 PyThreadState* __tstate = wxPyBeginAllowThreads();
21833 (arg1)->SetCurrentFocus(arg2);
21834
21835 wxPyEndAllowThreads(__tstate);
21836 if (PyErr_Occurred()) SWIG_fail;
21837 }
21838 Py_INCREF(Py_None); resultobj = Py_None;
21839 return resultobj;
21840 fail:
21841 return NULL;
21842 }
21843
21844
21845 static PyObject * NavigationKeyEvent_swigregister(PyObject *, PyObject *args) {
21846 PyObject *obj;
21847 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21848 SWIG_TypeClientData(SWIGTYPE_p_wxNavigationKeyEvent, obj);
21849 Py_INCREF(obj);
21850 return Py_BuildValue((char *)"");
21851 }
21852 static PyObject *_wrap_new_WindowCreateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21853 PyObject *resultobj;
21854 wxWindow *arg1 = (wxWindow *) NULL ;
21855 wxWindowCreateEvent *result;
21856 PyObject * obj0 = 0 ;
21857 char *kwnames[] = {
21858 (char *) "win", NULL
21859 };
21860
21861 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) goto fail;
21862 if (obj0) {
21863 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21864 if (SWIG_arg_fail(1)) SWIG_fail;
21865 }
21866 {
21867 PyThreadState* __tstate = wxPyBeginAllowThreads();
21868 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
21869
21870 wxPyEndAllowThreads(__tstate);
21871 if (PyErr_Occurred()) SWIG_fail;
21872 }
21873 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowCreateEvent, 1);
21874 return resultobj;
21875 fail:
21876 return NULL;
21877 }
21878
21879
21880 static PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21881 PyObject *resultobj;
21882 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
21883 wxWindow *result;
21884 PyObject * obj0 = 0 ;
21885 char *kwnames[] = {
21886 (char *) "self", NULL
21887 };
21888
21889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowCreateEvent_GetWindow",kwnames,&obj0)) goto fail;
21890 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_EXCEPTION | 0);
21891 if (SWIG_arg_fail(1)) SWIG_fail;
21892 {
21893 PyThreadState* __tstate = wxPyBeginAllowThreads();
21894 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
21895
21896 wxPyEndAllowThreads(__tstate);
21897 if (PyErr_Occurred()) SWIG_fail;
21898 }
21899 {
21900 resultobj = wxPyMake_wxObject(result, 0);
21901 }
21902 return resultobj;
21903 fail:
21904 return NULL;
21905 }
21906
21907
21908 static PyObject * WindowCreateEvent_swigregister(PyObject *, PyObject *args) {
21909 PyObject *obj;
21910 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21911 SWIG_TypeClientData(SWIGTYPE_p_wxWindowCreateEvent, obj);
21912 Py_INCREF(obj);
21913 return Py_BuildValue((char *)"");
21914 }
21915 static PyObject *_wrap_new_WindowDestroyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21916 PyObject *resultobj;
21917 wxWindow *arg1 = (wxWindow *) NULL ;
21918 wxWindowDestroyEvent *result;
21919 PyObject * obj0 = 0 ;
21920 char *kwnames[] = {
21921 (char *) "win", NULL
21922 };
21923
21924 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) goto fail;
21925 if (obj0) {
21926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
21927 if (SWIG_arg_fail(1)) SWIG_fail;
21928 }
21929 {
21930 PyThreadState* __tstate = wxPyBeginAllowThreads();
21931 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
21932
21933 wxPyEndAllowThreads(__tstate);
21934 if (PyErr_Occurred()) SWIG_fail;
21935 }
21936 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindowDestroyEvent, 1);
21937 return resultobj;
21938 fail:
21939 return NULL;
21940 }
21941
21942
21943 static PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
21944 PyObject *resultobj;
21945 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
21946 wxWindow *result;
21947 PyObject * obj0 = 0 ;
21948 char *kwnames[] = {
21949 (char *) "self", NULL
21950 };
21951
21952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:WindowDestroyEvent_GetWindow",kwnames,&obj0)) goto fail;
21953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_EXCEPTION | 0);
21954 if (SWIG_arg_fail(1)) SWIG_fail;
21955 {
21956 PyThreadState* __tstate = wxPyBeginAllowThreads();
21957 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
21958
21959 wxPyEndAllowThreads(__tstate);
21960 if (PyErr_Occurred()) SWIG_fail;
21961 }
21962 {
21963 resultobj = wxPyMake_wxObject(result, 0);
21964 }
21965 return resultobj;
21966 fail:
21967 return NULL;
21968 }
21969
21970
21971 static PyObject * WindowDestroyEvent_swigregister(PyObject *, PyObject *args) {
21972 PyObject *obj;
21973 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
21974 SWIG_TypeClientData(SWIGTYPE_p_wxWindowDestroyEvent, obj);
21975 Py_INCREF(obj);
21976 return Py_BuildValue((char *)"");
21977 }
21978 static PyObject *_wrap_new_ContextMenuEvent(PyObject *, PyObject *args, PyObject *kwargs) {
21979 PyObject *resultobj;
21980 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21981 int arg2 = (int) 0 ;
21982 wxPoint const &arg3_defvalue = wxDefaultPosition ;
21983 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
21984 wxContextMenuEvent *result;
21985 wxPoint temp3 ;
21986 PyObject * obj0 = 0 ;
21987 PyObject * obj1 = 0 ;
21988 PyObject * obj2 = 0 ;
21989 char *kwnames[] = {
21990 (char *) "type",(char *) "winid",(char *) "pt", NULL
21991 };
21992
21993 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
21994 if (obj0) {
21995 {
21996 arg1 = (wxEventType)(SWIG_As_int(obj0));
21997 if (SWIG_arg_fail(1)) SWIG_fail;
21998 }
21999 }
22000 if (obj1) {
22001 {
22002 arg2 = (int)(SWIG_As_int(obj1));
22003 if (SWIG_arg_fail(2)) SWIG_fail;
22004 }
22005 }
22006 if (obj2) {
22007 {
22008 arg3 = &temp3;
22009 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
22010 }
22011 }
22012 {
22013 PyThreadState* __tstate = wxPyBeginAllowThreads();
22014 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
22015
22016 wxPyEndAllowThreads(__tstate);
22017 if (PyErr_Occurred()) SWIG_fail;
22018 }
22019 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxContextMenuEvent, 1);
22020 return resultobj;
22021 fail:
22022 return NULL;
22023 }
22024
22025
22026 static PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22027 PyObject *resultobj;
22028 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22029 wxPoint *result;
22030 PyObject * obj0 = 0 ;
22031 char *kwnames[] = {
22032 (char *) "self", NULL
22033 };
22034
22035 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ContextMenuEvent_GetPosition",kwnames,&obj0)) goto fail;
22036 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22037 if (SWIG_arg_fail(1)) SWIG_fail;
22038 {
22039 PyThreadState* __tstate = wxPyBeginAllowThreads();
22040 {
22041 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
22042 result = (wxPoint *) &_result_ref;
22043 }
22044
22045 wxPyEndAllowThreads(__tstate);
22046 if (PyErr_Occurred()) SWIG_fail;
22047 }
22048 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPoint, 0);
22049 return resultobj;
22050 fail:
22051 return NULL;
22052 }
22053
22054
22055 static PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
22056 PyObject *resultobj;
22057 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
22058 wxPoint *arg2 = 0 ;
22059 wxPoint temp2 ;
22060 PyObject * obj0 = 0 ;
22061 PyObject * obj1 = 0 ;
22062 char *kwnames[] = {
22063 (char *) "self",(char *) "pos", NULL
22064 };
22065
22066 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) goto fail;
22067 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_EXCEPTION | 0);
22068 if (SWIG_arg_fail(1)) SWIG_fail;
22069 {
22070 arg2 = &temp2;
22071 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
22072 }
22073 {
22074 PyThreadState* __tstate = wxPyBeginAllowThreads();
22075 (arg1)->SetPosition((wxPoint const &)*arg2);
22076
22077 wxPyEndAllowThreads(__tstate);
22078 if (PyErr_Occurred()) SWIG_fail;
22079 }
22080 Py_INCREF(Py_None); resultobj = Py_None;
22081 return resultobj;
22082 fail:
22083 return NULL;
22084 }
22085
22086
22087 static PyObject * ContextMenuEvent_swigregister(PyObject *, PyObject *args) {
22088 PyObject *obj;
22089 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22090 SWIG_TypeClientData(SWIGTYPE_p_wxContextMenuEvent, obj);
22091 Py_INCREF(obj);
22092 return Py_BuildValue((char *)"");
22093 }
22094 static PyObject *_wrap_new_IdleEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22095 PyObject *resultobj;
22096 wxIdleEvent *result;
22097 char *kwnames[] = {
22098 NULL
22099 };
22100
22101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_IdleEvent",kwnames)) goto fail;
22102 {
22103 PyThreadState* __tstate = wxPyBeginAllowThreads();
22104 result = (wxIdleEvent *)new wxIdleEvent();
22105
22106 wxPyEndAllowThreads(__tstate);
22107 if (PyErr_Occurred()) SWIG_fail;
22108 }
22109 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIdleEvent, 1);
22110 return resultobj;
22111 fail:
22112 return NULL;
22113 }
22114
22115
22116 static PyObject *_wrap_IdleEvent_RequestMore(PyObject *, PyObject *args, PyObject *kwargs) {
22117 PyObject *resultobj;
22118 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22119 bool arg2 = (bool) true ;
22120 PyObject * obj0 = 0 ;
22121 PyObject * obj1 = 0 ;
22122 char *kwnames[] = {
22123 (char *) "self",(char *) "needMore", NULL
22124 };
22125
22126 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) goto fail;
22127 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22128 if (SWIG_arg_fail(1)) SWIG_fail;
22129 if (obj1) {
22130 {
22131 arg2 = (bool)(SWIG_As_bool(obj1));
22132 if (SWIG_arg_fail(2)) SWIG_fail;
22133 }
22134 }
22135 {
22136 PyThreadState* __tstate = wxPyBeginAllowThreads();
22137 (arg1)->RequestMore(arg2);
22138
22139 wxPyEndAllowThreads(__tstate);
22140 if (PyErr_Occurred()) SWIG_fail;
22141 }
22142 Py_INCREF(Py_None); resultobj = Py_None;
22143 return resultobj;
22144 fail:
22145 return NULL;
22146 }
22147
22148
22149 static PyObject *_wrap_IdleEvent_MoreRequested(PyObject *, PyObject *args, PyObject *kwargs) {
22150 PyObject *resultobj;
22151 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
22152 bool result;
22153 PyObject * obj0 = 0 ;
22154 char *kwnames[] = {
22155 (char *) "self", NULL
22156 };
22157
22158 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_MoreRequested",kwnames,&obj0)) goto fail;
22159 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
22160 if (SWIG_arg_fail(1)) SWIG_fail;
22161 {
22162 PyThreadState* __tstate = wxPyBeginAllowThreads();
22163 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
22164
22165 wxPyEndAllowThreads(__tstate);
22166 if (PyErr_Occurred()) SWIG_fail;
22167 }
22168 {
22169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22170 }
22171 return resultobj;
22172 fail:
22173 return NULL;
22174 }
22175
22176
22177 static PyObject *_wrap_IdleEvent_SetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22178 PyObject *resultobj;
22179 wxIdleMode arg1 ;
22180 PyObject * obj0 = 0 ;
22181 char *kwnames[] = {
22182 (char *) "mode", NULL
22183 };
22184
22185 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) goto fail;
22186 {
22187 arg1 = (wxIdleMode)(SWIG_As_int(obj0));
22188 if (SWIG_arg_fail(1)) SWIG_fail;
22189 }
22190 {
22191 PyThreadState* __tstate = wxPyBeginAllowThreads();
22192 wxIdleEvent::SetMode((wxIdleMode )arg1);
22193
22194 wxPyEndAllowThreads(__tstate);
22195 if (PyErr_Occurred()) SWIG_fail;
22196 }
22197 Py_INCREF(Py_None); resultobj = Py_None;
22198 return resultobj;
22199 fail:
22200 return NULL;
22201 }
22202
22203
22204 static PyObject *_wrap_IdleEvent_GetMode(PyObject *, PyObject *args, PyObject *kwargs) {
22205 PyObject *resultobj;
22206 wxIdleMode result;
22207 char *kwnames[] = {
22208 NULL
22209 };
22210
22211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":IdleEvent_GetMode",kwnames)) goto fail;
22212 {
22213 PyThreadState* __tstate = wxPyBeginAllowThreads();
22214 result = (wxIdleMode)wxIdleEvent::GetMode();
22215
22216 wxPyEndAllowThreads(__tstate);
22217 if (PyErr_Occurred()) SWIG_fail;
22218 }
22219 resultobj = SWIG_From_int((result));
22220 return resultobj;
22221 fail:
22222 return NULL;
22223 }
22224
22225
22226 static PyObject *_wrap_IdleEvent_CanSend(PyObject *, PyObject *args, PyObject *kwargs) {
22227 PyObject *resultobj;
22228 wxWindow *arg1 = (wxWindow *) 0 ;
22229 bool result;
22230 PyObject * obj0 = 0 ;
22231 char *kwnames[] = {
22232 (char *) "win", NULL
22233 };
22234
22235 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) goto fail;
22236 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22237 if (SWIG_arg_fail(1)) SWIG_fail;
22238 {
22239 PyThreadState* __tstate = wxPyBeginAllowThreads();
22240 result = (bool)wxIdleEvent::CanSend(arg1);
22241
22242 wxPyEndAllowThreads(__tstate);
22243 if (PyErr_Occurred()) SWIG_fail;
22244 }
22245 {
22246 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22247 }
22248 return resultobj;
22249 fail:
22250 return NULL;
22251 }
22252
22253
22254 static PyObject * IdleEvent_swigregister(PyObject *, PyObject *args) {
22255 PyObject *obj;
22256 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22257 SWIG_TypeClientData(SWIGTYPE_p_wxIdleEvent, obj);
22258 Py_INCREF(obj);
22259 return Py_BuildValue((char *)"");
22260 }
22261 static PyObject *_wrap_new_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22262 PyObject *resultobj;
22263 int arg1 = (int) 0 ;
22264 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
22265 wxPyEvent *result;
22266 PyObject * obj0 = 0 ;
22267 PyObject * obj1 = 0 ;
22268 char *kwnames[] = {
22269 (char *) "winid",(char *) "commandType", NULL
22270 };
22271
22272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) goto fail;
22273 if (obj0) {
22274 {
22275 arg1 = (int)(SWIG_As_int(obj0));
22276 if (SWIG_arg_fail(1)) SWIG_fail;
22277 }
22278 }
22279 if (obj1) {
22280 {
22281 arg2 = (wxEventType)(SWIG_As_int(obj1));
22282 if (SWIG_arg_fail(2)) SWIG_fail;
22283 }
22284 }
22285 {
22286 PyThreadState* __tstate = wxPyBeginAllowThreads();
22287 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
22288
22289 wxPyEndAllowThreads(__tstate);
22290 if (PyErr_Occurred()) SWIG_fail;
22291 }
22292 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyEvent, 1);
22293 return resultobj;
22294 fail:
22295 return NULL;
22296 }
22297
22298
22299 static PyObject *_wrap_delete_PyEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22300 PyObject *resultobj;
22301 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22302 PyObject * obj0 = 0 ;
22303 char *kwnames[] = {
22304 (char *) "self", NULL
22305 };
22306
22307 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyEvent",kwnames,&obj0)) goto fail;
22308 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22309 if (SWIG_arg_fail(1)) SWIG_fail;
22310 {
22311 PyThreadState* __tstate = wxPyBeginAllowThreads();
22312 delete arg1;
22313
22314 wxPyEndAllowThreads(__tstate);
22315 if (PyErr_Occurred()) SWIG_fail;
22316 }
22317 Py_INCREF(Py_None); resultobj = Py_None;
22318 return resultobj;
22319 fail:
22320 return NULL;
22321 }
22322
22323
22324 static PyObject *_wrap_PyEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22325 PyObject *resultobj;
22326 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22327 PyObject *arg2 = (PyObject *) 0 ;
22328 PyObject * obj0 = 0 ;
22329 PyObject * obj1 = 0 ;
22330 char *kwnames[] = {
22331 (char *) "self",(char *) "self", NULL
22332 };
22333
22334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22336 if (SWIG_arg_fail(1)) SWIG_fail;
22337 arg2 = obj1;
22338 {
22339 PyThreadState* __tstate = wxPyBeginAllowThreads();
22340 (arg1)->SetSelf(arg2);
22341
22342 wxPyEndAllowThreads(__tstate);
22343 if (PyErr_Occurred()) SWIG_fail;
22344 }
22345 Py_INCREF(Py_None); resultobj = Py_None;
22346 return resultobj;
22347 fail:
22348 return NULL;
22349 }
22350
22351
22352 static PyObject *_wrap_PyEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22353 PyObject *resultobj;
22354 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
22355 PyObject *result;
22356 PyObject * obj0 = 0 ;
22357 char *kwnames[] = {
22358 (char *) "self", NULL
22359 };
22360
22361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyEvent_GetSelf",kwnames,&obj0)) goto fail;
22362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyEvent, SWIG_POINTER_EXCEPTION | 0);
22363 if (SWIG_arg_fail(1)) SWIG_fail;
22364 {
22365 PyThreadState* __tstate = wxPyBeginAllowThreads();
22366 result = (PyObject *)(arg1)->GetSelf();
22367
22368 wxPyEndAllowThreads(__tstate);
22369 if (PyErr_Occurred()) SWIG_fail;
22370 }
22371 resultobj = result;
22372 return resultobj;
22373 fail:
22374 return NULL;
22375 }
22376
22377
22378 static PyObject * PyEvent_swigregister(PyObject *, PyObject *args) {
22379 PyObject *obj;
22380 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22381 SWIG_TypeClientData(SWIGTYPE_p_wxPyEvent, obj);
22382 Py_INCREF(obj);
22383 return Py_BuildValue((char *)"");
22384 }
22385 static PyObject *_wrap_new_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22386 PyObject *resultobj;
22387 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22388 int arg2 = (int) 0 ;
22389 wxPyCommandEvent *result;
22390 PyObject * obj0 = 0 ;
22391 PyObject * obj1 = 0 ;
22392 char *kwnames[] = {
22393 (char *) "commandType",(char *) "id", NULL
22394 };
22395
22396 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) goto fail;
22397 if (obj0) {
22398 {
22399 arg1 = (wxEventType)(SWIG_As_int(obj0));
22400 if (SWIG_arg_fail(1)) SWIG_fail;
22401 }
22402 }
22403 if (obj1) {
22404 {
22405 arg2 = (int)(SWIG_As_int(obj1));
22406 if (SWIG_arg_fail(2)) SWIG_fail;
22407 }
22408 }
22409 {
22410 PyThreadState* __tstate = wxPyBeginAllowThreads();
22411 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
22412
22413 wxPyEndAllowThreads(__tstate);
22414 if (PyErr_Occurred()) SWIG_fail;
22415 }
22416 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyCommandEvent, 1);
22417 return resultobj;
22418 fail:
22419 return NULL;
22420 }
22421
22422
22423 static PyObject *_wrap_delete_PyCommandEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22424 PyObject *resultobj;
22425 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22426 PyObject * obj0 = 0 ;
22427 char *kwnames[] = {
22428 (char *) "self", NULL
22429 };
22430
22431 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyCommandEvent",kwnames,&obj0)) goto fail;
22432 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22433 if (SWIG_arg_fail(1)) SWIG_fail;
22434 {
22435 PyThreadState* __tstate = wxPyBeginAllowThreads();
22436 delete arg1;
22437
22438 wxPyEndAllowThreads(__tstate);
22439 if (PyErr_Occurred()) SWIG_fail;
22440 }
22441 Py_INCREF(Py_None); resultobj = Py_None;
22442 return resultobj;
22443 fail:
22444 return NULL;
22445 }
22446
22447
22448 static PyObject *_wrap_PyCommandEvent_SetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22449 PyObject *resultobj;
22450 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22451 PyObject *arg2 = (PyObject *) 0 ;
22452 PyObject * obj0 = 0 ;
22453 PyObject * obj1 = 0 ;
22454 char *kwnames[] = {
22455 (char *) "self",(char *) "self", NULL
22456 };
22457
22458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent_SetSelf",kwnames,&obj0,&obj1)) goto fail;
22459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22460 if (SWIG_arg_fail(1)) SWIG_fail;
22461 arg2 = obj1;
22462 {
22463 PyThreadState* __tstate = wxPyBeginAllowThreads();
22464 (arg1)->SetSelf(arg2);
22465
22466 wxPyEndAllowThreads(__tstate);
22467 if (PyErr_Occurred()) SWIG_fail;
22468 }
22469 Py_INCREF(Py_None); resultobj = Py_None;
22470 return resultobj;
22471 fail:
22472 return NULL;
22473 }
22474
22475
22476 static PyObject *_wrap_PyCommandEvent_GetSelf(PyObject *, PyObject *args, PyObject *kwargs) {
22477 PyObject *resultobj;
22478 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
22479 PyObject *result;
22480 PyObject * obj0 = 0 ;
22481 char *kwnames[] = {
22482 (char *) "self", NULL
22483 };
22484
22485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyCommandEvent_GetSelf",kwnames,&obj0)) goto fail;
22486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_EXCEPTION | 0);
22487 if (SWIG_arg_fail(1)) SWIG_fail;
22488 {
22489 PyThreadState* __tstate = wxPyBeginAllowThreads();
22490 result = (PyObject *)(arg1)->GetSelf();
22491
22492 wxPyEndAllowThreads(__tstate);
22493 if (PyErr_Occurred()) SWIG_fail;
22494 }
22495 resultobj = result;
22496 return resultobj;
22497 fail:
22498 return NULL;
22499 }
22500
22501
22502 static PyObject * PyCommandEvent_swigregister(PyObject *, PyObject *args) {
22503 PyObject *obj;
22504 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22505 SWIG_TypeClientData(SWIGTYPE_p_wxPyCommandEvent, obj);
22506 Py_INCREF(obj);
22507 return Py_BuildValue((char *)"");
22508 }
22509 static PyObject *_wrap_new_DateEvent(PyObject *, PyObject *args, PyObject *kwargs) {
22510 PyObject *resultobj;
22511 wxWindow *arg1 = (wxWindow *) 0 ;
22512 wxDateTime *arg2 = 0 ;
22513 wxEventType arg3 ;
22514 wxDateEvent *result;
22515 PyObject * obj0 = 0 ;
22516 PyObject * obj1 = 0 ;
22517 PyObject * obj2 = 0 ;
22518 char *kwnames[] = {
22519 (char *) "win",(char *) "dt",(char *) "type", NULL
22520 };
22521
22522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) goto fail;
22523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
22524 if (SWIG_arg_fail(1)) SWIG_fail;
22525 {
22526 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22527 if (SWIG_arg_fail(2)) SWIG_fail;
22528 if (arg2 == NULL) {
22529 SWIG_null_ref("wxDateTime");
22530 }
22531 if (SWIG_arg_fail(2)) SWIG_fail;
22532 }
22533 {
22534 arg3 = (wxEventType)(SWIG_As_int(obj2));
22535 if (SWIG_arg_fail(3)) SWIG_fail;
22536 }
22537 {
22538 PyThreadState* __tstate = wxPyBeginAllowThreads();
22539 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
22540
22541 wxPyEndAllowThreads(__tstate);
22542 if (PyErr_Occurred()) SWIG_fail;
22543 }
22544 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateEvent, 1);
22545 return resultobj;
22546 fail:
22547 return NULL;
22548 }
22549
22550
22551 static PyObject *_wrap_DateEvent_GetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22552 PyObject *resultobj;
22553 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22554 wxDateTime *result;
22555 PyObject * obj0 = 0 ;
22556 char *kwnames[] = {
22557 (char *) "self", NULL
22558 };
22559
22560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:DateEvent_GetDate",kwnames,&obj0)) goto fail;
22561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22562 if (SWIG_arg_fail(1)) SWIG_fail;
22563 {
22564 PyThreadState* __tstate = wxPyBeginAllowThreads();
22565 {
22566 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
22567 result = (wxDateTime *) &_result_ref;
22568 }
22569
22570 wxPyEndAllowThreads(__tstate);
22571 if (PyErr_Occurred()) SWIG_fail;
22572 }
22573 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxDateTime, 0);
22574 return resultobj;
22575 fail:
22576 return NULL;
22577 }
22578
22579
22580 static PyObject *_wrap_DateEvent_SetDate(PyObject *, PyObject *args, PyObject *kwargs) {
22581 PyObject *resultobj;
22582 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
22583 wxDateTime *arg2 = 0 ;
22584 PyObject * obj0 = 0 ;
22585 PyObject * obj1 = 0 ;
22586 char *kwnames[] = {
22587 (char *) "self",(char *) "date", NULL
22588 };
22589
22590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) goto fail;
22591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxDateEvent, SWIG_POINTER_EXCEPTION | 0);
22592 if (SWIG_arg_fail(1)) SWIG_fail;
22593 {
22594 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDateTime, SWIG_POINTER_EXCEPTION | 0);
22595 if (SWIG_arg_fail(2)) SWIG_fail;
22596 if (arg2 == NULL) {
22597 SWIG_null_ref("wxDateTime");
22598 }
22599 if (SWIG_arg_fail(2)) SWIG_fail;
22600 }
22601 {
22602 PyThreadState* __tstate = wxPyBeginAllowThreads();
22603 (arg1)->SetDate((wxDateTime const &)*arg2);
22604
22605 wxPyEndAllowThreads(__tstate);
22606 if (PyErr_Occurred()) SWIG_fail;
22607 }
22608 Py_INCREF(Py_None); resultobj = Py_None;
22609 return resultobj;
22610 fail:
22611 return NULL;
22612 }
22613
22614
22615 static PyObject * DateEvent_swigregister(PyObject *, PyObject *args) {
22616 PyObject *obj;
22617 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
22618 SWIG_TypeClientData(SWIGTYPE_p_wxDateEvent, obj);
22619 Py_INCREF(obj);
22620 return Py_BuildValue((char *)"");
22621 }
22622 static PyObject *_wrap_new_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22623 PyObject *resultobj;
22624 wxPyApp *result;
22625 char *kwnames[] = {
22626 NULL
22627 };
22628
22629 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyApp",kwnames)) goto fail;
22630 {
22631 PyThreadState* __tstate = wxPyBeginAllowThreads();
22632 result = (wxPyApp *)new_wxPyApp();
22633
22634 wxPyEndAllowThreads(__tstate);
22635 if (PyErr_Occurred()) SWIG_fail;
22636 }
22637 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyApp, 1);
22638 return resultobj;
22639 fail:
22640 return NULL;
22641 }
22642
22643
22644 static PyObject *_wrap_delete_PyApp(PyObject *, PyObject *args, PyObject *kwargs) {
22645 PyObject *resultobj;
22646 wxPyApp *arg1 = (wxPyApp *) 0 ;
22647 PyObject * obj0 = 0 ;
22648 char *kwnames[] = {
22649 (char *) "self", NULL
22650 };
22651
22652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_PyApp",kwnames,&obj0)) goto fail;
22653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22654 if (SWIG_arg_fail(1)) SWIG_fail;
22655 {
22656 PyThreadState* __tstate = wxPyBeginAllowThreads();
22657 delete arg1;
22658
22659 wxPyEndAllowThreads(__tstate);
22660 if (PyErr_Occurred()) SWIG_fail;
22661 }
22662 Py_INCREF(Py_None); resultobj = Py_None;
22663 return resultobj;
22664 fail:
22665 return NULL;
22666 }
22667
22668
22669 static PyObject *_wrap_PyApp__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
22670 PyObject *resultobj;
22671 wxPyApp *arg1 = (wxPyApp *) 0 ;
22672 PyObject *arg2 = (PyObject *) 0 ;
22673 PyObject *arg3 = (PyObject *) 0 ;
22674 PyObject * obj0 = 0 ;
22675 PyObject * obj1 = 0 ;
22676 PyObject * obj2 = 0 ;
22677 char *kwnames[] = {
22678 (char *) "self",(char *) "self",(char *) "_class", NULL
22679 };
22680
22681 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
22682 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22683 if (SWIG_arg_fail(1)) SWIG_fail;
22684 arg2 = obj1;
22685 arg3 = obj2;
22686 {
22687 PyThreadState* __tstate = wxPyBeginAllowThreads();
22688 (arg1)->_setCallbackInfo(arg2,arg3);
22689
22690 wxPyEndAllowThreads(__tstate);
22691 if (PyErr_Occurred()) SWIG_fail;
22692 }
22693 Py_INCREF(Py_None); resultobj = Py_None;
22694 return resultobj;
22695 fail:
22696 return NULL;
22697 }
22698
22699
22700 static PyObject *_wrap_PyApp_GetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22701 PyObject *resultobj;
22702 wxPyApp *arg1 = (wxPyApp *) 0 ;
22703 wxString result;
22704 PyObject * obj0 = 0 ;
22705 char *kwnames[] = {
22706 (char *) "self", NULL
22707 };
22708
22709 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAppName",kwnames,&obj0)) goto fail;
22710 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22711 if (SWIG_arg_fail(1)) SWIG_fail;
22712 {
22713 PyThreadState* __tstate = wxPyBeginAllowThreads();
22714 result = ((wxPyApp const *)arg1)->GetAppName();
22715
22716 wxPyEndAllowThreads(__tstate);
22717 if (PyErr_Occurred()) SWIG_fail;
22718 }
22719 {
22720 #if wxUSE_UNICODE
22721 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22722 #else
22723 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22724 #endif
22725 }
22726 return resultobj;
22727 fail:
22728 return NULL;
22729 }
22730
22731
22732 static PyObject *_wrap_PyApp_SetAppName(PyObject *, PyObject *args, PyObject *kwargs) {
22733 PyObject *resultobj;
22734 wxPyApp *arg1 = (wxPyApp *) 0 ;
22735 wxString *arg2 = 0 ;
22736 bool temp2 = false ;
22737 PyObject * obj0 = 0 ;
22738 PyObject * obj1 = 0 ;
22739 char *kwnames[] = {
22740 (char *) "self",(char *) "name", NULL
22741 };
22742
22743 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) goto fail;
22744 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22745 if (SWIG_arg_fail(1)) SWIG_fail;
22746 {
22747 arg2 = wxString_in_helper(obj1);
22748 if (arg2 == NULL) SWIG_fail;
22749 temp2 = true;
22750 }
22751 {
22752 PyThreadState* __tstate = wxPyBeginAllowThreads();
22753 (arg1)->SetAppName((wxString const &)*arg2);
22754
22755 wxPyEndAllowThreads(__tstate);
22756 if (PyErr_Occurred()) SWIG_fail;
22757 }
22758 Py_INCREF(Py_None); resultobj = Py_None;
22759 {
22760 if (temp2)
22761 delete arg2;
22762 }
22763 return resultobj;
22764 fail:
22765 {
22766 if (temp2)
22767 delete arg2;
22768 }
22769 return NULL;
22770 }
22771
22772
22773 static PyObject *_wrap_PyApp_GetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22774 PyObject *resultobj;
22775 wxPyApp *arg1 = (wxPyApp *) 0 ;
22776 wxString result;
22777 PyObject * obj0 = 0 ;
22778 char *kwnames[] = {
22779 (char *) "self", NULL
22780 };
22781
22782 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetClassName",kwnames,&obj0)) goto fail;
22783 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22784 if (SWIG_arg_fail(1)) SWIG_fail;
22785 {
22786 PyThreadState* __tstate = wxPyBeginAllowThreads();
22787 result = ((wxPyApp const *)arg1)->GetClassName();
22788
22789 wxPyEndAllowThreads(__tstate);
22790 if (PyErr_Occurred()) SWIG_fail;
22791 }
22792 {
22793 #if wxUSE_UNICODE
22794 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
22795 #else
22796 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
22797 #endif
22798 }
22799 return resultobj;
22800 fail:
22801 return NULL;
22802 }
22803
22804
22805 static PyObject *_wrap_PyApp_SetClassName(PyObject *, PyObject *args, PyObject *kwargs) {
22806 PyObject *resultobj;
22807 wxPyApp *arg1 = (wxPyApp *) 0 ;
22808 wxString *arg2 = 0 ;
22809 bool temp2 = false ;
22810 PyObject * obj0 = 0 ;
22811 PyObject * obj1 = 0 ;
22812 char *kwnames[] = {
22813 (char *) "self",(char *) "name", NULL
22814 };
22815
22816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) goto fail;
22817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22818 if (SWIG_arg_fail(1)) SWIG_fail;
22819 {
22820 arg2 = wxString_in_helper(obj1);
22821 if (arg2 == NULL) SWIG_fail;
22822 temp2 = true;
22823 }
22824 {
22825 PyThreadState* __tstate = wxPyBeginAllowThreads();
22826 (arg1)->SetClassName((wxString const &)*arg2);
22827
22828 wxPyEndAllowThreads(__tstate);
22829 if (PyErr_Occurred()) SWIG_fail;
22830 }
22831 Py_INCREF(Py_None); resultobj = Py_None;
22832 {
22833 if (temp2)
22834 delete arg2;
22835 }
22836 return resultobj;
22837 fail:
22838 {
22839 if (temp2)
22840 delete arg2;
22841 }
22842 return NULL;
22843 }
22844
22845
22846 static PyObject *_wrap_PyApp_GetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22847 PyObject *resultobj;
22848 wxPyApp *arg1 = (wxPyApp *) 0 ;
22849 wxString *result;
22850 PyObject * obj0 = 0 ;
22851 char *kwnames[] = {
22852 (char *) "self", NULL
22853 };
22854
22855 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetVendorName",kwnames,&obj0)) goto fail;
22856 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22857 if (SWIG_arg_fail(1)) SWIG_fail;
22858 {
22859 PyThreadState* __tstate = wxPyBeginAllowThreads();
22860 {
22861 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
22862 result = (wxString *) &_result_ref;
22863 }
22864
22865 wxPyEndAllowThreads(__tstate);
22866 if (PyErr_Occurred()) SWIG_fail;
22867 }
22868 {
22869 #if wxUSE_UNICODE
22870 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
22871 #else
22872 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
22873 #endif
22874 }
22875 return resultobj;
22876 fail:
22877 return NULL;
22878 }
22879
22880
22881 static PyObject *_wrap_PyApp_SetVendorName(PyObject *, PyObject *args, PyObject *kwargs) {
22882 PyObject *resultobj;
22883 wxPyApp *arg1 = (wxPyApp *) 0 ;
22884 wxString *arg2 = 0 ;
22885 bool temp2 = false ;
22886 PyObject * obj0 = 0 ;
22887 PyObject * obj1 = 0 ;
22888 char *kwnames[] = {
22889 (char *) "self",(char *) "name", NULL
22890 };
22891
22892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) goto fail;
22893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22894 if (SWIG_arg_fail(1)) SWIG_fail;
22895 {
22896 arg2 = wxString_in_helper(obj1);
22897 if (arg2 == NULL) SWIG_fail;
22898 temp2 = true;
22899 }
22900 {
22901 PyThreadState* __tstate = wxPyBeginAllowThreads();
22902 (arg1)->SetVendorName((wxString const &)*arg2);
22903
22904 wxPyEndAllowThreads(__tstate);
22905 if (PyErr_Occurred()) SWIG_fail;
22906 }
22907 Py_INCREF(Py_None); resultobj = Py_None;
22908 {
22909 if (temp2)
22910 delete arg2;
22911 }
22912 return resultobj;
22913 fail:
22914 {
22915 if (temp2)
22916 delete arg2;
22917 }
22918 return NULL;
22919 }
22920
22921
22922 static PyObject *_wrap_PyApp_GetTraits(PyObject *, PyObject *args, PyObject *kwargs) {
22923 PyObject *resultobj;
22924 wxPyApp *arg1 = (wxPyApp *) 0 ;
22925 wxAppTraits *result;
22926 PyObject * obj0 = 0 ;
22927 char *kwnames[] = {
22928 (char *) "self", NULL
22929 };
22930
22931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTraits",kwnames,&obj0)) goto fail;
22932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22933 if (SWIG_arg_fail(1)) SWIG_fail;
22934 {
22935 PyThreadState* __tstate = wxPyBeginAllowThreads();
22936 result = (wxAppTraits *)(arg1)->GetTraits();
22937
22938 wxPyEndAllowThreads(__tstate);
22939 if (PyErr_Occurred()) SWIG_fail;
22940 }
22941 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAppTraits, 0);
22942 return resultobj;
22943 fail:
22944 return NULL;
22945 }
22946
22947
22948 static PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *, PyObject *args, PyObject *kwargs) {
22949 PyObject *resultobj;
22950 wxPyApp *arg1 = (wxPyApp *) 0 ;
22951 PyObject * obj0 = 0 ;
22952 char *kwnames[] = {
22953 (char *) "self", NULL
22954 };
22955
22956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessPendingEvents",kwnames,&obj0)) goto fail;
22957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22958 if (SWIG_arg_fail(1)) SWIG_fail;
22959 {
22960 PyThreadState* __tstate = wxPyBeginAllowThreads();
22961 (arg1)->ProcessPendingEvents();
22962
22963 wxPyEndAllowThreads(__tstate);
22964 if (PyErr_Occurred()) SWIG_fail;
22965 }
22966 Py_INCREF(Py_None); resultobj = Py_None;
22967 return resultobj;
22968 fail:
22969 return NULL;
22970 }
22971
22972
22973 static PyObject *_wrap_PyApp_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
22974 PyObject *resultobj;
22975 wxPyApp *arg1 = (wxPyApp *) 0 ;
22976 bool arg2 = (bool) false ;
22977 bool result;
22978 PyObject * obj0 = 0 ;
22979 PyObject * obj1 = 0 ;
22980 char *kwnames[] = {
22981 (char *) "self",(char *) "onlyIfNeeded", NULL
22982 };
22983
22984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) goto fail;
22985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
22986 if (SWIG_arg_fail(1)) SWIG_fail;
22987 if (obj1) {
22988 {
22989 arg2 = (bool)(SWIG_As_bool(obj1));
22990 if (SWIG_arg_fail(2)) SWIG_fail;
22991 }
22992 }
22993 {
22994 PyThreadState* __tstate = wxPyBeginAllowThreads();
22995 result = (bool)(arg1)->Yield(arg2);
22996
22997 wxPyEndAllowThreads(__tstate);
22998 if (PyErr_Occurred()) SWIG_fail;
22999 }
23000 {
23001 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23002 }
23003 return resultobj;
23004 fail:
23005 return NULL;
23006 }
23007
23008
23009 static PyObject *_wrap_PyApp_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23010 PyObject *resultobj;
23011 wxPyApp *arg1 = (wxPyApp *) 0 ;
23012 PyObject * obj0 = 0 ;
23013 char *kwnames[] = {
23014 (char *) "self", NULL
23015 };
23016
23017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_WakeUpIdle",kwnames,&obj0)) goto fail;
23018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23019 if (SWIG_arg_fail(1)) SWIG_fail;
23020 {
23021 PyThreadState* __tstate = wxPyBeginAllowThreads();
23022 (arg1)->WakeUpIdle();
23023
23024 wxPyEndAllowThreads(__tstate);
23025 if (PyErr_Occurred()) SWIG_fail;
23026 }
23027 Py_INCREF(Py_None); resultobj = Py_None;
23028 return resultobj;
23029 fail:
23030 return NULL;
23031 }
23032
23033
23034 static PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *, PyObject *args, PyObject *kwargs) {
23035 PyObject *resultobj;
23036 bool result;
23037 char *kwnames[] = {
23038 NULL
23039 };
23040
23041 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_IsMainLoopRunning",kwnames)) goto fail;
23042 {
23043 PyThreadState* __tstate = wxPyBeginAllowThreads();
23044 result = (bool)wxPyApp::IsMainLoopRunning();
23045
23046 wxPyEndAllowThreads(__tstate);
23047 if (PyErr_Occurred()) SWIG_fail;
23048 }
23049 {
23050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23051 }
23052 return resultobj;
23053 fail:
23054 return NULL;
23055 }
23056
23057
23058 static PyObject *_wrap_PyApp_MainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23059 PyObject *resultobj;
23060 wxPyApp *arg1 = (wxPyApp *) 0 ;
23061 int result;
23062 PyObject * obj0 = 0 ;
23063 char *kwnames[] = {
23064 (char *) "self", NULL
23065 };
23066
23067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_MainLoop",kwnames,&obj0)) goto fail;
23068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23069 if (SWIG_arg_fail(1)) SWIG_fail;
23070 {
23071 PyThreadState* __tstate = wxPyBeginAllowThreads();
23072 result = (int)(arg1)->MainLoop();
23073
23074 wxPyEndAllowThreads(__tstate);
23075 if (PyErr_Occurred()) SWIG_fail;
23076 }
23077 {
23078 resultobj = SWIG_From_int((int)(result));
23079 }
23080 return resultobj;
23081 fail:
23082 return NULL;
23083 }
23084
23085
23086 static PyObject *_wrap_PyApp_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23087 PyObject *resultobj;
23088 wxPyApp *arg1 = (wxPyApp *) 0 ;
23089 PyObject * obj0 = 0 ;
23090 char *kwnames[] = {
23091 (char *) "self", NULL
23092 };
23093
23094 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Exit",kwnames,&obj0)) goto fail;
23095 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23096 if (SWIG_arg_fail(1)) SWIG_fail;
23097 {
23098 PyThreadState* __tstate = wxPyBeginAllowThreads();
23099 (arg1)->Exit();
23100
23101 wxPyEndAllowThreads(__tstate);
23102 if (PyErr_Occurred()) SWIG_fail;
23103 }
23104 Py_INCREF(Py_None); resultobj = Py_None;
23105 return resultobj;
23106 fail:
23107 return NULL;
23108 }
23109
23110
23111 static PyObject *_wrap_PyApp_ExitMainLoop(PyObject *, PyObject *args, PyObject *kwargs) {
23112 PyObject *resultobj;
23113 wxPyApp *arg1 = (wxPyApp *) 0 ;
23114 PyObject * obj0 = 0 ;
23115 char *kwnames[] = {
23116 (char *) "self", NULL
23117 };
23118
23119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ExitMainLoop",kwnames,&obj0)) goto fail;
23120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23121 if (SWIG_arg_fail(1)) SWIG_fail;
23122 {
23123 PyThreadState* __tstate = wxPyBeginAllowThreads();
23124 (arg1)->ExitMainLoop();
23125
23126 wxPyEndAllowThreads(__tstate);
23127 if (PyErr_Occurred()) SWIG_fail;
23128 }
23129 Py_INCREF(Py_None); resultobj = Py_None;
23130 return resultobj;
23131 fail:
23132 return NULL;
23133 }
23134
23135
23136 static PyObject *_wrap_PyApp_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
23137 PyObject *resultobj;
23138 wxPyApp *arg1 = (wxPyApp *) 0 ;
23139 bool result;
23140 PyObject * obj0 = 0 ;
23141 char *kwnames[] = {
23142 (char *) "self", NULL
23143 };
23144
23145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Pending",kwnames,&obj0)) goto fail;
23146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23147 if (SWIG_arg_fail(1)) SWIG_fail;
23148 {
23149 PyThreadState* __tstate = wxPyBeginAllowThreads();
23150 result = (bool)(arg1)->Pending();
23151
23152 wxPyEndAllowThreads(__tstate);
23153 if (PyErr_Occurred()) SWIG_fail;
23154 }
23155 {
23156 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23157 }
23158 return resultobj;
23159 fail:
23160 return NULL;
23161 }
23162
23163
23164 static PyObject *_wrap_PyApp_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
23165 PyObject *resultobj;
23166 wxPyApp *arg1 = (wxPyApp *) 0 ;
23167 bool result;
23168 PyObject * obj0 = 0 ;
23169 char *kwnames[] = {
23170 (char *) "self", NULL
23171 };
23172
23173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_Dispatch",kwnames,&obj0)) goto fail;
23174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23175 if (SWIG_arg_fail(1)) SWIG_fail;
23176 {
23177 PyThreadState* __tstate = wxPyBeginAllowThreads();
23178 result = (bool)(arg1)->Dispatch();
23179
23180 wxPyEndAllowThreads(__tstate);
23181 if (PyErr_Occurred()) SWIG_fail;
23182 }
23183 {
23184 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23185 }
23186 return resultobj;
23187 fail:
23188 return NULL;
23189 }
23190
23191
23192 static PyObject *_wrap_PyApp_ProcessIdle(PyObject *, PyObject *args, PyObject *kwargs) {
23193 PyObject *resultobj;
23194 wxPyApp *arg1 = (wxPyApp *) 0 ;
23195 bool result;
23196 PyObject * obj0 = 0 ;
23197 char *kwnames[] = {
23198 (char *) "self", NULL
23199 };
23200
23201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_ProcessIdle",kwnames,&obj0)) goto fail;
23202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23203 if (SWIG_arg_fail(1)) SWIG_fail;
23204 {
23205 PyThreadState* __tstate = wxPyBeginAllowThreads();
23206 result = (bool)(arg1)->ProcessIdle();
23207
23208 wxPyEndAllowThreads(__tstate);
23209 if (PyErr_Occurred()) SWIG_fail;
23210 }
23211 {
23212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23213 }
23214 return resultobj;
23215 fail:
23216 return NULL;
23217 }
23218
23219
23220 static PyObject *_wrap_PyApp_SendIdleEvents(PyObject *, PyObject *args, PyObject *kwargs) {
23221 PyObject *resultobj;
23222 wxPyApp *arg1 = (wxPyApp *) 0 ;
23223 wxWindow *arg2 = (wxWindow *) 0 ;
23224 wxIdleEvent *arg3 = 0 ;
23225 bool result;
23226 PyObject * obj0 = 0 ;
23227 PyObject * obj1 = 0 ;
23228 PyObject * obj2 = 0 ;
23229 char *kwnames[] = {
23230 (char *) "self",(char *) "win",(char *) "event", NULL
23231 };
23232
23233 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) goto fail;
23234 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23235 if (SWIG_arg_fail(1)) SWIG_fail;
23236 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23237 if (SWIG_arg_fail(2)) SWIG_fail;
23238 {
23239 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_EXCEPTION | 0);
23240 if (SWIG_arg_fail(3)) SWIG_fail;
23241 if (arg3 == NULL) {
23242 SWIG_null_ref("wxIdleEvent");
23243 }
23244 if (SWIG_arg_fail(3)) SWIG_fail;
23245 }
23246 {
23247 PyThreadState* __tstate = wxPyBeginAllowThreads();
23248 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
23249
23250 wxPyEndAllowThreads(__tstate);
23251 if (PyErr_Occurred()) SWIG_fail;
23252 }
23253 {
23254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23255 }
23256 return resultobj;
23257 fail:
23258 return NULL;
23259 }
23260
23261
23262 static PyObject *_wrap_PyApp_IsActive(PyObject *, PyObject *args, PyObject *kwargs) {
23263 PyObject *resultobj;
23264 wxPyApp *arg1 = (wxPyApp *) 0 ;
23265 bool result;
23266 PyObject * obj0 = 0 ;
23267 char *kwnames[] = {
23268 (char *) "self", NULL
23269 };
23270
23271 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_IsActive",kwnames,&obj0)) goto fail;
23272 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23273 if (SWIG_arg_fail(1)) SWIG_fail;
23274 {
23275 PyThreadState* __tstate = wxPyBeginAllowThreads();
23276 result = (bool)((wxPyApp const *)arg1)->IsActive();
23277
23278 wxPyEndAllowThreads(__tstate);
23279 if (PyErr_Occurred()) SWIG_fail;
23280 }
23281 {
23282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23283 }
23284 return resultobj;
23285 fail:
23286 return NULL;
23287 }
23288
23289
23290 static PyObject *_wrap_PyApp_SetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23291 PyObject *resultobj;
23292 wxPyApp *arg1 = (wxPyApp *) 0 ;
23293 wxWindow *arg2 = (wxWindow *) 0 ;
23294 PyObject * obj0 = 0 ;
23295 PyObject * obj1 = 0 ;
23296 char *kwnames[] = {
23297 (char *) "self",(char *) "win", NULL
23298 };
23299
23300 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) goto fail;
23301 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23302 if (SWIG_arg_fail(1)) SWIG_fail;
23303 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23304 if (SWIG_arg_fail(2)) SWIG_fail;
23305 {
23306 PyThreadState* __tstate = wxPyBeginAllowThreads();
23307 (arg1)->SetTopWindow(arg2);
23308
23309 wxPyEndAllowThreads(__tstate);
23310 if (PyErr_Occurred()) SWIG_fail;
23311 }
23312 Py_INCREF(Py_None); resultobj = Py_None;
23313 return resultobj;
23314 fail:
23315 return NULL;
23316 }
23317
23318
23319 static PyObject *_wrap_PyApp_GetTopWindow(PyObject *, PyObject *args, PyObject *kwargs) {
23320 PyObject *resultobj;
23321 wxPyApp *arg1 = (wxPyApp *) 0 ;
23322 wxWindow *result;
23323 PyObject * obj0 = 0 ;
23324 char *kwnames[] = {
23325 (char *) "self", NULL
23326 };
23327
23328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetTopWindow",kwnames,&obj0)) goto fail;
23329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23330 if (SWIG_arg_fail(1)) SWIG_fail;
23331 {
23332 PyThreadState* __tstate = wxPyBeginAllowThreads();
23333 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
23334
23335 wxPyEndAllowThreads(__tstate);
23336 if (PyErr_Occurred()) SWIG_fail;
23337 }
23338 {
23339 resultobj = wxPyMake_wxObject(result, 0);
23340 }
23341 return resultobj;
23342 fail:
23343 return NULL;
23344 }
23345
23346
23347 static PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23348 PyObject *resultobj;
23349 wxPyApp *arg1 = (wxPyApp *) 0 ;
23350 bool arg2 ;
23351 PyObject * obj0 = 0 ;
23352 PyObject * obj1 = 0 ;
23353 char *kwnames[] = {
23354 (char *) "self",(char *) "flag", NULL
23355 };
23356
23357 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) goto fail;
23358 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23359 if (SWIG_arg_fail(1)) SWIG_fail;
23360 {
23361 arg2 = (bool)(SWIG_As_bool(obj1));
23362 if (SWIG_arg_fail(2)) SWIG_fail;
23363 }
23364 {
23365 PyThreadState* __tstate = wxPyBeginAllowThreads();
23366 (arg1)->SetExitOnFrameDelete(arg2);
23367
23368 wxPyEndAllowThreads(__tstate);
23369 if (PyErr_Occurred()) SWIG_fail;
23370 }
23371 Py_INCREF(Py_None); resultobj = Py_None;
23372 return resultobj;
23373 fail:
23374 return NULL;
23375 }
23376
23377
23378 static PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *, PyObject *args, PyObject *kwargs) {
23379 PyObject *resultobj;
23380 wxPyApp *arg1 = (wxPyApp *) 0 ;
23381 bool result;
23382 PyObject * obj0 = 0 ;
23383 char *kwnames[] = {
23384 (char *) "self", NULL
23385 };
23386
23387 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetExitOnFrameDelete",kwnames,&obj0)) goto fail;
23388 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23389 if (SWIG_arg_fail(1)) SWIG_fail;
23390 {
23391 PyThreadState* __tstate = wxPyBeginAllowThreads();
23392 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
23393
23394 wxPyEndAllowThreads(__tstate);
23395 if (PyErr_Occurred()) SWIG_fail;
23396 }
23397 {
23398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23399 }
23400 return resultobj;
23401 fail:
23402 return NULL;
23403 }
23404
23405
23406 static PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23407 PyObject *resultobj;
23408 wxPyApp *arg1 = (wxPyApp *) 0 ;
23409 bool arg2 ;
23410 PyObject * obj0 = 0 ;
23411 PyObject * obj1 = 0 ;
23412 char *kwnames[] = {
23413 (char *) "self",(char *) "flag", NULL
23414 };
23415
23416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) goto fail;
23417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23418 if (SWIG_arg_fail(1)) SWIG_fail;
23419 {
23420 arg2 = (bool)(SWIG_As_bool(obj1));
23421 if (SWIG_arg_fail(2)) SWIG_fail;
23422 }
23423 {
23424 PyThreadState* __tstate = wxPyBeginAllowThreads();
23425 (arg1)->SetUseBestVisual(arg2);
23426
23427 wxPyEndAllowThreads(__tstate);
23428 if (PyErr_Occurred()) SWIG_fail;
23429 }
23430 Py_INCREF(Py_None); resultobj = Py_None;
23431 return resultobj;
23432 fail:
23433 return NULL;
23434 }
23435
23436
23437 static PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *, PyObject *args, PyObject *kwargs) {
23438 PyObject *resultobj;
23439 wxPyApp *arg1 = (wxPyApp *) 0 ;
23440 bool result;
23441 PyObject * obj0 = 0 ;
23442 char *kwnames[] = {
23443 (char *) "self", NULL
23444 };
23445
23446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetUseBestVisual",kwnames,&obj0)) goto fail;
23447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23448 if (SWIG_arg_fail(1)) SWIG_fail;
23449 {
23450 PyThreadState* __tstate = wxPyBeginAllowThreads();
23451 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
23452
23453 wxPyEndAllowThreads(__tstate);
23454 if (PyErr_Occurred()) SWIG_fail;
23455 }
23456 {
23457 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23458 }
23459 return resultobj;
23460 fail:
23461 return NULL;
23462 }
23463
23464
23465 static PyObject *_wrap_PyApp_SetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23466 PyObject *resultobj;
23467 wxPyApp *arg1 = (wxPyApp *) 0 ;
23468 int arg2 ;
23469 PyObject * obj0 = 0 ;
23470 PyObject * obj1 = 0 ;
23471 char *kwnames[] = {
23472 (char *) "self",(char *) "mode", NULL
23473 };
23474
23475 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) goto fail;
23476 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23477 if (SWIG_arg_fail(1)) SWIG_fail;
23478 {
23479 arg2 = (int)(SWIG_As_int(obj1));
23480 if (SWIG_arg_fail(2)) SWIG_fail;
23481 }
23482 {
23483 PyThreadState* __tstate = wxPyBeginAllowThreads();
23484 (arg1)->SetPrintMode(arg2);
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_GetPrintMode(PyObject *, PyObject *args, PyObject *kwargs) {
23497 PyObject *resultobj;
23498 wxPyApp *arg1 = (wxPyApp *) 0 ;
23499 int result;
23500 PyObject * obj0 = 0 ;
23501 char *kwnames[] = {
23502 (char *) "self", NULL
23503 };
23504
23505 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetPrintMode",kwnames,&obj0)) goto fail;
23506 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23507 if (SWIG_arg_fail(1)) SWIG_fail;
23508 {
23509 PyThreadState* __tstate = wxPyBeginAllowThreads();
23510 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
23511
23512 wxPyEndAllowThreads(__tstate);
23513 if (PyErr_Occurred()) SWIG_fail;
23514 }
23515 {
23516 resultobj = SWIG_From_int((int)(result));
23517 }
23518 return resultobj;
23519 fail:
23520 return NULL;
23521 }
23522
23523
23524 static PyObject *_wrap_PyApp_SetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23525 PyObject *resultobj;
23526 wxPyApp *arg1 = (wxPyApp *) 0 ;
23527 int arg2 ;
23528 PyObject * obj0 = 0 ;
23529 PyObject * obj1 = 0 ;
23530 char *kwnames[] = {
23531 (char *) "self",(char *) "mode", NULL
23532 };
23533
23534 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) goto fail;
23535 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23536 if (SWIG_arg_fail(1)) SWIG_fail;
23537 {
23538 arg2 = (int)(SWIG_As_int(obj1));
23539 if (SWIG_arg_fail(2)) SWIG_fail;
23540 }
23541 {
23542 PyThreadState* __tstate = wxPyBeginAllowThreads();
23543 (arg1)->SetAssertMode(arg2);
23544
23545 wxPyEndAllowThreads(__tstate);
23546 if (PyErr_Occurred()) SWIG_fail;
23547 }
23548 Py_INCREF(Py_None); resultobj = Py_None;
23549 return resultobj;
23550 fail:
23551 return NULL;
23552 }
23553
23554
23555 static PyObject *_wrap_PyApp_GetAssertMode(PyObject *, PyObject *args, PyObject *kwargs) {
23556 PyObject *resultobj;
23557 wxPyApp *arg1 = (wxPyApp *) 0 ;
23558 int result;
23559 PyObject * obj0 = 0 ;
23560 char *kwnames[] = {
23561 (char *) "self", NULL
23562 };
23563
23564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_GetAssertMode",kwnames,&obj0)) goto fail;
23565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23566 if (SWIG_arg_fail(1)) SWIG_fail;
23567 {
23568 PyThreadState* __tstate = wxPyBeginAllowThreads();
23569 result = (int)(arg1)->GetAssertMode();
23570
23571 wxPyEndAllowThreads(__tstate);
23572 if (PyErr_Occurred()) SWIG_fail;
23573 }
23574 {
23575 resultobj = SWIG_From_int((int)(result));
23576 }
23577 return resultobj;
23578 fail:
23579 return NULL;
23580 }
23581
23582
23583 static PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23584 PyObject *resultobj;
23585 bool result;
23586 char *kwnames[] = {
23587 NULL
23588 };
23589
23590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacSupportPCMenuShortcuts",kwnames)) goto fail;
23591 {
23592 PyThreadState* __tstate = wxPyBeginAllowThreads();
23593 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
23594
23595 wxPyEndAllowThreads(__tstate);
23596 if (PyErr_Occurred()) SWIG_fail;
23597 }
23598 {
23599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23600 }
23601 return resultobj;
23602 fail:
23603 return NULL;
23604 }
23605
23606
23607 static PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23608 PyObject *resultobj;
23609 long result;
23610 char *kwnames[] = {
23611 NULL
23612 };
23613
23614 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacAboutMenuItemId",kwnames)) goto fail;
23615 {
23616 PyThreadState* __tstate = wxPyBeginAllowThreads();
23617 result = (long)wxPyApp::GetMacAboutMenuItemId();
23618
23619 wxPyEndAllowThreads(__tstate);
23620 if (PyErr_Occurred()) SWIG_fail;
23621 }
23622 {
23623 resultobj = SWIG_From_long((long)(result));
23624 }
23625 return resultobj;
23626 fail:
23627 return NULL;
23628 }
23629
23630
23631 static PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23632 PyObject *resultobj;
23633 long result;
23634 char *kwnames[] = {
23635 NULL
23636 };
23637
23638 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacPreferencesMenuItemId",kwnames)) goto fail;
23639 {
23640 PyThreadState* __tstate = wxPyBeginAllowThreads();
23641 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
23642
23643 wxPyEndAllowThreads(__tstate);
23644 if (PyErr_Occurred()) SWIG_fail;
23645 }
23646 {
23647 resultobj = SWIG_From_long((long)(result));
23648 }
23649 return resultobj;
23650 fail:
23651 return NULL;
23652 }
23653
23654
23655 static PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23656 PyObject *resultobj;
23657 long result;
23658 char *kwnames[] = {
23659 NULL
23660 };
23661
23662 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacExitMenuItemId",kwnames)) goto fail;
23663 {
23664 PyThreadState* __tstate = wxPyBeginAllowThreads();
23665 result = (long)wxPyApp::GetMacExitMenuItemId();
23666
23667 wxPyEndAllowThreads(__tstate);
23668 if (PyErr_Occurred()) SWIG_fail;
23669 }
23670 {
23671 resultobj = SWIG_From_long((long)(result));
23672 }
23673 return resultobj;
23674 fail:
23675 return NULL;
23676 }
23677
23678
23679 static PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23680 PyObject *resultobj;
23681 wxString result;
23682 char *kwnames[] = {
23683 NULL
23684 };
23685
23686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetMacHelpMenuTitleName",kwnames)) goto fail;
23687 {
23688 PyThreadState* __tstate = wxPyBeginAllowThreads();
23689 result = wxPyApp::GetMacHelpMenuTitleName();
23690
23691 wxPyEndAllowThreads(__tstate);
23692 if (PyErr_Occurred()) SWIG_fail;
23693 }
23694 {
23695 #if wxUSE_UNICODE
23696 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
23697 #else
23698 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
23699 #endif
23700 }
23701 return resultobj;
23702 fail:
23703 return NULL;
23704 }
23705
23706
23707 static PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *, PyObject *args, PyObject *kwargs) {
23708 PyObject *resultobj;
23709 bool arg1 ;
23710 PyObject * obj0 = 0 ;
23711 char *kwnames[] = {
23712 (char *) "val", NULL
23713 };
23714
23715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) goto fail;
23716 {
23717 arg1 = (bool)(SWIG_As_bool(obj0));
23718 if (SWIG_arg_fail(1)) SWIG_fail;
23719 }
23720 {
23721 PyThreadState* __tstate = wxPyBeginAllowThreads();
23722 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
23723
23724 wxPyEndAllowThreads(__tstate);
23725 if (PyErr_Occurred()) SWIG_fail;
23726 }
23727 Py_INCREF(Py_None); resultobj = Py_None;
23728 return resultobj;
23729 fail:
23730 return NULL;
23731 }
23732
23733
23734 static PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23735 PyObject *resultobj;
23736 long arg1 ;
23737 PyObject * obj0 = 0 ;
23738 char *kwnames[] = {
23739 (char *) "val", NULL
23740 };
23741
23742 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) goto fail;
23743 {
23744 arg1 = (long)(SWIG_As_long(obj0));
23745 if (SWIG_arg_fail(1)) SWIG_fail;
23746 }
23747 {
23748 PyThreadState* __tstate = wxPyBeginAllowThreads();
23749 wxPyApp::SetMacAboutMenuItemId(arg1);
23750
23751 wxPyEndAllowThreads(__tstate);
23752 if (PyErr_Occurred()) SWIG_fail;
23753 }
23754 Py_INCREF(Py_None); resultobj = Py_None;
23755 return resultobj;
23756 fail:
23757 return NULL;
23758 }
23759
23760
23761 static PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23762 PyObject *resultobj;
23763 long arg1 ;
23764 PyObject * obj0 = 0 ;
23765 char *kwnames[] = {
23766 (char *) "val", NULL
23767 };
23768
23769 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) goto fail;
23770 {
23771 arg1 = (long)(SWIG_As_long(obj0));
23772 if (SWIG_arg_fail(1)) SWIG_fail;
23773 }
23774 {
23775 PyThreadState* __tstate = wxPyBeginAllowThreads();
23776 wxPyApp::SetMacPreferencesMenuItemId(arg1);
23777
23778 wxPyEndAllowThreads(__tstate);
23779 if (PyErr_Occurred()) SWIG_fail;
23780 }
23781 Py_INCREF(Py_None); resultobj = Py_None;
23782 return resultobj;
23783 fail:
23784 return NULL;
23785 }
23786
23787
23788 static PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *, PyObject *args, PyObject *kwargs) {
23789 PyObject *resultobj;
23790 long arg1 ;
23791 PyObject * obj0 = 0 ;
23792 char *kwnames[] = {
23793 (char *) "val", NULL
23794 };
23795
23796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) goto fail;
23797 {
23798 arg1 = (long)(SWIG_As_long(obj0));
23799 if (SWIG_arg_fail(1)) SWIG_fail;
23800 }
23801 {
23802 PyThreadState* __tstate = wxPyBeginAllowThreads();
23803 wxPyApp::SetMacExitMenuItemId(arg1);
23804
23805 wxPyEndAllowThreads(__tstate);
23806 if (PyErr_Occurred()) SWIG_fail;
23807 }
23808 Py_INCREF(Py_None); resultobj = Py_None;
23809 return resultobj;
23810 fail:
23811 return NULL;
23812 }
23813
23814
23815 static PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *, PyObject *args, PyObject *kwargs) {
23816 PyObject *resultobj;
23817 wxString *arg1 = 0 ;
23818 bool temp1 = false ;
23819 PyObject * obj0 = 0 ;
23820 char *kwnames[] = {
23821 (char *) "val", NULL
23822 };
23823
23824 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) goto fail;
23825 {
23826 arg1 = wxString_in_helper(obj0);
23827 if (arg1 == NULL) SWIG_fail;
23828 temp1 = true;
23829 }
23830 {
23831 PyThreadState* __tstate = wxPyBeginAllowThreads();
23832 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
23833
23834 wxPyEndAllowThreads(__tstate);
23835 if (PyErr_Occurred()) SWIG_fail;
23836 }
23837 Py_INCREF(Py_None); resultobj = Py_None;
23838 {
23839 if (temp1)
23840 delete arg1;
23841 }
23842 return resultobj;
23843 fail:
23844 {
23845 if (temp1)
23846 delete arg1;
23847 }
23848 return NULL;
23849 }
23850
23851
23852 static PyObject *_wrap_PyApp__BootstrapApp(PyObject *, PyObject *args, PyObject *kwargs) {
23853 PyObject *resultobj;
23854 wxPyApp *arg1 = (wxPyApp *) 0 ;
23855 PyObject * obj0 = 0 ;
23856 char *kwnames[] = {
23857 (char *) "self", NULL
23858 };
23859
23860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp__BootstrapApp",kwnames,&obj0)) goto fail;
23861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyApp, SWIG_POINTER_EXCEPTION | 0);
23862 if (SWIG_arg_fail(1)) SWIG_fail;
23863 {
23864 PyThreadState* __tstate = wxPyBeginAllowThreads();
23865 (arg1)->_BootstrapApp();
23866
23867 wxPyEndAllowThreads(__tstate);
23868 if (PyErr_Occurred()) SWIG_fail;
23869 }
23870 Py_INCREF(Py_None); resultobj = Py_None;
23871 return resultobj;
23872 fail:
23873 return NULL;
23874 }
23875
23876
23877 static PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *, PyObject *args, PyObject *kwargs) {
23878 PyObject *resultobj;
23879 int result;
23880 char *kwnames[] = {
23881 NULL
23882 };
23883
23884 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":PyApp_GetComCtl32Version",kwnames)) goto fail;
23885 {
23886 PyThreadState* __tstate = wxPyBeginAllowThreads();
23887 result = (int)PyApp_GetComCtl32Version();
23888
23889 wxPyEndAllowThreads(__tstate);
23890 if (PyErr_Occurred()) SWIG_fail;
23891 }
23892 {
23893 resultobj = SWIG_From_int((int)(result));
23894 }
23895 return resultobj;
23896 fail:
23897 return NULL;
23898 }
23899
23900
23901 static PyObject * PyApp_swigregister(PyObject *, PyObject *args) {
23902 PyObject *obj;
23903 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
23904 SWIG_TypeClientData(SWIGTYPE_p_wxPyApp, obj);
23905 Py_INCREF(obj);
23906 return Py_BuildValue((char *)"");
23907 }
23908 static PyObject *_wrap_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
23909 PyObject *resultobj;
23910 char *kwnames[] = {
23911 NULL
23912 };
23913
23914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Exit",kwnames)) goto fail;
23915 {
23916 PyThreadState* __tstate = wxPyBeginAllowThreads();
23917 wxExit();
23918
23919 wxPyEndAllowThreads(__tstate);
23920 if (PyErr_Occurred()) SWIG_fail;
23921 }
23922 Py_INCREF(Py_None); resultobj = Py_None;
23923 return resultobj;
23924 fail:
23925 return NULL;
23926 }
23927
23928
23929 static PyObject *_wrap_Yield(PyObject *, PyObject *args, PyObject *kwargs) {
23930 PyObject *resultobj;
23931 bool result;
23932 char *kwnames[] = {
23933 NULL
23934 };
23935
23936 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Yield",kwnames)) goto fail;
23937 {
23938 PyThreadState* __tstate = wxPyBeginAllowThreads();
23939 result = (bool)wxYield();
23940
23941 wxPyEndAllowThreads(__tstate);
23942 if (PyErr_Occurred()) SWIG_fail;
23943 }
23944 {
23945 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23946 }
23947 return resultobj;
23948 fail:
23949 return NULL;
23950 }
23951
23952
23953 static PyObject *_wrap_YieldIfNeeded(PyObject *, PyObject *args, PyObject *kwargs) {
23954 PyObject *resultobj;
23955 bool result;
23956 char *kwnames[] = {
23957 NULL
23958 };
23959
23960 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":YieldIfNeeded",kwnames)) goto fail;
23961 {
23962 PyThreadState* __tstate = wxPyBeginAllowThreads();
23963 result = (bool)wxYieldIfNeeded();
23964
23965 wxPyEndAllowThreads(__tstate);
23966 if (PyErr_Occurred()) SWIG_fail;
23967 }
23968 {
23969 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23970 }
23971 return resultobj;
23972 fail:
23973 return NULL;
23974 }
23975
23976
23977 static PyObject *_wrap_SafeYield(PyObject *, PyObject *args, PyObject *kwargs) {
23978 PyObject *resultobj;
23979 wxWindow *arg1 = (wxWindow *) NULL ;
23980 bool arg2 = (bool) false ;
23981 bool result;
23982 PyObject * obj0 = 0 ;
23983 PyObject * obj1 = 0 ;
23984 char *kwnames[] = {
23985 (char *) "win",(char *) "onlyIfNeeded", NULL
23986 };
23987
23988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) goto fail;
23989 if (obj0) {
23990 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
23991 if (SWIG_arg_fail(1)) SWIG_fail;
23992 }
23993 if (obj1) {
23994 {
23995 arg2 = (bool)(SWIG_As_bool(obj1));
23996 if (SWIG_arg_fail(2)) SWIG_fail;
23997 }
23998 }
23999 {
24000 PyThreadState* __tstate = wxPyBeginAllowThreads();
24001 result = (bool)wxSafeYield(arg1,arg2);
24002
24003 wxPyEndAllowThreads(__tstate);
24004 if (PyErr_Occurred()) SWIG_fail;
24005 }
24006 {
24007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24008 }
24009 return resultobj;
24010 fail:
24011 return NULL;
24012 }
24013
24014
24015 static PyObject *_wrap_WakeUpIdle(PyObject *, PyObject *args, PyObject *kwargs) {
24016 PyObject *resultobj;
24017 char *kwnames[] = {
24018 NULL
24019 };
24020
24021 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":WakeUpIdle",kwnames)) goto fail;
24022 {
24023 PyThreadState* __tstate = wxPyBeginAllowThreads();
24024 wxWakeUpIdle();
24025
24026 wxPyEndAllowThreads(__tstate);
24027 if (PyErr_Occurred()) SWIG_fail;
24028 }
24029 Py_INCREF(Py_None); resultobj = Py_None;
24030 return resultobj;
24031 fail:
24032 return NULL;
24033 }
24034
24035
24036 static PyObject *_wrap_PostEvent(PyObject *, PyObject *args, PyObject *kwargs) {
24037 PyObject *resultobj;
24038 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
24039 wxEvent *arg2 = 0 ;
24040 PyObject * obj0 = 0 ;
24041 PyObject * obj1 = 0 ;
24042 char *kwnames[] = {
24043 (char *) "dest",(char *) "event", NULL
24044 };
24045
24046 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) goto fail;
24047 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
24048 if (SWIG_arg_fail(1)) SWIG_fail;
24049 {
24050 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvent, SWIG_POINTER_EXCEPTION | 0);
24051 if (SWIG_arg_fail(2)) SWIG_fail;
24052 if (arg2 == NULL) {
24053 SWIG_null_ref("wxEvent");
24054 }
24055 if (SWIG_arg_fail(2)) SWIG_fail;
24056 }
24057 {
24058 PyThreadState* __tstate = wxPyBeginAllowThreads();
24059 wxPostEvent(arg1,*arg2);
24060
24061 wxPyEndAllowThreads(__tstate);
24062 if (PyErr_Occurred()) SWIG_fail;
24063 }
24064 Py_INCREF(Py_None); resultobj = Py_None;
24065 return resultobj;
24066 fail:
24067 return NULL;
24068 }
24069
24070
24071 static PyObject *_wrap_App_CleanUp(PyObject *, PyObject *args, PyObject *kwargs) {
24072 PyObject *resultobj;
24073 char *kwnames[] = {
24074 NULL
24075 };
24076
24077 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":App_CleanUp",kwnames)) goto fail;
24078 {
24079 PyThreadState* __tstate = wxPyBeginAllowThreads();
24080 wxApp_CleanUp();
24081
24082 wxPyEndAllowThreads(__tstate);
24083 if (PyErr_Occurred()) SWIG_fail;
24084 }
24085 Py_INCREF(Py_None); resultobj = Py_None;
24086 return resultobj;
24087 fail:
24088 return NULL;
24089 }
24090
24091
24092 static PyObject *_wrap_GetApp(PyObject *, PyObject *args, PyObject *kwargs) {
24093 PyObject *resultobj;
24094 wxPyApp *result;
24095 char *kwnames[] = {
24096 NULL
24097 };
24098
24099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetApp",kwnames)) goto fail;
24100 {
24101 PyThreadState* __tstate = wxPyBeginAllowThreads();
24102 result = (wxPyApp *)wxPyGetApp();
24103
24104 wxPyEndAllowThreads(__tstate);
24105 if (PyErr_Occurred()) SWIG_fail;
24106 }
24107 {
24108 resultobj = wxPyMake_wxObject(result, 0);
24109 }
24110 return resultobj;
24111 fail:
24112 return NULL;
24113 }
24114
24115
24116 static PyObject *_wrap_SetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24117 PyObject *resultobj;
24118 char *arg1 = (char *) 0 ;
24119 PyObject * obj0 = 0 ;
24120 char *kwnames[] = {
24121 (char *) "encoding", NULL
24122 };
24123
24124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) goto fail;
24125 if (!SWIG_AsCharPtr(obj0, (char**)&arg1)) {
24126 SWIG_arg_fail(1);SWIG_fail;
24127 }
24128 {
24129 PyThreadState* __tstate = wxPyBeginAllowThreads();
24130 wxSetDefaultPyEncoding((char const *)arg1);
24131
24132 wxPyEndAllowThreads(__tstate);
24133 if (PyErr_Occurred()) SWIG_fail;
24134 }
24135 Py_INCREF(Py_None); resultobj = Py_None;
24136 return resultobj;
24137 fail:
24138 return NULL;
24139 }
24140
24141
24142 static PyObject *_wrap_GetDefaultPyEncoding(PyObject *, PyObject *args, PyObject *kwargs) {
24143 PyObject *resultobj;
24144 char *result;
24145 char *kwnames[] = {
24146 NULL
24147 };
24148
24149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":GetDefaultPyEncoding",kwnames)) goto fail;
24150 {
24151 PyThreadState* __tstate = wxPyBeginAllowThreads();
24152 result = (char *)wxGetDefaultPyEncoding();
24153
24154 wxPyEndAllowThreads(__tstate);
24155 if (PyErr_Occurred()) SWIG_fail;
24156 }
24157 resultobj = SWIG_FromCharPtr(result);
24158 return resultobj;
24159 fail:
24160 return NULL;
24161 }
24162
24163
24164 static PyObject *_wrap_new_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24165 PyObject *resultobj;
24166 wxEventLoop *result;
24167 char *kwnames[] = {
24168 NULL
24169 };
24170
24171 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_EventLoop",kwnames)) goto fail;
24172 {
24173 PyThreadState* __tstate = wxPyBeginAllowThreads();
24174 result = (wxEventLoop *)new wxEventLoop();
24175
24176 wxPyEndAllowThreads(__tstate);
24177 if (PyErr_Occurred()) SWIG_fail;
24178 }
24179 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 1);
24180 return resultobj;
24181 fail:
24182 return NULL;
24183 }
24184
24185
24186 static PyObject *_wrap_delete_EventLoop(PyObject *, PyObject *args, PyObject *kwargs) {
24187 PyObject *resultobj;
24188 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24189 PyObject * obj0 = 0 ;
24190 char *kwnames[] = {
24191 (char *) "self", NULL
24192 };
24193
24194 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_EventLoop",kwnames,&obj0)) goto fail;
24195 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24196 if (SWIG_arg_fail(1)) SWIG_fail;
24197 {
24198 PyThreadState* __tstate = wxPyBeginAllowThreads();
24199 delete arg1;
24200
24201 wxPyEndAllowThreads(__tstate);
24202 if (PyErr_Occurred()) SWIG_fail;
24203 }
24204 Py_INCREF(Py_None); resultobj = Py_None;
24205 return resultobj;
24206 fail:
24207 return NULL;
24208 }
24209
24210
24211 static PyObject *_wrap_EventLoop_Run(PyObject *, PyObject *args, PyObject *kwargs) {
24212 PyObject *resultobj;
24213 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24214 int result;
24215 PyObject * obj0 = 0 ;
24216 char *kwnames[] = {
24217 (char *) "self", NULL
24218 };
24219
24220 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Run",kwnames,&obj0)) goto fail;
24221 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24222 if (SWIG_arg_fail(1)) SWIG_fail;
24223 {
24224 PyThreadState* __tstate = wxPyBeginAllowThreads();
24225 result = (int)(arg1)->Run();
24226
24227 wxPyEndAllowThreads(__tstate);
24228 if (PyErr_Occurred()) SWIG_fail;
24229 }
24230 {
24231 resultobj = SWIG_From_int((int)(result));
24232 }
24233 return resultobj;
24234 fail:
24235 return NULL;
24236 }
24237
24238
24239 static PyObject *_wrap_EventLoop_Exit(PyObject *, PyObject *args, PyObject *kwargs) {
24240 PyObject *resultobj;
24241 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24242 int arg2 = (int) 0 ;
24243 PyObject * obj0 = 0 ;
24244 PyObject * obj1 = 0 ;
24245 char *kwnames[] = {
24246 (char *) "self",(char *) "rc", NULL
24247 };
24248
24249 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) goto fail;
24250 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24251 if (SWIG_arg_fail(1)) SWIG_fail;
24252 if (obj1) {
24253 {
24254 arg2 = (int)(SWIG_As_int(obj1));
24255 if (SWIG_arg_fail(2)) SWIG_fail;
24256 }
24257 }
24258 {
24259 PyThreadState* __tstate = wxPyBeginAllowThreads();
24260 (arg1)->Exit(arg2);
24261
24262 wxPyEndAllowThreads(__tstate);
24263 if (PyErr_Occurred()) SWIG_fail;
24264 }
24265 Py_INCREF(Py_None); resultobj = Py_None;
24266 return resultobj;
24267 fail:
24268 return NULL;
24269 }
24270
24271
24272 static PyObject *_wrap_EventLoop_Pending(PyObject *, PyObject *args, PyObject *kwargs) {
24273 PyObject *resultobj;
24274 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24275 bool result;
24276 PyObject * obj0 = 0 ;
24277 char *kwnames[] = {
24278 (char *) "self", NULL
24279 };
24280
24281 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Pending",kwnames,&obj0)) goto fail;
24282 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24283 if (SWIG_arg_fail(1)) SWIG_fail;
24284 {
24285 PyThreadState* __tstate = wxPyBeginAllowThreads();
24286 result = (bool)((wxEventLoop const *)arg1)->Pending();
24287
24288 wxPyEndAllowThreads(__tstate);
24289 if (PyErr_Occurred()) SWIG_fail;
24290 }
24291 {
24292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24293 }
24294 return resultobj;
24295 fail:
24296 return NULL;
24297 }
24298
24299
24300 static PyObject *_wrap_EventLoop_Dispatch(PyObject *, PyObject *args, PyObject *kwargs) {
24301 PyObject *resultobj;
24302 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24303 bool result;
24304 PyObject * obj0 = 0 ;
24305 char *kwnames[] = {
24306 (char *) "self", NULL
24307 };
24308
24309 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_Dispatch",kwnames,&obj0)) goto fail;
24310 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24311 if (SWIG_arg_fail(1)) SWIG_fail;
24312 {
24313 PyThreadState* __tstate = wxPyBeginAllowThreads();
24314 result = (bool)(arg1)->Dispatch();
24315
24316 wxPyEndAllowThreads(__tstate);
24317 if (PyErr_Occurred()) SWIG_fail;
24318 }
24319 {
24320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24321 }
24322 return resultobj;
24323 fail:
24324 return NULL;
24325 }
24326
24327
24328 static PyObject *_wrap_EventLoop_IsRunning(PyObject *, PyObject *args, PyObject *kwargs) {
24329 PyObject *resultobj;
24330 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24331 bool result;
24332 PyObject * obj0 = 0 ;
24333 char *kwnames[] = {
24334 (char *) "self", NULL
24335 };
24336
24337 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_IsRunning",kwnames,&obj0)) goto fail;
24338 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24339 if (SWIG_arg_fail(1)) SWIG_fail;
24340 {
24341 PyThreadState* __tstate = wxPyBeginAllowThreads();
24342 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
24343
24344 wxPyEndAllowThreads(__tstate);
24345 if (PyErr_Occurred()) SWIG_fail;
24346 }
24347 {
24348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24349 }
24350 return resultobj;
24351 fail:
24352 return NULL;
24353 }
24354
24355
24356 static PyObject *_wrap_EventLoop_GetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24357 PyObject *resultobj;
24358 wxEventLoop *result;
24359 char *kwnames[] = {
24360 NULL
24361 };
24362
24363 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":EventLoop_GetActive",kwnames)) goto fail;
24364 {
24365 PyThreadState* __tstate = wxPyBeginAllowThreads();
24366 result = (wxEventLoop *)wxEventLoop::GetActive();
24367
24368 wxPyEndAllowThreads(__tstate);
24369 if (PyErr_Occurred()) SWIG_fail;
24370 }
24371 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxEventLoop, 0);
24372 return resultobj;
24373 fail:
24374 return NULL;
24375 }
24376
24377
24378 static PyObject *_wrap_EventLoop_SetActive(PyObject *, PyObject *args, PyObject *kwargs) {
24379 PyObject *resultobj;
24380 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
24381 PyObject * obj0 = 0 ;
24382 char *kwnames[] = {
24383 (char *) "loop", NULL
24384 };
24385
24386 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) goto fail;
24387 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxEventLoop, SWIG_POINTER_EXCEPTION | 0);
24388 if (SWIG_arg_fail(1)) SWIG_fail;
24389 {
24390 PyThreadState* __tstate = wxPyBeginAllowThreads();
24391 wxEventLoop::SetActive(arg1);
24392
24393 wxPyEndAllowThreads(__tstate);
24394 if (PyErr_Occurred()) SWIG_fail;
24395 }
24396 Py_INCREF(Py_None); resultobj = Py_None;
24397 return resultobj;
24398 fail:
24399 return NULL;
24400 }
24401
24402
24403 static PyObject * EventLoop_swigregister(PyObject *, PyObject *args) {
24404 PyObject *obj;
24405 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24406 SWIG_TypeClientData(SWIGTYPE_p_wxEventLoop, obj);
24407 Py_INCREF(obj);
24408 return Py_BuildValue((char *)"");
24409 }
24410 static PyObject *_wrap_new_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24411 PyObject *resultobj;
24412 int arg1 = (int) 0 ;
24413 int arg2 = (int) 0 ;
24414 int arg3 = (int) 0 ;
24415 wxAcceleratorEntry *result;
24416 PyObject * obj0 = 0 ;
24417 PyObject * obj1 = 0 ;
24418 PyObject * obj2 = 0 ;
24419 char *kwnames[] = {
24420 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
24421 };
24422
24423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) goto fail;
24424 if (obj0) {
24425 {
24426 arg1 = (int)(SWIG_As_int(obj0));
24427 if (SWIG_arg_fail(1)) SWIG_fail;
24428 }
24429 }
24430 if (obj1) {
24431 {
24432 arg2 = (int)(SWIG_As_int(obj1));
24433 if (SWIG_arg_fail(2)) SWIG_fail;
24434 }
24435 }
24436 if (obj2) {
24437 {
24438 arg3 = (int)(SWIG_As_int(obj2));
24439 if (SWIG_arg_fail(3)) SWIG_fail;
24440 }
24441 }
24442 {
24443 PyThreadState* __tstate = wxPyBeginAllowThreads();
24444 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
24445
24446 wxPyEndAllowThreads(__tstate);
24447 if (PyErr_Occurred()) SWIG_fail;
24448 }
24449 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 1);
24450 return resultobj;
24451 fail:
24452 return NULL;
24453 }
24454
24455
24456 static PyObject *_wrap_delete_AcceleratorEntry(PyObject *, PyObject *args, PyObject *kwargs) {
24457 PyObject *resultobj;
24458 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24459 PyObject * obj0 = 0 ;
24460 char *kwnames[] = {
24461 (char *) "self", NULL
24462 };
24463
24464 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorEntry",kwnames,&obj0)) goto fail;
24465 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24466 if (SWIG_arg_fail(1)) SWIG_fail;
24467 {
24468 PyThreadState* __tstate = wxPyBeginAllowThreads();
24469 delete arg1;
24470
24471 wxPyEndAllowThreads(__tstate);
24472 if (PyErr_Occurred()) SWIG_fail;
24473 }
24474 Py_INCREF(Py_None); resultobj = Py_None;
24475 return resultobj;
24476 fail:
24477 return NULL;
24478 }
24479
24480
24481 static PyObject *_wrap_AcceleratorEntry_Set(PyObject *, PyObject *args, PyObject *kwargs) {
24482 PyObject *resultobj;
24483 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24484 int arg2 ;
24485 int arg3 ;
24486 int arg4 ;
24487 PyObject * obj0 = 0 ;
24488 PyObject * obj1 = 0 ;
24489 PyObject * obj2 = 0 ;
24490 PyObject * obj3 = 0 ;
24491 char *kwnames[] = {
24492 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
24493 };
24494
24495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
24496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24497 if (SWIG_arg_fail(1)) SWIG_fail;
24498 {
24499 arg2 = (int)(SWIG_As_int(obj1));
24500 if (SWIG_arg_fail(2)) SWIG_fail;
24501 }
24502 {
24503 arg3 = (int)(SWIG_As_int(obj2));
24504 if (SWIG_arg_fail(3)) SWIG_fail;
24505 }
24506 {
24507 arg4 = (int)(SWIG_As_int(obj3));
24508 if (SWIG_arg_fail(4)) SWIG_fail;
24509 }
24510 {
24511 PyThreadState* __tstate = wxPyBeginAllowThreads();
24512 (arg1)->Set(arg2,arg3,arg4);
24513
24514 wxPyEndAllowThreads(__tstate);
24515 if (PyErr_Occurred()) SWIG_fail;
24516 }
24517 Py_INCREF(Py_None); resultobj = Py_None;
24518 return resultobj;
24519 fail:
24520 return NULL;
24521 }
24522
24523
24524 static PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *, PyObject *args, PyObject *kwargs) {
24525 PyObject *resultobj;
24526 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24527 int result;
24528 PyObject * obj0 = 0 ;
24529 char *kwnames[] = {
24530 (char *) "self", NULL
24531 };
24532
24533 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetFlags",kwnames,&obj0)) goto fail;
24534 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24535 if (SWIG_arg_fail(1)) SWIG_fail;
24536 {
24537 PyThreadState* __tstate = wxPyBeginAllowThreads();
24538 result = (int)(arg1)->GetFlags();
24539
24540 wxPyEndAllowThreads(__tstate);
24541 if (PyErr_Occurred()) SWIG_fail;
24542 }
24543 {
24544 resultobj = SWIG_From_int((int)(result));
24545 }
24546 return resultobj;
24547 fail:
24548 return NULL;
24549 }
24550
24551
24552 static PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *, PyObject *args, PyObject *kwargs) {
24553 PyObject *resultobj;
24554 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24555 int result;
24556 PyObject * obj0 = 0 ;
24557 char *kwnames[] = {
24558 (char *) "self", NULL
24559 };
24560
24561 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetKeyCode",kwnames,&obj0)) goto fail;
24562 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24563 if (SWIG_arg_fail(1)) SWIG_fail;
24564 {
24565 PyThreadState* __tstate = wxPyBeginAllowThreads();
24566 result = (int)(arg1)->GetKeyCode();
24567
24568 wxPyEndAllowThreads(__tstate);
24569 if (PyErr_Occurred()) SWIG_fail;
24570 }
24571 {
24572 resultobj = SWIG_From_int((int)(result));
24573 }
24574 return resultobj;
24575 fail:
24576 return NULL;
24577 }
24578
24579
24580 static PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *, PyObject *args, PyObject *kwargs) {
24581 PyObject *resultobj;
24582 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
24583 int result;
24584 PyObject * obj0 = 0 ;
24585 char *kwnames[] = {
24586 (char *) "self", NULL
24587 };
24588
24589 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_GetCommand",kwnames,&obj0)) goto fail;
24590 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
24591 if (SWIG_arg_fail(1)) SWIG_fail;
24592 {
24593 PyThreadState* __tstate = wxPyBeginAllowThreads();
24594 result = (int)(arg1)->GetCommand();
24595
24596 wxPyEndAllowThreads(__tstate);
24597 if (PyErr_Occurred()) SWIG_fail;
24598 }
24599 {
24600 resultobj = SWIG_From_int((int)(result));
24601 }
24602 return resultobj;
24603 fail:
24604 return NULL;
24605 }
24606
24607
24608 static PyObject * AcceleratorEntry_swigregister(PyObject *, PyObject *args) {
24609 PyObject *obj;
24610 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24611 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorEntry, obj);
24612 Py_INCREF(obj);
24613 return Py_BuildValue((char *)"");
24614 }
24615 static PyObject *_wrap_new_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24616 PyObject *resultobj;
24617 int arg1 ;
24618 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
24619 wxAcceleratorTable *result;
24620 PyObject * obj0 = 0 ;
24621 char *kwnames[] = {
24622 (char *) "n", NULL
24623 };
24624
24625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) goto fail;
24626 {
24627 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
24628 if (arg2) arg1 = PyList_Size(obj0);
24629 else arg1 = 0;
24630 }
24631 {
24632 PyThreadState* __tstate = wxPyBeginAllowThreads();
24633 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
24634
24635 wxPyEndAllowThreads(__tstate);
24636 if (PyErr_Occurred()) SWIG_fail;
24637 }
24638 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 1);
24639 {
24640 delete [] arg2;
24641 }
24642 return resultobj;
24643 fail:
24644 {
24645 delete [] arg2;
24646 }
24647 return NULL;
24648 }
24649
24650
24651 static PyObject *_wrap_delete_AcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
24652 PyObject *resultobj;
24653 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24654 PyObject * obj0 = 0 ;
24655 char *kwnames[] = {
24656 (char *) "self", NULL
24657 };
24658
24659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_AcceleratorTable",kwnames,&obj0)) goto fail;
24660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24661 if (SWIG_arg_fail(1)) SWIG_fail;
24662 {
24663 PyThreadState* __tstate = wxPyBeginAllowThreads();
24664 delete arg1;
24665
24666 wxPyEndAllowThreads(__tstate);
24667 if (PyErr_Occurred()) SWIG_fail;
24668 }
24669 Py_INCREF(Py_None); resultobj = Py_None;
24670 return resultobj;
24671 fail:
24672 return NULL;
24673 }
24674
24675
24676 static PyObject *_wrap_AcceleratorTable_Ok(PyObject *, PyObject *args, PyObject *kwargs) {
24677 PyObject *resultobj;
24678 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
24679 bool result;
24680 PyObject * obj0 = 0 ;
24681 char *kwnames[] = {
24682 (char *) "self", NULL
24683 };
24684
24685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorTable_Ok",kwnames,&obj0)) goto fail;
24686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
24687 if (SWIG_arg_fail(1)) SWIG_fail;
24688 {
24689 PyThreadState* __tstate = wxPyBeginAllowThreads();
24690 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
24691
24692 wxPyEndAllowThreads(__tstate);
24693 if (PyErr_Occurred()) SWIG_fail;
24694 }
24695 {
24696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24697 }
24698 return resultobj;
24699 fail:
24700 return NULL;
24701 }
24702
24703
24704 static PyObject * AcceleratorTable_swigregister(PyObject *, PyObject *args) {
24705 PyObject *obj;
24706 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24707 SWIG_TypeClientData(SWIGTYPE_p_wxAcceleratorTable, obj);
24708 Py_INCREF(obj);
24709 return Py_BuildValue((char *)"");
24710 }
24711 static int _wrap_NullAcceleratorTable_set(PyObject *) {
24712 PyErr_SetString(PyExc_TypeError,"Variable NullAcceleratorTable is read-only.");
24713 return 1;
24714 }
24715
24716
24717 static PyObject *_wrap_NullAcceleratorTable_get(void) {
24718 PyObject *pyobj;
24719
24720 pyobj = SWIG_NewPointerObj((void *)(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0);
24721 return pyobj;
24722 }
24723
24724
24725 static PyObject *_wrap_GetAccelFromString(PyObject *, PyObject *args, PyObject *kwargs) {
24726 PyObject *resultobj;
24727 wxString *arg1 = 0 ;
24728 wxAcceleratorEntry *result;
24729 bool temp1 = false ;
24730 PyObject * obj0 = 0 ;
24731 char *kwnames[] = {
24732 (char *) "label", NULL
24733 };
24734
24735 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) goto fail;
24736 {
24737 arg1 = wxString_in_helper(obj0);
24738 if (arg1 == NULL) SWIG_fail;
24739 temp1 = true;
24740 }
24741 {
24742 PyThreadState* __tstate = wxPyBeginAllowThreads();
24743 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
24744
24745 wxPyEndAllowThreads(__tstate);
24746 if (PyErr_Occurred()) SWIG_fail;
24747 }
24748 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
24749 {
24750 if (temp1)
24751 delete arg1;
24752 }
24753 return resultobj;
24754 fail:
24755 {
24756 if (temp1)
24757 delete arg1;
24758 }
24759 return NULL;
24760 }
24761
24762
24763 static int _wrap_PanelNameStr_set(PyObject *) {
24764 PyErr_SetString(PyExc_TypeError,"Variable PanelNameStr is read-only.");
24765 return 1;
24766 }
24767
24768
24769 static PyObject *_wrap_PanelNameStr_get(void) {
24770 PyObject *pyobj;
24771
24772 {
24773 #if wxUSE_UNICODE
24774 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24775 #else
24776 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
24777 #endif
24778 }
24779 return pyobj;
24780 }
24781
24782
24783 static PyObject *_wrap_new_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24784 PyObject *resultobj;
24785 wxVisualAttributes *result;
24786 char *kwnames[] = {
24787 NULL
24788 };
24789
24790 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_VisualAttributes",kwnames)) goto fail;
24791 {
24792 PyThreadState* __tstate = wxPyBeginAllowThreads();
24793 result = (wxVisualAttributes *)new_wxVisualAttributes();
24794
24795 wxPyEndAllowThreads(__tstate);
24796 if (PyErr_Occurred()) SWIG_fail;
24797 }
24798 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxVisualAttributes, 1);
24799 return resultobj;
24800 fail:
24801 return NULL;
24802 }
24803
24804
24805 static PyObject *_wrap_delete_VisualAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
24806 PyObject *resultobj;
24807 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24808 PyObject * obj0 = 0 ;
24809 char *kwnames[] = {
24810 (char *) "self", NULL
24811 };
24812
24813 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:delete_VisualAttributes",kwnames,&obj0)) goto fail;
24814 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24815 if (SWIG_arg_fail(1)) SWIG_fail;
24816 {
24817 PyThreadState* __tstate = wxPyBeginAllowThreads();
24818 delete_wxVisualAttributes(arg1);
24819
24820 wxPyEndAllowThreads(__tstate);
24821 if (PyErr_Occurred()) SWIG_fail;
24822 }
24823 Py_INCREF(Py_None); resultobj = Py_None;
24824 return resultobj;
24825 fail:
24826 return NULL;
24827 }
24828
24829
24830 static PyObject *_wrap_VisualAttributes_font_set(PyObject *, PyObject *args, PyObject *kwargs) {
24831 PyObject *resultobj;
24832 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24833 wxFont *arg2 = (wxFont *) 0 ;
24834 PyObject * obj0 = 0 ;
24835 PyObject * obj1 = 0 ;
24836 char *kwnames[] = {
24837 (char *) "self",(char *) "font", NULL
24838 };
24839
24840 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_font_set",kwnames,&obj0,&obj1)) goto fail;
24841 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24842 if (SWIG_arg_fail(1)) SWIG_fail;
24843 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
24844 if (SWIG_arg_fail(2)) SWIG_fail;
24845 if (arg1) (arg1)->font = *arg2;
24846
24847 Py_INCREF(Py_None); resultobj = Py_None;
24848 return resultobj;
24849 fail:
24850 return NULL;
24851 }
24852
24853
24854 static PyObject *_wrap_VisualAttributes_font_get(PyObject *, PyObject *args, PyObject *kwargs) {
24855 PyObject *resultobj;
24856 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24857 wxFont *result;
24858 PyObject * obj0 = 0 ;
24859 char *kwnames[] = {
24860 (char *) "self", NULL
24861 };
24862
24863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_font_get",kwnames,&obj0)) goto fail;
24864 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24865 if (SWIG_arg_fail(1)) SWIG_fail;
24866 result = (wxFont *)& ((arg1)->font);
24867
24868 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFont, 0);
24869 return resultobj;
24870 fail:
24871 return NULL;
24872 }
24873
24874
24875 static PyObject *_wrap_VisualAttributes_colFg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24876 PyObject *resultobj;
24877 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24878 wxColour *arg2 = (wxColour *) 0 ;
24879 PyObject * obj0 = 0 ;
24880 PyObject * obj1 = 0 ;
24881 char *kwnames[] = {
24882 (char *) "self",(char *) "colFg", NULL
24883 };
24884
24885 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colFg_set",kwnames,&obj0,&obj1)) goto fail;
24886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24887 if (SWIG_arg_fail(1)) SWIG_fail;
24888 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24889 if (SWIG_arg_fail(2)) SWIG_fail;
24890 if (arg1) (arg1)->colFg = *arg2;
24891
24892 Py_INCREF(Py_None); resultobj = Py_None;
24893 return resultobj;
24894 fail:
24895 return NULL;
24896 }
24897
24898
24899 static PyObject *_wrap_VisualAttributes_colFg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24900 PyObject *resultobj;
24901 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24902 wxColour *result;
24903 PyObject * obj0 = 0 ;
24904 char *kwnames[] = {
24905 (char *) "self", NULL
24906 };
24907
24908 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colFg_get",kwnames,&obj0)) goto fail;
24909 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24910 if (SWIG_arg_fail(1)) SWIG_fail;
24911 result = (wxColour *)& ((arg1)->colFg);
24912
24913 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24914 return resultobj;
24915 fail:
24916 return NULL;
24917 }
24918
24919
24920 static PyObject *_wrap_VisualAttributes_colBg_set(PyObject *, PyObject *args, PyObject *kwargs) {
24921 PyObject *resultobj;
24922 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24923 wxColour *arg2 = (wxColour *) 0 ;
24924 PyObject * obj0 = 0 ;
24925 PyObject * obj1 = 0 ;
24926 char *kwnames[] = {
24927 (char *) "self",(char *) "colBg", NULL
24928 };
24929
24930 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:VisualAttributes_colBg_set",kwnames,&obj0,&obj1)) goto fail;
24931 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24932 if (SWIG_arg_fail(1)) SWIG_fail;
24933 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxColour, SWIG_POINTER_EXCEPTION | 0);
24934 if (SWIG_arg_fail(2)) SWIG_fail;
24935 if (arg1) (arg1)->colBg = *arg2;
24936
24937 Py_INCREF(Py_None); resultobj = Py_None;
24938 return resultobj;
24939 fail:
24940 return NULL;
24941 }
24942
24943
24944 static PyObject *_wrap_VisualAttributes_colBg_get(PyObject *, PyObject *args, PyObject *kwargs) {
24945 PyObject *resultobj;
24946 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
24947 wxColour *result;
24948 PyObject * obj0 = 0 ;
24949 char *kwnames[] = {
24950 (char *) "self", NULL
24951 };
24952
24953 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:VisualAttributes_colBg_get",kwnames,&obj0)) goto fail;
24954 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_EXCEPTION | 0);
24955 if (SWIG_arg_fail(1)) SWIG_fail;
24956 result = (wxColour *)& ((arg1)->colBg);
24957
24958 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxColour, 0);
24959 return resultobj;
24960 fail:
24961 return NULL;
24962 }
24963
24964
24965 static PyObject * VisualAttributes_swigregister(PyObject *, PyObject *args) {
24966 PyObject *obj;
24967 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
24968 SWIG_TypeClientData(SWIGTYPE_p_wxVisualAttributes, obj);
24969 Py_INCREF(obj);
24970 return Py_BuildValue((char *)"");
24971 }
24972 static PyObject *_wrap_new_Window(PyObject *, PyObject *args, PyObject *kwargs) {
24973 PyObject *resultobj;
24974 wxWindow *arg1 = (wxWindow *) 0 ;
24975 int arg2 = (int) (int)-1 ;
24976 wxPoint const &arg3_defvalue = wxDefaultPosition ;
24977 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
24978 wxSize const &arg4_defvalue = wxDefaultSize ;
24979 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
24980 long arg5 = (long) 0 ;
24981 wxString const &arg6_defvalue = wxPyPanelNameStr ;
24982 wxString *arg6 = (wxString *) &arg6_defvalue ;
24983 wxWindow *result;
24984 wxPoint temp3 ;
24985 wxSize temp4 ;
24986 bool temp6 = false ;
24987 PyObject * obj0 = 0 ;
24988 PyObject * obj1 = 0 ;
24989 PyObject * obj2 = 0 ;
24990 PyObject * obj3 = 0 ;
24991 PyObject * obj4 = 0 ;
24992 PyObject * obj5 = 0 ;
24993 char *kwnames[] = {
24994 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
24995 };
24996
24997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
24998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
24999 if (SWIG_arg_fail(1)) SWIG_fail;
25000 if (obj1) {
25001 {
25002 arg2 = (int const)(SWIG_As_int(obj1));
25003 if (SWIG_arg_fail(2)) SWIG_fail;
25004 }
25005 }
25006 if (obj2) {
25007 {
25008 arg3 = &temp3;
25009 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
25010 }
25011 }
25012 if (obj3) {
25013 {
25014 arg4 = &temp4;
25015 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
25016 }
25017 }
25018 if (obj4) {
25019 {
25020 arg5 = (long)(SWIG_As_long(obj4));
25021 if (SWIG_arg_fail(5)) SWIG_fail;
25022 }
25023 }
25024 if (obj5) {
25025 {
25026 arg6 = wxString_in_helper(obj5);
25027 if (arg6 == NULL) SWIG_fail;
25028 temp6 = true;
25029 }
25030 }
25031 {
25032 if (!wxPyCheckForApp()) SWIG_fail;
25033 PyThreadState* __tstate = wxPyBeginAllowThreads();
25034 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
25035
25036 wxPyEndAllowThreads(__tstate);
25037 if (PyErr_Occurred()) SWIG_fail;
25038 }
25039 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25040 {
25041 if (temp6)
25042 delete arg6;
25043 }
25044 return resultobj;
25045 fail:
25046 {
25047 if (temp6)
25048 delete arg6;
25049 }
25050 return NULL;
25051 }
25052
25053
25054 static PyObject *_wrap_new_PreWindow(PyObject *, PyObject *args, PyObject *kwargs) {
25055 PyObject *resultobj;
25056 wxWindow *result;
25057 char *kwnames[] = {
25058 NULL
25059 };
25060
25061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreWindow",kwnames)) goto fail;
25062 {
25063 if (!wxPyCheckForApp()) SWIG_fail;
25064 PyThreadState* __tstate = wxPyBeginAllowThreads();
25065 result = (wxWindow *)new wxWindow();
25066
25067 wxPyEndAllowThreads(__tstate);
25068 if (PyErr_Occurred()) SWIG_fail;
25069 }
25070 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxWindow, 1);
25071 return resultobj;
25072 fail:
25073 return NULL;
25074 }
25075
25076
25077 static PyObject *_wrap_Window_Create(PyObject *, PyObject *args, PyObject *kwargs) {
25078 PyObject *resultobj;
25079 wxWindow *arg1 = (wxWindow *) 0 ;
25080 wxWindow *arg2 = (wxWindow *) 0 ;
25081 int arg3 = (int) (int)-1 ;
25082 wxPoint const &arg4_defvalue = wxDefaultPosition ;
25083 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
25084 wxSize const &arg5_defvalue = wxDefaultSize ;
25085 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
25086 long arg6 = (long) 0 ;
25087 wxString const &arg7_defvalue = wxPyPanelNameStr ;
25088 wxString *arg7 = (wxString *) &arg7_defvalue ;
25089 bool result;
25090 wxPoint temp4 ;
25091 wxSize temp5 ;
25092 bool temp7 = false ;
25093 PyObject * obj0 = 0 ;
25094 PyObject * obj1 = 0 ;
25095 PyObject * obj2 = 0 ;
25096 PyObject * obj3 = 0 ;
25097 PyObject * obj4 = 0 ;
25098 PyObject * obj5 = 0 ;
25099 PyObject * obj6 = 0 ;
25100 char *kwnames[] = {
25101 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
25102 };
25103
25104 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
25105 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25106 if (SWIG_arg_fail(1)) SWIG_fail;
25107 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25108 if (SWIG_arg_fail(2)) SWIG_fail;
25109 if (obj2) {
25110 {
25111 arg3 = (int const)(SWIG_As_int(obj2));
25112 if (SWIG_arg_fail(3)) SWIG_fail;
25113 }
25114 }
25115 if (obj3) {
25116 {
25117 arg4 = &temp4;
25118 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
25119 }
25120 }
25121 if (obj4) {
25122 {
25123 arg5 = &temp5;
25124 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
25125 }
25126 }
25127 if (obj5) {
25128 {
25129 arg6 = (long)(SWIG_As_long(obj5));
25130 if (SWIG_arg_fail(6)) SWIG_fail;
25131 }
25132 }
25133 if (obj6) {
25134 {
25135 arg7 = wxString_in_helper(obj6);
25136 if (arg7 == NULL) SWIG_fail;
25137 temp7 = true;
25138 }
25139 }
25140 {
25141 PyThreadState* __tstate = wxPyBeginAllowThreads();
25142 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
25143
25144 wxPyEndAllowThreads(__tstate);
25145 if (PyErr_Occurred()) SWIG_fail;
25146 }
25147 {
25148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25149 }
25150 {
25151 if (temp7)
25152 delete arg7;
25153 }
25154 return resultobj;
25155 fail:
25156 {
25157 if (temp7)
25158 delete arg7;
25159 }
25160 return NULL;
25161 }
25162
25163
25164 static PyObject *_wrap_Window_Close(PyObject *, PyObject *args, PyObject *kwargs) {
25165 PyObject *resultobj;
25166 wxWindow *arg1 = (wxWindow *) 0 ;
25167 bool arg2 = (bool) false ;
25168 bool result;
25169 PyObject * obj0 = 0 ;
25170 PyObject * obj1 = 0 ;
25171 char *kwnames[] = {
25172 (char *) "self",(char *) "force", NULL
25173 };
25174
25175 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) goto fail;
25176 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25177 if (SWIG_arg_fail(1)) SWIG_fail;
25178 if (obj1) {
25179 {
25180 arg2 = (bool)(SWIG_As_bool(obj1));
25181 if (SWIG_arg_fail(2)) SWIG_fail;
25182 }
25183 }
25184 {
25185 PyThreadState* __tstate = wxPyBeginAllowThreads();
25186 result = (bool)(arg1)->Close(arg2);
25187
25188 wxPyEndAllowThreads(__tstate);
25189 if (PyErr_Occurred()) SWIG_fail;
25190 }
25191 {
25192 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25193 }
25194 return resultobj;
25195 fail:
25196 return NULL;
25197 }
25198
25199
25200 static PyObject *_wrap_Window_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
25201 PyObject *resultobj;
25202 wxWindow *arg1 = (wxWindow *) 0 ;
25203 bool result;
25204 PyObject * obj0 = 0 ;
25205 char *kwnames[] = {
25206 (char *) "self", NULL
25207 };
25208
25209 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Destroy",kwnames,&obj0)) goto fail;
25210 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25211 if (SWIG_arg_fail(1)) SWIG_fail;
25212 {
25213 PyThreadState* __tstate = wxPyBeginAllowThreads();
25214 result = (bool)(arg1)->Destroy();
25215
25216 wxPyEndAllowThreads(__tstate);
25217 if (PyErr_Occurred()) SWIG_fail;
25218 }
25219 {
25220 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25221 }
25222 return resultobj;
25223 fail:
25224 return NULL;
25225 }
25226
25227
25228 static PyObject *_wrap_Window_DestroyChildren(PyObject *, PyObject *args, PyObject *kwargs) {
25229 PyObject *resultobj;
25230 wxWindow *arg1 = (wxWindow *) 0 ;
25231 bool result;
25232 PyObject * obj0 = 0 ;
25233 char *kwnames[] = {
25234 (char *) "self", NULL
25235 };
25236
25237 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DestroyChildren",kwnames,&obj0)) goto fail;
25238 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25239 if (SWIG_arg_fail(1)) SWIG_fail;
25240 {
25241 PyThreadState* __tstate = wxPyBeginAllowThreads();
25242 result = (bool)(arg1)->DestroyChildren();
25243
25244 wxPyEndAllowThreads(__tstate);
25245 if (PyErr_Occurred()) SWIG_fail;
25246 }
25247 {
25248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25249 }
25250 return resultobj;
25251 fail:
25252 return NULL;
25253 }
25254
25255
25256 static PyObject *_wrap_Window_IsBeingDeleted(PyObject *, PyObject *args, PyObject *kwargs) {
25257 PyObject *resultobj;
25258 wxWindow *arg1 = (wxWindow *) 0 ;
25259 bool result;
25260 PyObject * obj0 = 0 ;
25261 char *kwnames[] = {
25262 (char *) "self", NULL
25263 };
25264
25265 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsBeingDeleted",kwnames,&obj0)) goto fail;
25266 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25267 if (SWIG_arg_fail(1)) SWIG_fail;
25268 {
25269 PyThreadState* __tstate = wxPyBeginAllowThreads();
25270 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
25271
25272 wxPyEndAllowThreads(__tstate);
25273 if (PyErr_Occurred()) SWIG_fail;
25274 }
25275 {
25276 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25277 }
25278 return resultobj;
25279 fail:
25280 return NULL;
25281 }
25282
25283
25284 static PyObject *_wrap_Window_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25285 PyObject *resultobj;
25286 wxWindow *arg1 = (wxWindow *) 0 ;
25287 wxString *arg2 = 0 ;
25288 bool temp2 = false ;
25289 PyObject * obj0 = 0 ;
25290 PyObject * obj1 = 0 ;
25291 char *kwnames[] = {
25292 (char *) "self",(char *) "title", NULL
25293 };
25294
25295 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTitle",kwnames,&obj0,&obj1)) goto fail;
25296 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25297 if (SWIG_arg_fail(1)) SWIG_fail;
25298 {
25299 arg2 = wxString_in_helper(obj1);
25300 if (arg2 == NULL) SWIG_fail;
25301 temp2 = true;
25302 }
25303 {
25304 PyThreadState* __tstate = wxPyBeginAllowThreads();
25305 (arg1)->SetTitle((wxString const &)*arg2);
25306
25307 wxPyEndAllowThreads(__tstate);
25308 if (PyErr_Occurred()) SWIG_fail;
25309 }
25310 Py_INCREF(Py_None); resultobj = Py_None;
25311 {
25312 if (temp2)
25313 delete arg2;
25314 }
25315 return resultobj;
25316 fail:
25317 {
25318 if (temp2)
25319 delete arg2;
25320 }
25321 return NULL;
25322 }
25323
25324
25325 static PyObject *_wrap_Window_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
25326 PyObject *resultobj;
25327 wxWindow *arg1 = (wxWindow *) 0 ;
25328 wxString result;
25329 PyObject * obj0 = 0 ;
25330 char *kwnames[] = {
25331 (char *) "self", NULL
25332 };
25333
25334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetTitle",kwnames,&obj0)) goto fail;
25335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25336 if (SWIG_arg_fail(1)) SWIG_fail;
25337 {
25338 PyThreadState* __tstate = wxPyBeginAllowThreads();
25339 result = ((wxWindow const *)arg1)->GetTitle();
25340
25341 wxPyEndAllowThreads(__tstate);
25342 if (PyErr_Occurred()) SWIG_fail;
25343 }
25344 {
25345 #if wxUSE_UNICODE
25346 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25347 #else
25348 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25349 #endif
25350 }
25351 return resultobj;
25352 fail:
25353 return NULL;
25354 }
25355
25356
25357 static PyObject *_wrap_Window_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25358 PyObject *resultobj;
25359 wxWindow *arg1 = (wxWindow *) 0 ;
25360 wxString *arg2 = 0 ;
25361 bool temp2 = false ;
25362 PyObject * obj0 = 0 ;
25363 PyObject * obj1 = 0 ;
25364 char *kwnames[] = {
25365 (char *) "self",(char *) "label", NULL
25366 };
25367
25368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) goto fail;
25369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25370 if (SWIG_arg_fail(1)) SWIG_fail;
25371 {
25372 arg2 = wxString_in_helper(obj1);
25373 if (arg2 == NULL) SWIG_fail;
25374 temp2 = true;
25375 }
25376 {
25377 PyThreadState* __tstate = wxPyBeginAllowThreads();
25378 (arg1)->SetLabel((wxString const &)*arg2);
25379
25380 wxPyEndAllowThreads(__tstate);
25381 if (PyErr_Occurred()) SWIG_fail;
25382 }
25383 Py_INCREF(Py_None); resultobj = Py_None;
25384 {
25385 if (temp2)
25386 delete arg2;
25387 }
25388 return resultobj;
25389 fail:
25390 {
25391 if (temp2)
25392 delete arg2;
25393 }
25394 return NULL;
25395 }
25396
25397
25398 static PyObject *_wrap_Window_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
25399 PyObject *resultobj;
25400 wxWindow *arg1 = (wxWindow *) 0 ;
25401 wxString result;
25402 PyObject * obj0 = 0 ;
25403 char *kwnames[] = {
25404 (char *) "self", NULL
25405 };
25406
25407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetLabel",kwnames,&obj0)) goto fail;
25408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25409 if (SWIG_arg_fail(1)) SWIG_fail;
25410 {
25411 PyThreadState* __tstate = wxPyBeginAllowThreads();
25412 result = ((wxWindow const *)arg1)->GetLabel();
25413
25414 wxPyEndAllowThreads(__tstate);
25415 if (PyErr_Occurred()) SWIG_fail;
25416 }
25417 {
25418 #if wxUSE_UNICODE
25419 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25420 #else
25421 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25422 #endif
25423 }
25424 return resultobj;
25425 fail:
25426 return NULL;
25427 }
25428
25429
25430 static PyObject *_wrap_Window_SetName(PyObject *, PyObject *args, PyObject *kwargs) {
25431 PyObject *resultobj;
25432 wxWindow *arg1 = (wxWindow *) 0 ;
25433 wxString *arg2 = 0 ;
25434 bool temp2 = false ;
25435 PyObject * obj0 = 0 ;
25436 PyObject * obj1 = 0 ;
25437 char *kwnames[] = {
25438 (char *) "self",(char *) "name", NULL
25439 };
25440
25441 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) goto fail;
25442 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25443 if (SWIG_arg_fail(1)) SWIG_fail;
25444 {
25445 arg2 = wxString_in_helper(obj1);
25446 if (arg2 == NULL) SWIG_fail;
25447 temp2 = true;
25448 }
25449 {
25450 PyThreadState* __tstate = wxPyBeginAllowThreads();
25451 (arg1)->SetName((wxString const &)*arg2);
25452
25453 wxPyEndAllowThreads(__tstate);
25454 if (PyErr_Occurred()) SWIG_fail;
25455 }
25456 Py_INCREF(Py_None); resultobj = Py_None;
25457 {
25458 if (temp2)
25459 delete arg2;
25460 }
25461 return resultobj;
25462 fail:
25463 {
25464 if (temp2)
25465 delete arg2;
25466 }
25467 return NULL;
25468 }
25469
25470
25471 static PyObject *_wrap_Window_GetName(PyObject *, PyObject *args, PyObject *kwargs) {
25472 PyObject *resultobj;
25473 wxWindow *arg1 = (wxWindow *) 0 ;
25474 wxString result;
25475 PyObject * obj0 = 0 ;
25476 char *kwnames[] = {
25477 (char *) "self", NULL
25478 };
25479
25480 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetName",kwnames,&obj0)) goto fail;
25481 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25482 if (SWIG_arg_fail(1)) SWIG_fail;
25483 {
25484 PyThreadState* __tstate = wxPyBeginAllowThreads();
25485 result = ((wxWindow const *)arg1)->GetName();
25486
25487 wxPyEndAllowThreads(__tstate);
25488 if (PyErr_Occurred()) SWIG_fail;
25489 }
25490 {
25491 #if wxUSE_UNICODE
25492 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
25493 #else
25494 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
25495 #endif
25496 }
25497 return resultobj;
25498 fail:
25499 return NULL;
25500 }
25501
25502
25503 static PyObject *_wrap_Window_SetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25504 PyObject *resultobj;
25505 wxWindow *arg1 = (wxWindow *) 0 ;
25506 wxWindowVariant arg2 ;
25507 PyObject * obj0 = 0 ;
25508 PyObject * obj1 = 0 ;
25509 char *kwnames[] = {
25510 (char *) "self",(char *) "variant", NULL
25511 };
25512
25513 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) goto fail;
25514 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25515 if (SWIG_arg_fail(1)) SWIG_fail;
25516 {
25517 arg2 = (wxWindowVariant)(SWIG_As_int(obj1));
25518 if (SWIG_arg_fail(2)) SWIG_fail;
25519 }
25520 {
25521 PyThreadState* __tstate = wxPyBeginAllowThreads();
25522 (arg1)->SetWindowVariant((wxWindowVariant )arg2);
25523
25524 wxPyEndAllowThreads(__tstate);
25525 if (PyErr_Occurred()) SWIG_fail;
25526 }
25527 Py_INCREF(Py_None); resultobj = Py_None;
25528 return resultobj;
25529 fail:
25530 return NULL;
25531 }
25532
25533
25534 static PyObject *_wrap_Window_GetWindowVariant(PyObject *, PyObject *args, PyObject *kwargs) {
25535 PyObject *resultobj;
25536 wxWindow *arg1 = (wxWindow *) 0 ;
25537 wxWindowVariant result;
25538 PyObject * obj0 = 0 ;
25539 char *kwnames[] = {
25540 (char *) "self", NULL
25541 };
25542
25543 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowVariant",kwnames,&obj0)) goto fail;
25544 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25545 if (SWIG_arg_fail(1)) SWIG_fail;
25546 {
25547 PyThreadState* __tstate = wxPyBeginAllowThreads();
25548 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
25549
25550 wxPyEndAllowThreads(__tstate);
25551 if (PyErr_Occurred()) SWIG_fail;
25552 }
25553 resultobj = SWIG_From_int((result));
25554 return resultobj;
25555 fail:
25556 return NULL;
25557 }
25558
25559
25560 static PyObject *_wrap_Window_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
25561 PyObject *resultobj;
25562 wxWindow *arg1 = (wxWindow *) 0 ;
25563 int arg2 ;
25564 PyObject * obj0 = 0 ;
25565 PyObject * obj1 = 0 ;
25566 char *kwnames[] = {
25567 (char *) "self",(char *) "winid", NULL
25568 };
25569
25570 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) goto fail;
25571 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25572 if (SWIG_arg_fail(1)) SWIG_fail;
25573 {
25574 arg2 = (int)(SWIG_As_int(obj1));
25575 if (SWIG_arg_fail(2)) SWIG_fail;
25576 }
25577 {
25578 PyThreadState* __tstate = wxPyBeginAllowThreads();
25579 (arg1)->SetId(arg2);
25580
25581 wxPyEndAllowThreads(__tstate);
25582 if (PyErr_Occurred()) SWIG_fail;
25583 }
25584 Py_INCREF(Py_None); resultobj = Py_None;
25585 return resultobj;
25586 fail:
25587 return NULL;
25588 }
25589
25590
25591 static PyObject *_wrap_Window_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
25592 PyObject *resultobj;
25593 wxWindow *arg1 = (wxWindow *) 0 ;
25594 int result;
25595 PyObject * obj0 = 0 ;
25596 char *kwnames[] = {
25597 (char *) "self", NULL
25598 };
25599
25600 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetId",kwnames,&obj0)) goto fail;
25601 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25602 if (SWIG_arg_fail(1)) SWIG_fail;
25603 {
25604 PyThreadState* __tstate = wxPyBeginAllowThreads();
25605 result = (int)((wxWindow const *)arg1)->GetId();
25606
25607 wxPyEndAllowThreads(__tstate);
25608 if (PyErr_Occurred()) SWIG_fail;
25609 }
25610 {
25611 resultobj = SWIG_From_int((int)(result));
25612 }
25613 return resultobj;
25614 fail:
25615 return NULL;
25616 }
25617
25618
25619 static PyObject *_wrap_Window_NewControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25620 PyObject *resultobj;
25621 int result;
25622 char *kwnames[] = {
25623 NULL
25624 };
25625
25626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_NewControlId",kwnames)) goto fail;
25627 {
25628 PyThreadState* __tstate = wxPyBeginAllowThreads();
25629 result = (int)wxWindow::NewControlId();
25630
25631 wxPyEndAllowThreads(__tstate);
25632 if (PyErr_Occurred()) SWIG_fail;
25633 }
25634 {
25635 resultobj = SWIG_From_int((int)(result));
25636 }
25637 return resultobj;
25638 fail:
25639 return NULL;
25640 }
25641
25642
25643 static PyObject *_wrap_Window_NextControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25644 PyObject *resultobj;
25645 int arg1 ;
25646 int result;
25647 PyObject * obj0 = 0 ;
25648 char *kwnames[] = {
25649 (char *) "winid", NULL
25650 };
25651
25652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) goto fail;
25653 {
25654 arg1 = (int)(SWIG_As_int(obj0));
25655 if (SWIG_arg_fail(1)) SWIG_fail;
25656 }
25657 {
25658 PyThreadState* __tstate = wxPyBeginAllowThreads();
25659 result = (int)wxWindow::NextControlId(arg1);
25660
25661 wxPyEndAllowThreads(__tstate);
25662 if (PyErr_Occurred()) SWIG_fail;
25663 }
25664 {
25665 resultobj = SWIG_From_int((int)(result));
25666 }
25667 return resultobj;
25668 fail:
25669 return NULL;
25670 }
25671
25672
25673 static PyObject *_wrap_Window_PrevControlId(PyObject *, PyObject *args, PyObject *kwargs) {
25674 PyObject *resultobj;
25675 int arg1 ;
25676 int result;
25677 PyObject * obj0 = 0 ;
25678 char *kwnames[] = {
25679 (char *) "winid", NULL
25680 };
25681
25682 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) goto fail;
25683 {
25684 arg1 = (int)(SWIG_As_int(obj0));
25685 if (SWIG_arg_fail(1)) SWIG_fail;
25686 }
25687 {
25688 PyThreadState* __tstate = wxPyBeginAllowThreads();
25689 result = (int)wxWindow::PrevControlId(arg1);
25690
25691 wxPyEndAllowThreads(__tstate);
25692 if (PyErr_Occurred()) SWIG_fail;
25693 }
25694 {
25695 resultobj = SWIG_From_int((int)(result));
25696 }
25697 return resultobj;
25698 fail:
25699 return NULL;
25700 }
25701
25702
25703 static PyObject *_wrap_Window_SetSize(PyObject *, PyObject *args, PyObject *kwargs) {
25704 PyObject *resultobj;
25705 wxWindow *arg1 = (wxWindow *) 0 ;
25706 wxSize *arg2 = 0 ;
25707 wxSize temp2 ;
25708 PyObject * obj0 = 0 ;
25709 PyObject * obj1 = 0 ;
25710 char *kwnames[] = {
25711 (char *) "self",(char *) "size", NULL
25712 };
25713
25714 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) goto fail;
25715 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25716 if (SWIG_arg_fail(1)) SWIG_fail;
25717 {
25718 arg2 = &temp2;
25719 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25720 }
25721 {
25722 PyThreadState* __tstate = wxPyBeginAllowThreads();
25723 (arg1)->SetSize((wxSize const &)*arg2);
25724
25725 wxPyEndAllowThreads(__tstate);
25726 if (PyErr_Occurred()) SWIG_fail;
25727 }
25728 Py_INCREF(Py_None); resultobj = Py_None;
25729 return resultobj;
25730 fail:
25731 return NULL;
25732 }
25733
25734
25735 static PyObject *_wrap_Window_SetDimensions(PyObject *, PyObject *args, PyObject *kwargs) {
25736 PyObject *resultobj;
25737 wxWindow *arg1 = (wxWindow *) 0 ;
25738 int arg2 ;
25739 int arg3 ;
25740 int arg4 ;
25741 int arg5 ;
25742 int arg6 = (int) wxSIZE_AUTO ;
25743 PyObject * obj0 = 0 ;
25744 PyObject * obj1 = 0 ;
25745 PyObject * obj2 = 0 ;
25746 PyObject * obj3 = 0 ;
25747 PyObject * obj4 = 0 ;
25748 PyObject * obj5 = 0 ;
25749 char *kwnames[] = {
25750 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
25751 };
25752
25753 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
25754 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25755 if (SWIG_arg_fail(1)) SWIG_fail;
25756 {
25757 arg2 = (int)(SWIG_As_int(obj1));
25758 if (SWIG_arg_fail(2)) SWIG_fail;
25759 }
25760 {
25761 arg3 = (int)(SWIG_As_int(obj2));
25762 if (SWIG_arg_fail(3)) SWIG_fail;
25763 }
25764 {
25765 arg4 = (int)(SWIG_As_int(obj3));
25766 if (SWIG_arg_fail(4)) SWIG_fail;
25767 }
25768 {
25769 arg5 = (int)(SWIG_As_int(obj4));
25770 if (SWIG_arg_fail(5)) SWIG_fail;
25771 }
25772 if (obj5) {
25773 {
25774 arg6 = (int)(SWIG_As_int(obj5));
25775 if (SWIG_arg_fail(6)) SWIG_fail;
25776 }
25777 }
25778 {
25779 PyThreadState* __tstate = wxPyBeginAllowThreads();
25780 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
25781
25782 wxPyEndAllowThreads(__tstate);
25783 if (PyErr_Occurred()) SWIG_fail;
25784 }
25785 Py_INCREF(Py_None); resultobj = Py_None;
25786 return resultobj;
25787 fail:
25788 return NULL;
25789 }
25790
25791
25792 static PyObject *_wrap_Window_SetRect(PyObject *, PyObject *args, PyObject *kwargs) {
25793 PyObject *resultobj;
25794 wxWindow *arg1 = (wxWindow *) 0 ;
25795 wxRect *arg2 = 0 ;
25796 int arg3 = (int) wxSIZE_AUTO ;
25797 wxRect temp2 ;
25798 PyObject * obj0 = 0 ;
25799 PyObject * obj1 = 0 ;
25800 PyObject * obj2 = 0 ;
25801 char *kwnames[] = {
25802 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
25803 };
25804
25805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
25806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25807 if (SWIG_arg_fail(1)) SWIG_fail;
25808 {
25809 arg2 = &temp2;
25810 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
25811 }
25812 if (obj2) {
25813 {
25814 arg3 = (int)(SWIG_As_int(obj2));
25815 if (SWIG_arg_fail(3)) SWIG_fail;
25816 }
25817 }
25818 {
25819 PyThreadState* __tstate = wxPyBeginAllowThreads();
25820 (arg1)->SetSize((wxRect const &)*arg2,arg3);
25821
25822 wxPyEndAllowThreads(__tstate);
25823 if (PyErr_Occurred()) SWIG_fail;
25824 }
25825 Py_INCREF(Py_None); resultobj = Py_None;
25826 return resultobj;
25827 fail:
25828 return NULL;
25829 }
25830
25831
25832 static PyObject *_wrap_Window_SetSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
25833 PyObject *resultobj;
25834 wxWindow *arg1 = (wxWindow *) 0 ;
25835 int arg2 ;
25836 int arg3 ;
25837 PyObject * obj0 = 0 ;
25838 PyObject * obj1 = 0 ;
25839 PyObject * obj2 = 0 ;
25840 char *kwnames[] = {
25841 (char *) "self",(char *) "width",(char *) "height", NULL
25842 };
25843
25844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
25845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25846 if (SWIG_arg_fail(1)) SWIG_fail;
25847 {
25848 arg2 = (int)(SWIG_As_int(obj1));
25849 if (SWIG_arg_fail(2)) SWIG_fail;
25850 }
25851 {
25852 arg3 = (int)(SWIG_As_int(obj2));
25853 if (SWIG_arg_fail(3)) SWIG_fail;
25854 }
25855 {
25856 PyThreadState* __tstate = wxPyBeginAllowThreads();
25857 (arg1)->SetSize(arg2,arg3);
25858
25859 wxPyEndAllowThreads(__tstate);
25860 if (PyErr_Occurred()) SWIG_fail;
25861 }
25862 Py_INCREF(Py_None); resultobj = Py_None;
25863 return resultobj;
25864 fail:
25865 return NULL;
25866 }
25867
25868
25869 static PyObject *_wrap_Window_Move(PyObject *, PyObject *args, PyObject *kwargs) {
25870 PyObject *resultobj;
25871 wxWindow *arg1 = (wxWindow *) 0 ;
25872 wxPoint *arg2 = 0 ;
25873 int arg3 = (int) wxSIZE_USE_EXISTING ;
25874 wxPoint temp2 ;
25875 PyObject * obj0 = 0 ;
25876 PyObject * obj1 = 0 ;
25877 PyObject * obj2 = 0 ;
25878 char *kwnames[] = {
25879 (char *) "self",(char *) "pt",(char *) "flags", NULL
25880 };
25881
25882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) goto fail;
25883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25884 if (SWIG_arg_fail(1)) SWIG_fail;
25885 {
25886 arg2 = &temp2;
25887 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
25888 }
25889 if (obj2) {
25890 {
25891 arg3 = (int)(SWIG_As_int(obj2));
25892 if (SWIG_arg_fail(3)) SWIG_fail;
25893 }
25894 }
25895 {
25896 PyThreadState* __tstate = wxPyBeginAllowThreads();
25897 (arg1)->Move((wxPoint const &)*arg2,arg3);
25898
25899 wxPyEndAllowThreads(__tstate);
25900 if (PyErr_Occurred()) SWIG_fail;
25901 }
25902 Py_INCREF(Py_None); resultobj = Py_None;
25903 return resultobj;
25904 fail:
25905 return NULL;
25906 }
25907
25908
25909 static PyObject *_wrap_Window_MoveXY(PyObject *, PyObject *args, PyObject *kwargs) {
25910 PyObject *resultobj;
25911 wxWindow *arg1 = (wxWindow *) 0 ;
25912 int arg2 ;
25913 int arg3 ;
25914 int arg4 = (int) wxSIZE_USE_EXISTING ;
25915 PyObject * obj0 = 0 ;
25916 PyObject * obj1 = 0 ;
25917 PyObject * obj2 = 0 ;
25918 PyObject * obj3 = 0 ;
25919 char *kwnames[] = {
25920 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
25921 };
25922
25923 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
25924 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25925 if (SWIG_arg_fail(1)) SWIG_fail;
25926 {
25927 arg2 = (int)(SWIG_As_int(obj1));
25928 if (SWIG_arg_fail(2)) SWIG_fail;
25929 }
25930 {
25931 arg3 = (int)(SWIG_As_int(obj2));
25932 if (SWIG_arg_fail(3)) SWIG_fail;
25933 }
25934 if (obj3) {
25935 {
25936 arg4 = (int)(SWIG_As_int(obj3));
25937 if (SWIG_arg_fail(4)) SWIG_fail;
25938 }
25939 }
25940 {
25941 PyThreadState* __tstate = wxPyBeginAllowThreads();
25942 (arg1)->Move(arg2,arg3,arg4);
25943
25944 wxPyEndAllowThreads(__tstate);
25945 if (PyErr_Occurred()) SWIG_fail;
25946 }
25947 Py_INCREF(Py_None); resultobj = Py_None;
25948 return resultobj;
25949 fail:
25950 return NULL;
25951 }
25952
25953
25954 static PyObject *_wrap_Window_SetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
25955 PyObject *resultobj;
25956 wxWindow *arg1 = (wxWindow *) 0 ;
25957 wxSize const &arg2_defvalue = wxDefaultSize ;
25958 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
25959 wxSize temp2 ;
25960 PyObject * obj0 = 0 ;
25961 PyObject * obj1 = 0 ;
25962 char *kwnames[] = {
25963 (char *) "self",(char *) "size", NULL
25964 };
25965
25966 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) goto fail;
25967 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25968 if (SWIG_arg_fail(1)) SWIG_fail;
25969 if (obj1) {
25970 {
25971 arg2 = &temp2;
25972 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
25973 }
25974 }
25975 {
25976 PyThreadState* __tstate = wxPyBeginAllowThreads();
25977 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
25978
25979 wxPyEndAllowThreads(__tstate);
25980 if (PyErr_Occurred()) SWIG_fail;
25981 }
25982 Py_INCREF(Py_None); resultobj = Py_None;
25983 return resultobj;
25984 fail:
25985 return NULL;
25986 }
25987
25988
25989 static PyObject *_wrap_Window_Raise(PyObject *, PyObject *args, PyObject *kwargs) {
25990 PyObject *resultobj;
25991 wxWindow *arg1 = (wxWindow *) 0 ;
25992 PyObject * obj0 = 0 ;
25993 char *kwnames[] = {
25994 (char *) "self", NULL
25995 };
25996
25997 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Raise",kwnames,&obj0)) goto fail;
25998 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
25999 if (SWIG_arg_fail(1)) SWIG_fail;
26000 {
26001 PyThreadState* __tstate = wxPyBeginAllowThreads();
26002 (arg1)->Raise();
26003
26004 wxPyEndAllowThreads(__tstate);
26005 if (PyErr_Occurred()) SWIG_fail;
26006 }
26007 Py_INCREF(Py_None); resultobj = Py_None;
26008 return resultobj;
26009 fail:
26010 return NULL;
26011 }
26012
26013
26014 static PyObject *_wrap_Window_Lower(PyObject *, PyObject *args, PyObject *kwargs) {
26015 PyObject *resultobj;
26016 wxWindow *arg1 = (wxWindow *) 0 ;
26017 PyObject * obj0 = 0 ;
26018 char *kwnames[] = {
26019 (char *) "self", NULL
26020 };
26021
26022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Lower",kwnames,&obj0)) goto fail;
26023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26024 if (SWIG_arg_fail(1)) SWIG_fail;
26025 {
26026 PyThreadState* __tstate = wxPyBeginAllowThreads();
26027 (arg1)->Lower();
26028
26029 wxPyEndAllowThreads(__tstate);
26030 if (PyErr_Occurred()) SWIG_fail;
26031 }
26032 Py_INCREF(Py_None); resultobj = Py_None;
26033 return resultobj;
26034 fail:
26035 return NULL;
26036 }
26037
26038
26039 static PyObject *_wrap_Window_SetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26040 PyObject *resultobj;
26041 wxWindow *arg1 = (wxWindow *) 0 ;
26042 wxSize *arg2 = 0 ;
26043 wxSize temp2 ;
26044 PyObject * obj0 = 0 ;
26045 PyObject * obj1 = 0 ;
26046 char *kwnames[] = {
26047 (char *) "self",(char *) "size", NULL
26048 };
26049
26050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) 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 arg2 = &temp2;
26055 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26056 }
26057 {
26058 PyThreadState* __tstate = wxPyBeginAllowThreads();
26059 (arg1)->SetClientSize((wxSize const &)*arg2);
26060
26061 wxPyEndAllowThreads(__tstate);
26062 if (PyErr_Occurred()) SWIG_fail;
26063 }
26064 Py_INCREF(Py_None); resultobj = Py_None;
26065 return resultobj;
26066 fail:
26067 return NULL;
26068 }
26069
26070
26071 static PyObject *_wrap_Window_SetClientSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
26072 PyObject *resultobj;
26073 wxWindow *arg1 = (wxWindow *) 0 ;
26074 int arg2 ;
26075 int arg3 ;
26076 PyObject * obj0 = 0 ;
26077 PyObject * obj1 = 0 ;
26078 PyObject * obj2 = 0 ;
26079 char *kwnames[] = {
26080 (char *) "self",(char *) "width",(char *) "height", NULL
26081 };
26082
26083 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
26084 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26085 if (SWIG_arg_fail(1)) SWIG_fail;
26086 {
26087 arg2 = (int)(SWIG_As_int(obj1));
26088 if (SWIG_arg_fail(2)) SWIG_fail;
26089 }
26090 {
26091 arg3 = (int)(SWIG_As_int(obj2));
26092 if (SWIG_arg_fail(3)) SWIG_fail;
26093 }
26094 {
26095 PyThreadState* __tstate = wxPyBeginAllowThreads();
26096 (arg1)->SetClientSize(arg2,arg3);
26097
26098 wxPyEndAllowThreads(__tstate);
26099 if (PyErr_Occurred()) SWIG_fail;
26100 }
26101 Py_INCREF(Py_None); resultobj = Py_None;
26102 return resultobj;
26103 fail:
26104 return NULL;
26105 }
26106
26107
26108 static PyObject *_wrap_Window_SetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26109 PyObject *resultobj;
26110 wxWindow *arg1 = (wxWindow *) 0 ;
26111 wxRect *arg2 = 0 ;
26112 wxRect temp2 ;
26113 PyObject * obj0 = 0 ;
26114 PyObject * obj1 = 0 ;
26115 char *kwnames[] = {
26116 (char *) "self",(char *) "rect", NULL
26117 };
26118
26119 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) goto fail;
26120 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26121 if (SWIG_arg_fail(1)) SWIG_fail;
26122 {
26123 arg2 = &temp2;
26124 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26125 }
26126 {
26127 PyThreadState* __tstate = wxPyBeginAllowThreads();
26128 (arg1)->SetClientSize((wxRect const &)*arg2);
26129
26130 wxPyEndAllowThreads(__tstate);
26131 if (PyErr_Occurred()) SWIG_fail;
26132 }
26133 Py_INCREF(Py_None); resultobj = Py_None;
26134 return resultobj;
26135 fail:
26136 return NULL;
26137 }
26138
26139
26140 static PyObject *_wrap_Window_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
26141 PyObject *resultobj;
26142 wxWindow *arg1 = (wxWindow *) 0 ;
26143 wxPoint result;
26144 PyObject * obj0 = 0 ;
26145 char *kwnames[] = {
26146 (char *) "self", NULL
26147 };
26148
26149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPosition",kwnames,&obj0)) goto fail;
26150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26151 if (SWIG_arg_fail(1)) SWIG_fail;
26152 {
26153 PyThreadState* __tstate = wxPyBeginAllowThreads();
26154 result = (arg1)->GetPosition();
26155
26156 wxPyEndAllowThreads(__tstate);
26157 if (PyErr_Occurred()) SWIG_fail;
26158 }
26159 {
26160 wxPoint * resultptr;
26161 resultptr = new wxPoint((wxPoint &)(result));
26162 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26163 }
26164 return resultobj;
26165 fail:
26166 return NULL;
26167 }
26168
26169
26170 static PyObject *_wrap_Window_GetPositionTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26171 PyObject *resultobj;
26172 wxWindow *arg1 = (wxWindow *) 0 ;
26173 int *arg2 = (int *) 0 ;
26174 int *arg3 = (int *) 0 ;
26175 int temp2 ;
26176 int res2 = 0 ;
26177 int temp3 ;
26178 int res3 = 0 ;
26179 PyObject * obj0 = 0 ;
26180 char *kwnames[] = {
26181 (char *) "self", NULL
26182 };
26183
26184 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26185 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetPositionTuple",kwnames,&obj0)) goto fail;
26187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26188 if (SWIG_arg_fail(1)) SWIG_fail;
26189 {
26190 PyThreadState* __tstate = wxPyBeginAllowThreads();
26191 (arg1)->GetPosition(arg2,arg3);
26192
26193 wxPyEndAllowThreads(__tstate);
26194 if (PyErr_Occurred()) SWIG_fail;
26195 }
26196 Py_INCREF(Py_None); resultobj = Py_None;
26197 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26198 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26199 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26200 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26201 return resultobj;
26202 fail:
26203 return NULL;
26204 }
26205
26206
26207 static PyObject *_wrap_Window_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
26208 PyObject *resultobj;
26209 wxWindow *arg1 = (wxWindow *) 0 ;
26210 wxSize result;
26211 PyObject * obj0 = 0 ;
26212 char *kwnames[] = {
26213 (char *) "self", NULL
26214 };
26215
26216 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSize",kwnames,&obj0)) goto fail;
26217 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26218 if (SWIG_arg_fail(1)) SWIG_fail;
26219 {
26220 PyThreadState* __tstate = wxPyBeginAllowThreads();
26221 result = ((wxWindow const *)arg1)->GetSize();
26222
26223 wxPyEndAllowThreads(__tstate);
26224 if (PyErr_Occurred()) SWIG_fail;
26225 }
26226 {
26227 wxSize * resultptr;
26228 resultptr = new wxSize((wxSize &)(result));
26229 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26230 }
26231 return resultobj;
26232 fail:
26233 return NULL;
26234 }
26235
26236
26237 static PyObject *_wrap_Window_GetSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26238 PyObject *resultobj;
26239 wxWindow *arg1 = (wxWindow *) 0 ;
26240 int *arg2 = (int *) 0 ;
26241 int *arg3 = (int *) 0 ;
26242 int temp2 ;
26243 int res2 = 0 ;
26244 int temp3 ;
26245 int res3 = 0 ;
26246 PyObject * obj0 = 0 ;
26247 char *kwnames[] = {
26248 (char *) "self", NULL
26249 };
26250
26251 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26252 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26253 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizeTuple",kwnames,&obj0)) goto fail;
26254 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26255 if (SWIG_arg_fail(1)) SWIG_fail;
26256 {
26257 PyThreadState* __tstate = wxPyBeginAllowThreads();
26258 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
26259
26260 wxPyEndAllowThreads(__tstate);
26261 if (PyErr_Occurred()) SWIG_fail;
26262 }
26263 Py_INCREF(Py_None); resultobj = Py_None;
26264 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26265 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26266 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26267 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26268 return resultobj;
26269 fail:
26270 return NULL;
26271 }
26272
26273
26274 static PyObject *_wrap_Window_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
26275 PyObject *resultobj;
26276 wxWindow *arg1 = (wxWindow *) 0 ;
26277 wxRect result;
26278 PyObject * obj0 = 0 ;
26279 char *kwnames[] = {
26280 (char *) "self", NULL
26281 };
26282
26283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetRect",kwnames,&obj0)) goto fail;
26284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26285 if (SWIG_arg_fail(1)) SWIG_fail;
26286 {
26287 PyThreadState* __tstate = wxPyBeginAllowThreads();
26288 result = ((wxWindow const *)arg1)->GetRect();
26289
26290 wxPyEndAllowThreads(__tstate);
26291 if (PyErr_Occurred()) SWIG_fail;
26292 }
26293 {
26294 wxRect * resultptr;
26295 resultptr = new wxRect((wxRect &)(result));
26296 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26297 }
26298 return resultobj;
26299 fail:
26300 return NULL;
26301 }
26302
26303
26304 static PyObject *_wrap_Window_GetClientSize(PyObject *, PyObject *args, PyObject *kwargs) {
26305 PyObject *resultobj;
26306 wxWindow *arg1 = (wxWindow *) 0 ;
26307 wxSize result;
26308 PyObject * obj0 = 0 ;
26309 char *kwnames[] = {
26310 (char *) "self", NULL
26311 };
26312
26313 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSize",kwnames,&obj0)) goto fail;
26314 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26315 if (SWIG_arg_fail(1)) SWIG_fail;
26316 {
26317 PyThreadState* __tstate = wxPyBeginAllowThreads();
26318 result = ((wxWindow const *)arg1)->GetClientSize();
26319
26320 wxPyEndAllowThreads(__tstate);
26321 if (PyErr_Occurred()) SWIG_fail;
26322 }
26323 {
26324 wxSize * resultptr;
26325 resultptr = new wxSize((wxSize &)(result));
26326 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26327 }
26328 return resultobj;
26329 fail:
26330 return NULL;
26331 }
26332
26333
26334 static PyObject *_wrap_Window_GetClientSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26335 PyObject *resultobj;
26336 wxWindow *arg1 = (wxWindow *) 0 ;
26337 int *arg2 = (int *) 0 ;
26338 int *arg3 = (int *) 0 ;
26339 int temp2 ;
26340 int res2 = 0 ;
26341 int temp3 ;
26342 int res3 = 0 ;
26343 PyObject * obj0 = 0 ;
26344 char *kwnames[] = {
26345 (char *) "self", NULL
26346 };
26347
26348 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26349 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26350 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientSizeTuple",kwnames,&obj0)) goto fail;
26351 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26352 if (SWIG_arg_fail(1)) SWIG_fail;
26353 {
26354 PyThreadState* __tstate = wxPyBeginAllowThreads();
26355 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
26356
26357 wxPyEndAllowThreads(__tstate);
26358 if (PyErr_Occurred()) SWIG_fail;
26359 }
26360 Py_INCREF(Py_None); resultobj = Py_None;
26361 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26362 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26363 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26364 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26365 return resultobj;
26366 fail:
26367 return NULL;
26368 }
26369
26370
26371 static PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *, PyObject *args, PyObject *kwargs) {
26372 PyObject *resultobj;
26373 wxWindow *arg1 = (wxWindow *) 0 ;
26374 wxPoint result;
26375 PyObject * obj0 = 0 ;
26376 char *kwnames[] = {
26377 (char *) "self", NULL
26378 };
26379
26380 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientAreaOrigin",kwnames,&obj0)) goto fail;
26381 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26382 if (SWIG_arg_fail(1)) SWIG_fail;
26383 {
26384 PyThreadState* __tstate = wxPyBeginAllowThreads();
26385 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
26386
26387 wxPyEndAllowThreads(__tstate);
26388 if (PyErr_Occurred()) SWIG_fail;
26389 }
26390 {
26391 wxPoint * resultptr;
26392 resultptr = new wxPoint((wxPoint &)(result));
26393 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
26394 }
26395 return resultobj;
26396 fail:
26397 return NULL;
26398 }
26399
26400
26401 static PyObject *_wrap_Window_GetClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
26402 PyObject *resultobj;
26403 wxWindow *arg1 = (wxWindow *) 0 ;
26404 wxRect result;
26405 PyObject * obj0 = 0 ;
26406 char *kwnames[] = {
26407 (char *) "self", NULL
26408 };
26409
26410 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetClientRect",kwnames,&obj0)) goto fail;
26411 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26412 if (SWIG_arg_fail(1)) SWIG_fail;
26413 {
26414 PyThreadState* __tstate = wxPyBeginAllowThreads();
26415 result = ((wxWindow const *)arg1)->GetClientRect();
26416
26417 wxPyEndAllowThreads(__tstate);
26418 if (PyErr_Occurred()) SWIG_fail;
26419 }
26420 {
26421 wxRect * resultptr;
26422 resultptr = new wxRect((wxRect &)(result));
26423 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
26424 }
26425 return resultobj;
26426 fail:
26427 return NULL;
26428 }
26429
26430
26431 static PyObject *_wrap_Window_GetBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26432 PyObject *resultobj;
26433 wxWindow *arg1 = (wxWindow *) 0 ;
26434 wxSize result;
26435 PyObject * obj0 = 0 ;
26436 char *kwnames[] = {
26437 (char *) "self", NULL
26438 };
26439
26440 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSize",kwnames,&obj0)) goto fail;
26441 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26442 if (SWIG_arg_fail(1)) SWIG_fail;
26443 {
26444 PyThreadState* __tstate = wxPyBeginAllowThreads();
26445 result = ((wxWindow const *)arg1)->GetBestSize();
26446
26447 wxPyEndAllowThreads(__tstate);
26448 if (PyErr_Occurred()) SWIG_fail;
26449 }
26450 {
26451 wxSize * resultptr;
26452 resultptr = new wxSize((wxSize &)(result));
26453 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26454 }
26455 return resultobj;
26456 fail:
26457 return NULL;
26458 }
26459
26460
26461 static PyObject *_wrap_Window_GetBestSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
26462 PyObject *resultobj;
26463 wxWindow *arg1 = (wxWindow *) 0 ;
26464 int *arg2 = (int *) 0 ;
26465 int *arg3 = (int *) 0 ;
26466 int temp2 ;
26467 int res2 = 0 ;
26468 int temp3 ;
26469 int res3 = 0 ;
26470 PyObject * obj0 = 0 ;
26471 char *kwnames[] = {
26472 (char *) "self", NULL
26473 };
26474
26475 arg2 = &temp2; res2 = SWIG_NEWOBJ;
26476 arg3 = &temp3; res3 = SWIG_NEWOBJ;
26477 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestSizeTuple",kwnames,&obj0)) goto fail;
26478 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26479 if (SWIG_arg_fail(1)) SWIG_fail;
26480 {
26481 PyThreadState* __tstate = wxPyBeginAllowThreads();
26482 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
26483
26484 wxPyEndAllowThreads(__tstate);
26485 if (PyErr_Occurred()) SWIG_fail;
26486 }
26487 Py_INCREF(Py_None); resultobj = Py_None;
26488 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
26489 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
26490 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
26491 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
26492 return resultobj;
26493 fail:
26494 return NULL;
26495 }
26496
26497
26498 static PyObject *_wrap_Window_InvalidateBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26499 PyObject *resultobj;
26500 wxWindow *arg1 = (wxWindow *) 0 ;
26501 PyObject * obj0 = 0 ;
26502 char *kwnames[] = {
26503 (char *) "self", NULL
26504 };
26505
26506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InvalidateBestSize",kwnames,&obj0)) goto fail;
26507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26508 if (SWIG_arg_fail(1)) SWIG_fail;
26509 {
26510 PyThreadState* __tstate = wxPyBeginAllowThreads();
26511 (arg1)->InvalidateBestSize();
26512
26513 wxPyEndAllowThreads(__tstate);
26514 if (PyErr_Occurred()) SWIG_fail;
26515 }
26516 Py_INCREF(Py_None); resultobj = Py_None;
26517 return resultobj;
26518 fail:
26519 return NULL;
26520 }
26521
26522
26523 static PyObject *_wrap_Window_GetBestFittingSize(PyObject *, PyObject *args, PyObject *kwargs) {
26524 PyObject *resultobj;
26525 wxWindow *arg1 = (wxWindow *) 0 ;
26526 wxSize result;
26527 PyObject * obj0 = 0 ;
26528 char *kwnames[] = {
26529 (char *) "self", NULL
26530 };
26531
26532 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestFittingSize",kwnames,&obj0)) goto fail;
26533 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26534 if (SWIG_arg_fail(1)) SWIG_fail;
26535 {
26536 PyThreadState* __tstate = wxPyBeginAllowThreads();
26537 result = ((wxWindow const *)arg1)->GetBestFittingSize();
26538
26539 wxPyEndAllowThreads(__tstate);
26540 if (PyErr_Occurred()) SWIG_fail;
26541 }
26542 {
26543 wxSize * resultptr;
26544 resultptr = new wxSize((wxSize &)(result));
26545 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26546 }
26547 return resultobj;
26548 fail:
26549 return NULL;
26550 }
26551
26552
26553 static PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *, PyObject *args, PyObject *kwargs) {
26554 PyObject *resultobj;
26555 wxWindow *arg1 = (wxWindow *) 0 ;
26556 wxSize result;
26557 PyObject * obj0 = 0 ;
26558 char *kwnames[] = {
26559 (char *) "self", NULL
26560 };
26561
26562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAdjustedBestSize",kwnames,&obj0)) goto fail;
26563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26564 if (SWIG_arg_fail(1)) SWIG_fail;
26565 {
26566 PyThreadState* __tstate = wxPyBeginAllowThreads();
26567 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
26568
26569 wxPyEndAllowThreads(__tstate);
26570 if (PyErr_Occurred()) SWIG_fail;
26571 }
26572 {
26573 wxSize * resultptr;
26574 resultptr = new wxSize((wxSize &)(result));
26575 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26576 }
26577 return resultobj;
26578 fail:
26579 return NULL;
26580 }
26581
26582
26583 static PyObject *_wrap_Window_Center(PyObject *, PyObject *args, PyObject *kwargs) {
26584 PyObject *resultobj;
26585 wxWindow *arg1 = (wxWindow *) 0 ;
26586 int arg2 = (int) wxBOTH ;
26587 PyObject * obj0 = 0 ;
26588 PyObject * obj1 = 0 ;
26589 char *kwnames[] = {
26590 (char *) "self",(char *) "direction", NULL
26591 };
26592
26593 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) goto fail;
26594 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26595 if (SWIG_arg_fail(1)) SWIG_fail;
26596 if (obj1) {
26597 {
26598 arg2 = (int)(SWIG_As_int(obj1));
26599 if (SWIG_arg_fail(2)) SWIG_fail;
26600 }
26601 }
26602 {
26603 PyThreadState* __tstate = wxPyBeginAllowThreads();
26604 (arg1)->Center(arg2);
26605
26606 wxPyEndAllowThreads(__tstate);
26607 if (PyErr_Occurred()) SWIG_fail;
26608 }
26609 Py_INCREF(Py_None); resultobj = Py_None;
26610 return resultobj;
26611 fail:
26612 return NULL;
26613 }
26614
26615
26616 static PyObject *_wrap_Window_CenterOnScreen(PyObject *, PyObject *args, PyObject *kwargs) {
26617 PyObject *resultobj;
26618 wxWindow *arg1 = (wxWindow *) 0 ;
26619 int arg2 = (int) wxBOTH ;
26620 PyObject * obj0 = 0 ;
26621 PyObject * obj1 = 0 ;
26622 char *kwnames[] = {
26623 (char *) "self",(char *) "dir", NULL
26624 };
26625
26626 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnScreen",kwnames,&obj0,&obj1)) goto fail;
26627 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26628 if (SWIG_arg_fail(1)) SWIG_fail;
26629 if (obj1) {
26630 {
26631 arg2 = (int)(SWIG_As_int(obj1));
26632 if (SWIG_arg_fail(2)) SWIG_fail;
26633 }
26634 }
26635 {
26636 PyThreadState* __tstate = wxPyBeginAllowThreads();
26637 (arg1)->CenterOnScreen(arg2);
26638
26639 wxPyEndAllowThreads(__tstate);
26640 if (PyErr_Occurred()) SWIG_fail;
26641 }
26642 Py_INCREF(Py_None); resultobj = Py_None;
26643 return resultobj;
26644 fail:
26645 return NULL;
26646 }
26647
26648
26649 static PyObject *_wrap_Window_CenterOnParent(PyObject *, PyObject *args, PyObject *kwargs) {
26650 PyObject *resultobj;
26651 wxWindow *arg1 = (wxWindow *) 0 ;
26652 int arg2 = (int) wxBOTH ;
26653 PyObject * obj0 = 0 ;
26654 PyObject * obj1 = 0 ;
26655 char *kwnames[] = {
26656 (char *) "self",(char *) "dir", NULL
26657 };
26658
26659 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) goto fail;
26660 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26661 if (SWIG_arg_fail(1)) SWIG_fail;
26662 if (obj1) {
26663 {
26664 arg2 = (int)(SWIG_As_int(obj1));
26665 if (SWIG_arg_fail(2)) SWIG_fail;
26666 }
26667 }
26668 {
26669 PyThreadState* __tstate = wxPyBeginAllowThreads();
26670 (arg1)->CenterOnParent(arg2);
26671
26672 wxPyEndAllowThreads(__tstate);
26673 if (PyErr_Occurred()) SWIG_fail;
26674 }
26675 Py_INCREF(Py_None); resultobj = Py_None;
26676 return resultobj;
26677 fail:
26678 return NULL;
26679 }
26680
26681
26682 static PyObject *_wrap_Window_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
26683 PyObject *resultobj;
26684 wxWindow *arg1 = (wxWindow *) 0 ;
26685 PyObject * obj0 = 0 ;
26686 char *kwnames[] = {
26687 (char *) "self", NULL
26688 };
26689
26690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Fit",kwnames,&obj0)) goto fail;
26691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26692 if (SWIG_arg_fail(1)) SWIG_fail;
26693 {
26694 PyThreadState* __tstate = wxPyBeginAllowThreads();
26695 (arg1)->Fit();
26696
26697 wxPyEndAllowThreads(__tstate);
26698 if (PyErr_Occurred()) SWIG_fail;
26699 }
26700 Py_INCREF(Py_None); resultobj = Py_None;
26701 return resultobj;
26702 fail:
26703 return NULL;
26704 }
26705
26706
26707 static PyObject *_wrap_Window_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
26708 PyObject *resultobj;
26709 wxWindow *arg1 = (wxWindow *) 0 ;
26710 PyObject * obj0 = 0 ;
26711 char *kwnames[] = {
26712 (char *) "self", NULL
26713 };
26714
26715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_FitInside",kwnames,&obj0)) goto fail;
26716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26717 if (SWIG_arg_fail(1)) SWIG_fail;
26718 {
26719 PyThreadState* __tstate = wxPyBeginAllowThreads();
26720 (arg1)->FitInside();
26721
26722 wxPyEndAllowThreads(__tstate);
26723 if (PyErr_Occurred()) SWIG_fail;
26724 }
26725 Py_INCREF(Py_None); resultobj = Py_None;
26726 return resultobj;
26727 fail:
26728 return NULL;
26729 }
26730
26731
26732 static PyObject *_wrap_Window_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26733 PyObject *resultobj;
26734 wxWindow *arg1 = (wxWindow *) 0 ;
26735 int arg2 ;
26736 int arg3 ;
26737 int arg4 = (int) -1 ;
26738 int arg5 = (int) -1 ;
26739 int arg6 = (int) -1 ;
26740 int arg7 = (int) -1 ;
26741 PyObject * obj0 = 0 ;
26742 PyObject * obj1 = 0 ;
26743 PyObject * obj2 = 0 ;
26744 PyObject * obj3 = 0 ;
26745 PyObject * obj4 = 0 ;
26746 PyObject * obj5 = 0 ;
26747 PyObject * obj6 = 0 ;
26748 char *kwnames[] = {
26749 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
26750 };
26751
26752 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
26753 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26754 if (SWIG_arg_fail(1)) SWIG_fail;
26755 {
26756 arg2 = (int)(SWIG_As_int(obj1));
26757 if (SWIG_arg_fail(2)) SWIG_fail;
26758 }
26759 {
26760 arg3 = (int)(SWIG_As_int(obj2));
26761 if (SWIG_arg_fail(3)) SWIG_fail;
26762 }
26763 if (obj3) {
26764 {
26765 arg4 = (int)(SWIG_As_int(obj3));
26766 if (SWIG_arg_fail(4)) SWIG_fail;
26767 }
26768 }
26769 if (obj4) {
26770 {
26771 arg5 = (int)(SWIG_As_int(obj4));
26772 if (SWIG_arg_fail(5)) SWIG_fail;
26773 }
26774 }
26775 if (obj5) {
26776 {
26777 arg6 = (int)(SWIG_As_int(obj5));
26778 if (SWIG_arg_fail(6)) SWIG_fail;
26779 }
26780 }
26781 if (obj6) {
26782 {
26783 arg7 = (int)(SWIG_As_int(obj6));
26784 if (SWIG_arg_fail(7)) SWIG_fail;
26785 }
26786 }
26787 {
26788 PyThreadState* __tstate = wxPyBeginAllowThreads();
26789 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
26790
26791 wxPyEndAllowThreads(__tstate);
26792 if (PyErr_Occurred()) SWIG_fail;
26793 }
26794 Py_INCREF(Py_None); resultobj = Py_None;
26795 return resultobj;
26796 fail:
26797 return NULL;
26798 }
26799
26800
26801 static PyObject *_wrap_Window_SetSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26802 PyObject *resultobj;
26803 wxWindow *arg1 = (wxWindow *) 0 ;
26804 wxSize *arg2 = 0 ;
26805 wxSize const &arg3_defvalue = wxDefaultSize ;
26806 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26807 wxSize const &arg4_defvalue = wxDefaultSize ;
26808 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
26809 wxSize temp2 ;
26810 wxSize temp3 ;
26811 wxSize temp4 ;
26812 PyObject * obj0 = 0 ;
26813 PyObject * obj1 = 0 ;
26814 PyObject * obj2 = 0 ;
26815 PyObject * obj3 = 0 ;
26816 char *kwnames[] = {
26817 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
26818 };
26819
26820 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
26821 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26822 if (SWIG_arg_fail(1)) SWIG_fail;
26823 {
26824 arg2 = &temp2;
26825 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26826 }
26827 if (obj2) {
26828 {
26829 arg3 = &temp3;
26830 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26831 }
26832 }
26833 if (obj3) {
26834 {
26835 arg4 = &temp4;
26836 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
26837 }
26838 }
26839 {
26840 PyThreadState* __tstate = wxPyBeginAllowThreads();
26841 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
26842
26843 wxPyEndAllowThreads(__tstate);
26844 if (PyErr_Occurred()) SWIG_fail;
26845 }
26846 Py_INCREF(Py_None); resultobj = Py_None;
26847 return resultobj;
26848 fail:
26849 return NULL;
26850 }
26851
26852
26853 static PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
26854 PyObject *resultobj;
26855 wxWindow *arg1 = (wxWindow *) 0 ;
26856 int arg2 ;
26857 int arg3 ;
26858 int arg4 = (int) -1 ;
26859 int arg5 = (int) -1 ;
26860 PyObject * obj0 = 0 ;
26861 PyObject * obj1 = 0 ;
26862 PyObject * obj2 = 0 ;
26863 PyObject * obj3 = 0 ;
26864 PyObject * obj4 = 0 ;
26865 char *kwnames[] = {
26866 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
26867 };
26868
26869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
26870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26871 if (SWIG_arg_fail(1)) SWIG_fail;
26872 {
26873 arg2 = (int)(SWIG_As_int(obj1));
26874 if (SWIG_arg_fail(2)) SWIG_fail;
26875 }
26876 {
26877 arg3 = (int)(SWIG_As_int(obj2));
26878 if (SWIG_arg_fail(3)) SWIG_fail;
26879 }
26880 if (obj3) {
26881 {
26882 arg4 = (int)(SWIG_As_int(obj3));
26883 if (SWIG_arg_fail(4)) SWIG_fail;
26884 }
26885 }
26886 if (obj4) {
26887 {
26888 arg5 = (int)(SWIG_As_int(obj4));
26889 if (SWIG_arg_fail(5)) SWIG_fail;
26890 }
26891 }
26892 {
26893 PyThreadState* __tstate = wxPyBeginAllowThreads();
26894 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
26895
26896 wxPyEndAllowThreads(__tstate);
26897 if (PyErr_Occurred()) SWIG_fail;
26898 }
26899 Py_INCREF(Py_None); resultobj = Py_None;
26900 return resultobj;
26901 fail:
26902 return NULL;
26903 }
26904
26905
26906 static PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *, PyObject *args, PyObject *kwargs) {
26907 PyObject *resultobj;
26908 wxWindow *arg1 = (wxWindow *) 0 ;
26909 wxSize *arg2 = 0 ;
26910 wxSize const &arg3_defvalue = wxDefaultSize ;
26911 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
26912 wxSize temp2 ;
26913 wxSize temp3 ;
26914 PyObject * obj0 = 0 ;
26915 PyObject * obj1 = 0 ;
26916 PyObject * obj2 = 0 ;
26917 char *kwnames[] = {
26918 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
26919 };
26920
26921 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) goto fail;
26922 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26923 if (SWIG_arg_fail(1)) SWIG_fail;
26924 {
26925 arg2 = &temp2;
26926 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
26927 }
26928 if (obj2) {
26929 {
26930 arg3 = &temp3;
26931 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
26932 }
26933 }
26934 {
26935 PyThreadState* __tstate = wxPyBeginAllowThreads();
26936 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
26937
26938 wxPyEndAllowThreads(__tstate);
26939 if (PyErr_Occurred()) SWIG_fail;
26940 }
26941 Py_INCREF(Py_None); resultobj = Py_None;
26942 return resultobj;
26943 fail:
26944 return NULL;
26945 }
26946
26947
26948 static PyObject *_wrap_Window_GetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
26949 PyObject *resultobj;
26950 wxWindow *arg1 = (wxWindow *) 0 ;
26951 wxSize result;
26952 PyObject * obj0 = 0 ;
26953 char *kwnames[] = {
26954 (char *) "self", NULL
26955 };
26956
26957 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxSize",kwnames,&obj0)) goto fail;
26958 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26959 if (SWIG_arg_fail(1)) SWIG_fail;
26960 {
26961 PyThreadState* __tstate = wxPyBeginAllowThreads();
26962 result = ((wxWindow const *)arg1)->GetMaxSize();
26963
26964 wxPyEndAllowThreads(__tstate);
26965 if (PyErr_Occurred()) SWIG_fail;
26966 }
26967 {
26968 wxSize * resultptr;
26969 resultptr = new wxSize((wxSize &)(result));
26970 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
26971 }
26972 return resultobj;
26973 fail:
26974 return NULL;
26975 }
26976
26977
26978 static PyObject *_wrap_Window_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
26979 PyObject *resultobj;
26980 wxWindow *arg1 = (wxWindow *) 0 ;
26981 wxSize result;
26982 PyObject * obj0 = 0 ;
26983 char *kwnames[] = {
26984 (char *) "self", NULL
26985 };
26986
26987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinSize",kwnames,&obj0)) goto fail;
26988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
26989 if (SWIG_arg_fail(1)) SWIG_fail;
26990 {
26991 PyThreadState* __tstate = wxPyBeginAllowThreads();
26992 result = ((wxWindow const *)arg1)->GetMinSize();
26993
26994 wxPyEndAllowThreads(__tstate);
26995 if (PyErr_Occurred()) SWIG_fail;
26996 }
26997 {
26998 wxSize * resultptr;
26999 resultptr = new wxSize((wxSize &)(result));
27000 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27001 }
27002 return resultobj;
27003 fail:
27004 return NULL;
27005 }
27006
27007
27008 static PyObject *_wrap_Window_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
27009 PyObject *resultobj;
27010 wxWindow *arg1 = (wxWindow *) 0 ;
27011 wxSize *arg2 = 0 ;
27012 wxSize temp2 ;
27013 PyObject * obj0 = 0 ;
27014 PyObject * obj1 = 0 ;
27015 char *kwnames[] = {
27016 (char *) "self",(char *) "minSize", NULL
27017 };
27018
27019 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
27020 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27021 if (SWIG_arg_fail(1)) SWIG_fail;
27022 {
27023 arg2 = &temp2;
27024 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27025 }
27026 {
27027 PyThreadState* __tstate = wxPyBeginAllowThreads();
27028 (arg1)->SetMinSize((wxSize const &)*arg2);
27029
27030 wxPyEndAllowThreads(__tstate);
27031 if (PyErr_Occurred()) SWIG_fail;
27032 }
27033 Py_INCREF(Py_None); resultobj = Py_None;
27034 return resultobj;
27035 fail:
27036 return NULL;
27037 }
27038
27039
27040 static PyObject *_wrap_Window_SetMaxSize(PyObject *, PyObject *args, PyObject *kwargs) {
27041 PyObject *resultobj;
27042 wxWindow *arg1 = (wxWindow *) 0 ;
27043 wxSize *arg2 = 0 ;
27044 wxSize temp2 ;
27045 PyObject * obj0 = 0 ;
27046 PyObject * obj1 = 0 ;
27047 char *kwnames[] = {
27048 (char *) "self",(char *) "maxSize", NULL
27049 };
27050
27051 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) goto fail;
27052 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27053 if (SWIG_arg_fail(1)) SWIG_fail;
27054 {
27055 arg2 = &temp2;
27056 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27057 }
27058 {
27059 PyThreadState* __tstate = wxPyBeginAllowThreads();
27060 (arg1)->SetMaxSize((wxSize const &)*arg2);
27061
27062 wxPyEndAllowThreads(__tstate);
27063 if (PyErr_Occurred()) SWIG_fail;
27064 }
27065 Py_INCREF(Py_None); resultobj = Py_None;
27066 return resultobj;
27067 fail:
27068 return NULL;
27069 }
27070
27071
27072 static PyObject *_wrap_Window_GetMinWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27073 PyObject *resultobj;
27074 wxWindow *arg1 = (wxWindow *) 0 ;
27075 int result;
27076 PyObject * obj0 = 0 ;
27077 char *kwnames[] = {
27078 (char *) "self", NULL
27079 };
27080
27081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinWidth",kwnames,&obj0)) goto fail;
27082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27083 if (SWIG_arg_fail(1)) SWIG_fail;
27084 {
27085 PyThreadState* __tstate = wxPyBeginAllowThreads();
27086 result = (int)((wxWindow const *)arg1)->GetMinWidth();
27087
27088 wxPyEndAllowThreads(__tstate);
27089 if (PyErr_Occurred()) SWIG_fail;
27090 }
27091 {
27092 resultobj = SWIG_From_int((int)(result));
27093 }
27094 return resultobj;
27095 fail:
27096 return NULL;
27097 }
27098
27099
27100 static PyObject *_wrap_Window_GetMinHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27101 PyObject *resultobj;
27102 wxWindow *arg1 = (wxWindow *) 0 ;
27103 int result;
27104 PyObject * obj0 = 0 ;
27105 char *kwnames[] = {
27106 (char *) "self", NULL
27107 };
27108
27109 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMinHeight",kwnames,&obj0)) goto fail;
27110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27111 if (SWIG_arg_fail(1)) SWIG_fail;
27112 {
27113 PyThreadState* __tstate = wxPyBeginAllowThreads();
27114 result = (int)((wxWindow const *)arg1)->GetMinHeight();
27115
27116 wxPyEndAllowThreads(__tstate);
27117 if (PyErr_Occurred()) SWIG_fail;
27118 }
27119 {
27120 resultobj = SWIG_From_int((int)(result));
27121 }
27122 return resultobj;
27123 fail:
27124 return NULL;
27125 }
27126
27127
27128 static PyObject *_wrap_Window_GetMaxWidth(PyObject *, PyObject *args, PyObject *kwargs) {
27129 PyObject *resultobj;
27130 wxWindow *arg1 = (wxWindow *) 0 ;
27131 int result;
27132 PyObject * obj0 = 0 ;
27133 char *kwnames[] = {
27134 (char *) "self", NULL
27135 };
27136
27137 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxWidth",kwnames,&obj0)) goto fail;
27138 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27139 if (SWIG_arg_fail(1)) SWIG_fail;
27140 {
27141 PyThreadState* __tstate = wxPyBeginAllowThreads();
27142 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
27143
27144 wxPyEndAllowThreads(__tstate);
27145 if (PyErr_Occurred()) SWIG_fail;
27146 }
27147 {
27148 resultobj = SWIG_From_int((int)(result));
27149 }
27150 return resultobj;
27151 fail:
27152 return NULL;
27153 }
27154
27155
27156 static PyObject *_wrap_Window_GetMaxHeight(PyObject *, PyObject *args, PyObject *kwargs) {
27157 PyObject *resultobj;
27158 wxWindow *arg1 = (wxWindow *) 0 ;
27159 int result;
27160 PyObject * obj0 = 0 ;
27161 char *kwnames[] = {
27162 (char *) "self", NULL
27163 };
27164
27165 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetMaxHeight",kwnames,&obj0)) goto fail;
27166 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27167 if (SWIG_arg_fail(1)) SWIG_fail;
27168 {
27169 PyThreadState* __tstate = wxPyBeginAllowThreads();
27170 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
27171
27172 wxPyEndAllowThreads(__tstate);
27173 if (PyErr_Occurred()) SWIG_fail;
27174 }
27175 {
27176 resultobj = SWIG_From_int((int)(result));
27177 }
27178 return resultobj;
27179 fail:
27180 return NULL;
27181 }
27182
27183
27184 static PyObject *_wrap_Window_SetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27185 PyObject *resultobj;
27186 wxWindow *arg1 = (wxWindow *) 0 ;
27187 wxSize *arg2 = 0 ;
27188 wxSize temp2 ;
27189 PyObject * obj0 = 0 ;
27190 PyObject * obj1 = 0 ;
27191 char *kwnames[] = {
27192 (char *) "self",(char *) "size", NULL
27193 };
27194
27195 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) goto fail;
27196 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27197 if (SWIG_arg_fail(1)) SWIG_fail;
27198 {
27199 arg2 = &temp2;
27200 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
27201 }
27202 {
27203 PyThreadState* __tstate = wxPyBeginAllowThreads();
27204 (arg1)->SetVirtualSize((wxSize const &)*arg2);
27205
27206 wxPyEndAllowThreads(__tstate);
27207 if (PyErr_Occurred()) SWIG_fail;
27208 }
27209 Py_INCREF(Py_None); resultobj = Py_None;
27210 return resultobj;
27211 fail:
27212 return NULL;
27213 }
27214
27215
27216 static PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *, PyObject *args, PyObject *kwargs) {
27217 PyObject *resultobj;
27218 wxWindow *arg1 = (wxWindow *) 0 ;
27219 int arg2 ;
27220 int arg3 ;
27221 PyObject * obj0 = 0 ;
27222 PyObject * obj1 = 0 ;
27223 PyObject * obj2 = 0 ;
27224 char *kwnames[] = {
27225 (char *) "self",(char *) "w",(char *) "h", NULL
27226 };
27227
27228 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
27229 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27230 if (SWIG_arg_fail(1)) SWIG_fail;
27231 {
27232 arg2 = (int)(SWIG_As_int(obj1));
27233 if (SWIG_arg_fail(2)) SWIG_fail;
27234 }
27235 {
27236 arg3 = (int)(SWIG_As_int(obj2));
27237 if (SWIG_arg_fail(3)) SWIG_fail;
27238 }
27239 {
27240 PyThreadState* __tstate = wxPyBeginAllowThreads();
27241 (arg1)->SetVirtualSize(arg2,arg3);
27242
27243 wxPyEndAllowThreads(__tstate);
27244 if (PyErr_Occurred()) SWIG_fail;
27245 }
27246 Py_INCREF(Py_None); resultobj = Py_None;
27247 return resultobj;
27248 fail:
27249 return NULL;
27250 }
27251
27252
27253 static PyObject *_wrap_Window_GetVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27254 PyObject *resultobj;
27255 wxWindow *arg1 = (wxWindow *) 0 ;
27256 wxSize result;
27257 PyObject * obj0 = 0 ;
27258 char *kwnames[] = {
27259 (char *) "self", NULL
27260 };
27261
27262 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSize",kwnames,&obj0)) goto fail;
27263 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27264 if (SWIG_arg_fail(1)) SWIG_fail;
27265 {
27266 PyThreadState* __tstate = wxPyBeginAllowThreads();
27267 result = ((wxWindow const *)arg1)->GetVirtualSize();
27268
27269 wxPyEndAllowThreads(__tstate);
27270 if (PyErr_Occurred()) SWIG_fail;
27271 }
27272 {
27273 wxSize * resultptr;
27274 resultptr = new wxSize((wxSize &)(result));
27275 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27276 }
27277 return resultobj;
27278 fail:
27279 return NULL;
27280 }
27281
27282
27283 static PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *, PyObject *args, PyObject *kwargs) {
27284 PyObject *resultobj;
27285 wxWindow *arg1 = (wxWindow *) 0 ;
27286 int *arg2 = (int *) 0 ;
27287 int *arg3 = (int *) 0 ;
27288 int temp2 ;
27289 int res2 = 0 ;
27290 int temp3 ;
27291 int res3 = 0 ;
27292 PyObject * obj0 = 0 ;
27293 char *kwnames[] = {
27294 (char *) "self", NULL
27295 };
27296
27297 arg2 = &temp2; res2 = SWIG_NEWOBJ;
27298 arg3 = &temp3; res3 = SWIG_NEWOBJ;
27299 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetVirtualSizeTuple",kwnames,&obj0)) goto fail;
27300 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27301 if (SWIG_arg_fail(1)) SWIG_fail;
27302 {
27303 PyThreadState* __tstate = wxPyBeginAllowThreads();
27304 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
27305
27306 wxPyEndAllowThreads(__tstate);
27307 if (PyErr_Occurred()) SWIG_fail;
27308 }
27309 Py_INCREF(Py_None); resultobj = Py_None;
27310 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
27311 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
27312 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
27313 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
27314 return resultobj;
27315 fail:
27316 return NULL;
27317 }
27318
27319
27320 static PyObject *_wrap_Window_GetBestVirtualSize(PyObject *, PyObject *args, PyObject *kwargs) {
27321 PyObject *resultobj;
27322 wxWindow *arg1 = (wxWindow *) 0 ;
27323 wxSize result;
27324 PyObject * obj0 = 0 ;
27325 char *kwnames[] = {
27326 (char *) "self", NULL
27327 };
27328
27329 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBestVirtualSize",kwnames,&obj0)) goto fail;
27330 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27331 if (SWIG_arg_fail(1)) SWIG_fail;
27332 {
27333 PyThreadState* __tstate = wxPyBeginAllowThreads();
27334 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
27335
27336 wxPyEndAllowThreads(__tstate);
27337 if (PyErr_Occurred()) SWIG_fail;
27338 }
27339 {
27340 wxSize * resultptr;
27341 resultptr = new wxSize((wxSize &)(result));
27342 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
27343 }
27344 return resultobj;
27345 fail:
27346 return NULL;
27347 }
27348
27349
27350 static PyObject *_wrap_Window_Show(PyObject *, PyObject *args, PyObject *kwargs) {
27351 PyObject *resultobj;
27352 wxWindow *arg1 = (wxWindow *) 0 ;
27353 bool arg2 = (bool) true ;
27354 bool result;
27355 PyObject * obj0 = 0 ;
27356 PyObject * obj1 = 0 ;
27357 char *kwnames[] = {
27358 (char *) "self",(char *) "show", NULL
27359 };
27360
27361 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) goto fail;
27362 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27363 if (SWIG_arg_fail(1)) SWIG_fail;
27364 if (obj1) {
27365 {
27366 arg2 = (bool)(SWIG_As_bool(obj1));
27367 if (SWIG_arg_fail(2)) SWIG_fail;
27368 }
27369 }
27370 {
27371 PyThreadState* __tstate = wxPyBeginAllowThreads();
27372 result = (bool)(arg1)->Show(arg2);
27373
27374 wxPyEndAllowThreads(__tstate);
27375 if (PyErr_Occurred()) SWIG_fail;
27376 }
27377 {
27378 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27379 }
27380 return resultobj;
27381 fail:
27382 return NULL;
27383 }
27384
27385
27386 static PyObject *_wrap_Window_Hide(PyObject *, PyObject *args, PyObject *kwargs) {
27387 PyObject *resultobj;
27388 wxWindow *arg1 = (wxWindow *) 0 ;
27389 bool result;
27390 PyObject * obj0 = 0 ;
27391 char *kwnames[] = {
27392 (char *) "self", NULL
27393 };
27394
27395 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Hide",kwnames,&obj0)) goto fail;
27396 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27397 if (SWIG_arg_fail(1)) SWIG_fail;
27398 {
27399 PyThreadState* __tstate = wxPyBeginAllowThreads();
27400 result = (bool)(arg1)->Hide();
27401
27402 wxPyEndAllowThreads(__tstate);
27403 if (PyErr_Occurred()) SWIG_fail;
27404 }
27405 {
27406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27407 }
27408 return resultobj;
27409 fail:
27410 return NULL;
27411 }
27412
27413
27414 static PyObject *_wrap_Window_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
27415 PyObject *resultobj;
27416 wxWindow *arg1 = (wxWindow *) 0 ;
27417 bool arg2 = (bool) true ;
27418 bool result;
27419 PyObject * obj0 = 0 ;
27420 PyObject * obj1 = 0 ;
27421 char *kwnames[] = {
27422 (char *) "self",(char *) "enable", NULL
27423 };
27424
27425 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) goto fail;
27426 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27427 if (SWIG_arg_fail(1)) SWIG_fail;
27428 if (obj1) {
27429 {
27430 arg2 = (bool)(SWIG_As_bool(obj1));
27431 if (SWIG_arg_fail(2)) SWIG_fail;
27432 }
27433 }
27434 {
27435 PyThreadState* __tstate = wxPyBeginAllowThreads();
27436 result = (bool)(arg1)->Enable(arg2);
27437
27438 wxPyEndAllowThreads(__tstate);
27439 if (PyErr_Occurred()) SWIG_fail;
27440 }
27441 {
27442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27443 }
27444 return resultobj;
27445 fail:
27446 return NULL;
27447 }
27448
27449
27450 static PyObject *_wrap_Window_Disable(PyObject *, PyObject *args, PyObject *kwargs) {
27451 PyObject *resultobj;
27452 wxWindow *arg1 = (wxWindow *) 0 ;
27453 bool result;
27454 PyObject * obj0 = 0 ;
27455 char *kwnames[] = {
27456 (char *) "self", NULL
27457 };
27458
27459 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Disable",kwnames,&obj0)) goto fail;
27460 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27461 if (SWIG_arg_fail(1)) SWIG_fail;
27462 {
27463 PyThreadState* __tstate = wxPyBeginAllowThreads();
27464 result = (bool)(arg1)->Disable();
27465
27466 wxPyEndAllowThreads(__tstate);
27467 if (PyErr_Occurred()) SWIG_fail;
27468 }
27469 {
27470 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27471 }
27472 return resultobj;
27473 fail:
27474 return NULL;
27475 }
27476
27477
27478 static PyObject *_wrap_Window_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
27479 PyObject *resultobj;
27480 wxWindow *arg1 = (wxWindow *) 0 ;
27481 bool result;
27482 PyObject * obj0 = 0 ;
27483 char *kwnames[] = {
27484 (char *) "self", NULL
27485 };
27486
27487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsShown",kwnames,&obj0)) goto fail;
27488 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27489 if (SWIG_arg_fail(1)) SWIG_fail;
27490 {
27491 PyThreadState* __tstate = wxPyBeginAllowThreads();
27492 result = (bool)((wxWindow const *)arg1)->IsShown();
27493
27494 wxPyEndAllowThreads(__tstate);
27495 if (PyErr_Occurred()) SWIG_fail;
27496 }
27497 {
27498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27499 }
27500 return resultobj;
27501 fail:
27502 return NULL;
27503 }
27504
27505
27506 static PyObject *_wrap_Window_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27507 PyObject *resultobj;
27508 wxWindow *arg1 = (wxWindow *) 0 ;
27509 bool result;
27510 PyObject * obj0 = 0 ;
27511 char *kwnames[] = {
27512 (char *) "self", NULL
27513 };
27514
27515 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsEnabled",kwnames,&obj0)) goto fail;
27516 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27517 if (SWIG_arg_fail(1)) SWIG_fail;
27518 {
27519 PyThreadState* __tstate = wxPyBeginAllowThreads();
27520 result = (bool)((wxWindow const *)arg1)->IsEnabled();
27521
27522 wxPyEndAllowThreads(__tstate);
27523 if (PyErr_Occurred()) SWIG_fail;
27524 }
27525 {
27526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27527 }
27528 return resultobj;
27529 fail:
27530 return NULL;
27531 }
27532
27533
27534 static PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27535 PyObject *resultobj;
27536 wxWindow *arg1 = (wxWindow *) 0 ;
27537 long arg2 ;
27538 PyObject * obj0 = 0 ;
27539 PyObject * obj1 = 0 ;
27540 char *kwnames[] = {
27541 (char *) "self",(char *) "style", NULL
27542 };
27543
27544 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) goto fail;
27545 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27546 if (SWIG_arg_fail(1)) SWIG_fail;
27547 {
27548 arg2 = (long)(SWIG_As_long(obj1));
27549 if (SWIG_arg_fail(2)) SWIG_fail;
27550 }
27551 {
27552 PyThreadState* __tstate = wxPyBeginAllowThreads();
27553 (arg1)->SetWindowStyleFlag(arg2);
27554
27555 wxPyEndAllowThreads(__tstate);
27556 if (PyErr_Occurred()) SWIG_fail;
27557 }
27558 Py_INCREF(Py_None); resultobj = Py_None;
27559 return resultobj;
27560 fail:
27561 return NULL;
27562 }
27563
27564
27565 static PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27566 PyObject *resultobj;
27567 wxWindow *arg1 = (wxWindow *) 0 ;
27568 long result;
27569 PyObject * obj0 = 0 ;
27570 char *kwnames[] = {
27571 (char *) "self", NULL
27572 };
27573
27574 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetWindowStyleFlag",kwnames,&obj0)) goto fail;
27575 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27576 if (SWIG_arg_fail(1)) SWIG_fail;
27577 {
27578 PyThreadState* __tstate = wxPyBeginAllowThreads();
27579 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
27580
27581 wxPyEndAllowThreads(__tstate);
27582 if (PyErr_Occurred()) SWIG_fail;
27583 }
27584 {
27585 resultobj = SWIG_From_long((long)(result));
27586 }
27587 return resultobj;
27588 fail:
27589 return NULL;
27590 }
27591
27592
27593 static PyObject *_wrap_Window_HasFlag(PyObject *, PyObject *args, PyObject *kwargs) {
27594 PyObject *resultobj;
27595 wxWindow *arg1 = (wxWindow *) 0 ;
27596 int arg2 ;
27597 bool result;
27598 PyObject * obj0 = 0 ;
27599 PyObject * obj1 = 0 ;
27600 char *kwnames[] = {
27601 (char *) "self",(char *) "flag", NULL
27602 };
27603
27604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) goto fail;
27605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27606 if (SWIG_arg_fail(1)) SWIG_fail;
27607 {
27608 arg2 = (int)(SWIG_As_int(obj1));
27609 if (SWIG_arg_fail(2)) SWIG_fail;
27610 }
27611 {
27612 PyThreadState* __tstate = wxPyBeginAllowThreads();
27613 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
27614
27615 wxPyEndAllowThreads(__tstate);
27616 if (PyErr_Occurred()) SWIG_fail;
27617 }
27618 {
27619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27620 }
27621 return resultobj;
27622 fail:
27623 return NULL;
27624 }
27625
27626
27627 static PyObject *_wrap_Window_IsRetained(PyObject *, PyObject *args, PyObject *kwargs) {
27628 PyObject *resultobj;
27629 wxWindow *arg1 = (wxWindow *) 0 ;
27630 bool result;
27631 PyObject * obj0 = 0 ;
27632 char *kwnames[] = {
27633 (char *) "self", NULL
27634 };
27635
27636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsRetained",kwnames,&obj0)) goto fail;
27637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27638 if (SWIG_arg_fail(1)) SWIG_fail;
27639 {
27640 PyThreadState* __tstate = wxPyBeginAllowThreads();
27641 result = (bool)((wxWindow const *)arg1)->IsRetained();
27642
27643 wxPyEndAllowThreads(__tstate);
27644 if (PyErr_Occurred()) SWIG_fail;
27645 }
27646 {
27647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27648 }
27649 return resultobj;
27650 fail:
27651 return NULL;
27652 }
27653
27654
27655 static PyObject *_wrap_Window_SetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27656 PyObject *resultobj;
27657 wxWindow *arg1 = (wxWindow *) 0 ;
27658 long arg2 ;
27659 PyObject * obj0 = 0 ;
27660 PyObject * obj1 = 0 ;
27661 char *kwnames[] = {
27662 (char *) "self",(char *) "exStyle", NULL
27663 };
27664
27665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) goto fail;
27666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27667 if (SWIG_arg_fail(1)) SWIG_fail;
27668 {
27669 arg2 = (long)(SWIG_As_long(obj1));
27670 if (SWIG_arg_fail(2)) SWIG_fail;
27671 }
27672 {
27673 PyThreadState* __tstate = wxPyBeginAllowThreads();
27674 (arg1)->SetExtraStyle(arg2);
27675
27676 wxPyEndAllowThreads(__tstate);
27677 if (PyErr_Occurred()) SWIG_fail;
27678 }
27679 Py_INCREF(Py_None); resultobj = Py_None;
27680 return resultobj;
27681 fail:
27682 return NULL;
27683 }
27684
27685
27686 static PyObject *_wrap_Window_GetExtraStyle(PyObject *, PyObject *args, PyObject *kwargs) {
27687 PyObject *resultobj;
27688 wxWindow *arg1 = (wxWindow *) 0 ;
27689 long result;
27690 PyObject * obj0 = 0 ;
27691 char *kwnames[] = {
27692 (char *) "self", NULL
27693 };
27694
27695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetExtraStyle",kwnames,&obj0)) goto fail;
27696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27697 if (SWIG_arg_fail(1)) SWIG_fail;
27698 {
27699 PyThreadState* __tstate = wxPyBeginAllowThreads();
27700 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
27701
27702 wxPyEndAllowThreads(__tstate);
27703 if (PyErr_Occurred()) SWIG_fail;
27704 }
27705 {
27706 resultobj = SWIG_From_long((long)(result));
27707 }
27708 return resultobj;
27709 fail:
27710 return NULL;
27711 }
27712
27713
27714 static PyObject *_wrap_Window_MakeModal(PyObject *, PyObject *args, PyObject *kwargs) {
27715 PyObject *resultobj;
27716 wxWindow *arg1 = (wxWindow *) 0 ;
27717 bool arg2 = (bool) true ;
27718 PyObject * obj0 = 0 ;
27719 PyObject * obj1 = 0 ;
27720 char *kwnames[] = {
27721 (char *) "self",(char *) "modal", NULL
27722 };
27723
27724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) goto fail;
27725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27726 if (SWIG_arg_fail(1)) SWIG_fail;
27727 if (obj1) {
27728 {
27729 arg2 = (bool)(SWIG_As_bool(obj1));
27730 if (SWIG_arg_fail(2)) SWIG_fail;
27731 }
27732 }
27733 {
27734 PyThreadState* __tstate = wxPyBeginAllowThreads();
27735 (arg1)->MakeModal(arg2);
27736
27737 wxPyEndAllowThreads(__tstate);
27738 if (PyErr_Occurred()) SWIG_fail;
27739 }
27740 Py_INCREF(Py_None); resultobj = Py_None;
27741 return resultobj;
27742 fail:
27743 return NULL;
27744 }
27745
27746
27747 static PyObject *_wrap_Window_SetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27748 PyObject *resultobj;
27749 wxWindow *arg1 = (wxWindow *) 0 ;
27750 bool arg2 ;
27751 PyObject * obj0 = 0 ;
27752 PyObject * obj1 = 0 ;
27753 char *kwnames[] = {
27754 (char *) "self",(char *) "enableTheme", NULL
27755 };
27756
27757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) goto fail;
27758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27759 if (SWIG_arg_fail(1)) SWIG_fail;
27760 {
27761 arg2 = (bool)(SWIG_As_bool(obj1));
27762 if (SWIG_arg_fail(2)) SWIG_fail;
27763 }
27764 {
27765 PyThreadState* __tstate = wxPyBeginAllowThreads();
27766 (arg1)->SetThemeEnabled(arg2);
27767
27768 wxPyEndAllowThreads(__tstate);
27769 if (PyErr_Occurred()) SWIG_fail;
27770 }
27771 Py_INCREF(Py_None); resultobj = Py_None;
27772 return resultobj;
27773 fail:
27774 return NULL;
27775 }
27776
27777
27778 static PyObject *_wrap_Window_GetThemeEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
27779 PyObject *resultobj;
27780 wxWindow *arg1 = (wxWindow *) 0 ;
27781 bool result;
27782 PyObject * obj0 = 0 ;
27783 char *kwnames[] = {
27784 (char *) "self", NULL
27785 };
27786
27787 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetThemeEnabled",kwnames,&obj0)) goto fail;
27788 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27789 if (SWIG_arg_fail(1)) SWIG_fail;
27790 {
27791 PyThreadState* __tstate = wxPyBeginAllowThreads();
27792 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
27793
27794 wxPyEndAllowThreads(__tstate);
27795 if (PyErr_Occurred()) SWIG_fail;
27796 }
27797 {
27798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27799 }
27800 return resultobj;
27801 fail:
27802 return NULL;
27803 }
27804
27805
27806 static PyObject *_wrap_Window_SetFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27807 PyObject *resultobj;
27808 wxWindow *arg1 = (wxWindow *) 0 ;
27809 PyObject * obj0 = 0 ;
27810 char *kwnames[] = {
27811 (char *) "self", NULL
27812 };
27813
27814 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocus",kwnames,&obj0)) goto fail;
27815 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27816 if (SWIG_arg_fail(1)) SWIG_fail;
27817 {
27818 PyThreadState* __tstate = wxPyBeginAllowThreads();
27819 (arg1)->SetFocus();
27820
27821 wxPyEndAllowThreads(__tstate);
27822 if (PyErr_Occurred()) SWIG_fail;
27823 }
27824 Py_INCREF(Py_None); resultobj = Py_None;
27825 return resultobj;
27826 fail:
27827 return NULL;
27828 }
27829
27830
27831 static PyObject *_wrap_Window_SetFocusFromKbd(PyObject *, PyObject *args, PyObject *kwargs) {
27832 PyObject *resultobj;
27833 wxWindow *arg1 = (wxWindow *) 0 ;
27834 PyObject * obj0 = 0 ;
27835 char *kwnames[] = {
27836 (char *) "self", NULL
27837 };
27838
27839 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_SetFocusFromKbd",kwnames,&obj0)) goto fail;
27840 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27841 if (SWIG_arg_fail(1)) SWIG_fail;
27842 {
27843 PyThreadState* __tstate = wxPyBeginAllowThreads();
27844 (arg1)->SetFocusFromKbd();
27845
27846 wxPyEndAllowThreads(__tstate);
27847 if (PyErr_Occurred()) SWIG_fail;
27848 }
27849 Py_INCREF(Py_None); resultobj = Py_None;
27850 return resultobj;
27851 fail:
27852 return NULL;
27853 }
27854
27855
27856 static PyObject *_wrap_Window_FindFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27857 PyObject *resultobj;
27858 wxWindow *result;
27859 char *kwnames[] = {
27860 NULL
27861 };
27862
27863 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_FindFocus",kwnames)) goto fail;
27864 {
27865 if (!wxPyCheckForApp()) SWIG_fail;
27866 PyThreadState* __tstate = wxPyBeginAllowThreads();
27867 result = (wxWindow *)wxWindow::FindFocus();
27868
27869 wxPyEndAllowThreads(__tstate);
27870 if (PyErr_Occurred()) SWIG_fail;
27871 }
27872 {
27873 resultobj = wxPyMake_wxObject(result, 0);
27874 }
27875 return resultobj;
27876 fail:
27877 return NULL;
27878 }
27879
27880
27881 static PyObject *_wrap_Window_AcceptsFocus(PyObject *, PyObject *args, PyObject *kwargs) {
27882 PyObject *resultobj;
27883 wxWindow *arg1 = (wxWindow *) 0 ;
27884 bool result;
27885 PyObject * obj0 = 0 ;
27886 char *kwnames[] = {
27887 (char *) "self", NULL
27888 };
27889
27890 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocus",kwnames,&obj0)) goto fail;
27891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27892 if (SWIG_arg_fail(1)) SWIG_fail;
27893 {
27894 PyThreadState* __tstate = wxPyBeginAllowThreads();
27895 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
27896
27897 wxPyEndAllowThreads(__tstate);
27898 if (PyErr_Occurred()) SWIG_fail;
27899 }
27900 {
27901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27902 }
27903 return resultobj;
27904 fail:
27905 return NULL;
27906 }
27907
27908
27909 static PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *, PyObject *args, PyObject *kwargs) {
27910 PyObject *resultobj;
27911 wxWindow *arg1 = (wxWindow *) 0 ;
27912 bool result;
27913 PyObject * obj0 = 0 ;
27914 char *kwnames[] = {
27915 (char *) "self", NULL
27916 };
27917
27918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_AcceptsFocusFromKeyboard",kwnames,&obj0)) goto fail;
27919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27920 if (SWIG_arg_fail(1)) SWIG_fail;
27921 {
27922 PyThreadState* __tstate = wxPyBeginAllowThreads();
27923 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
27924
27925 wxPyEndAllowThreads(__tstate);
27926 if (PyErr_Occurred()) SWIG_fail;
27927 }
27928 {
27929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27930 }
27931 return resultobj;
27932 fail:
27933 return NULL;
27934 }
27935
27936
27937 static PyObject *_wrap_Window_GetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27938 PyObject *resultobj;
27939 wxWindow *arg1 = (wxWindow *) 0 ;
27940 wxWindow *result;
27941 PyObject * obj0 = 0 ;
27942 char *kwnames[] = {
27943 (char *) "self", NULL
27944 };
27945
27946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultItem",kwnames,&obj0)) goto fail;
27947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27948 if (SWIG_arg_fail(1)) SWIG_fail;
27949 {
27950 PyThreadState* __tstate = wxPyBeginAllowThreads();
27951 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
27952
27953 wxPyEndAllowThreads(__tstate);
27954 if (PyErr_Occurred()) SWIG_fail;
27955 }
27956 {
27957 resultobj = wxPyMake_wxObject(result, 0);
27958 }
27959 return resultobj;
27960 fail:
27961 return NULL;
27962 }
27963
27964
27965 static PyObject *_wrap_Window_SetDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27966 PyObject *resultobj;
27967 wxWindow *arg1 = (wxWindow *) 0 ;
27968 wxWindow *arg2 = (wxWindow *) 0 ;
27969 wxWindow *result;
27970 PyObject * obj0 = 0 ;
27971 PyObject * obj1 = 0 ;
27972 char *kwnames[] = {
27973 (char *) "self",(char *) "child", NULL
27974 };
27975
27976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) goto fail;
27977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27978 if (SWIG_arg_fail(1)) SWIG_fail;
27979 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
27980 if (SWIG_arg_fail(2)) SWIG_fail;
27981 {
27982 PyThreadState* __tstate = wxPyBeginAllowThreads();
27983 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
27984
27985 wxPyEndAllowThreads(__tstate);
27986 if (PyErr_Occurred()) SWIG_fail;
27987 }
27988 {
27989 resultobj = wxPyMake_wxObject(result, 0);
27990 }
27991 return resultobj;
27992 fail:
27993 return NULL;
27994 }
27995
27996
27997 static PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *, PyObject *args, PyObject *kwargs) {
27998 PyObject *resultobj;
27999 wxWindow *arg1 = (wxWindow *) 0 ;
28000 wxWindow *arg2 = (wxWindow *) 0 ;
28001 PyObject * obj0 = 0 ;
28002 PyObject * obj1 = 0 ;
28003 char *kwnames[] = {
28004 (char *) "self",(char *) "win", NULL
28005 };
28006
28007 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) goto fail;
28008 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28009 if (SWIG_arg_fail(1)) SWIG_fail;
28010 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28011 if (SWIG_arg_fail(2)) SWIG_fail;
28012 {
28013 PyThreadState* __tstate = wxPyBeginAllowThreads();
28014 (arg1)->SetTmpDefaultItem(arg2);
28015
28016 wxPyEndAllowThreads(__tstate);
28017 if (PyErr_Occurred()) SWIG_fail;
28018 }
28019 Py_INCREF(Py_None); resultobj = Py_None;
28020 return resultobj;
28021 fail:
28022 return NULL;
28023 }
28024
28025
28026 static PyObject *_wrap_Window_Navigate(PyObject *, PyObject *args, PyObject *kwargs) {
28027 PyObject *resultobj;
28028 wxWindow *arg1 = (wxWindow *) 0 ;
28029 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
28030 bool result;
28031 PyObject * obj0 = 0 ;
28032 PyObject * obj1 = 0 ;
28033 char *kwnames[] = {
28034 (char *) "self",(char *) "flags", NULL
28035 };
28036
28037 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) goto fail;
28038 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28039 if (SWIG_arg_fail(1)) SWIG_fail;
28040 if (obj1) {
28041 {
28042 arg2 = (int)(SWIG_As_int(obj1));
28043 if (SWIG_arg_fail(2)) SWIG_fail;
28044 }
28045 }
28046 {
28047 PyThreadState* __tstate = wxPyBeginAllowThreads();
28048 result = (bool)(arg1)->Navigate(arg2);
28049
28050 wxPyEndAllowThreads(__tstate);
28051 if (PyErr_Occurred()) SWIG_fail;
28052 }
28053 {
28054 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28055 }
28056 return resultobj;
28057 fail:
28058 return NULL;
28059 }
28060
28061
28062 static PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28063 PyObject *resultobj;
28064 wxWindow *arg1 = (wxWindow *) 0 ;
28065 wxWindow *arg2 = (wxWindow *) 0 ;
28066 PyObject * obj0 = 0 ;
28067 PyObject * obj1 = 0 ;
28068 char *kwnames[] = {
28069 (char *) "self",(char *) "win", NULL
28070 };
28071
28072 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28073 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28074 if (SWIG_arg_fail(1)) SWIG_fail;
28075 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28076 if (SWIG_arg_fail(2)) SWIG_fail;
28077 {
28078 PyThreadState* __tstate = wxPyBeginAllowThreads();
28079 (arg1)->MoveAfterInTabOrder(arg2);
28080
28081 wxPyEndAllowThreads(__tstate);
28082 if (PyErr_Occurred()) SWIG_fail;
28083 }
28084 Py_INCREF(Py_None); resultobj = Py_None;
28085 return resultobj;
28086 fail:
28087 return NULL;
28088 }
28089
28090
28091 static PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *, PyObject *args, PyObject *kwargs) {
28092 PyObject *resultobj;
28093 wxWindow *arg1 = (wxWindow *) 0 ;
28094 wxWindow *arg2 = (wxWindow *) 0 ;
28095 PyObject * obj0 = 0 ;
28096 PyObject * obj1 = 0 ;
28097 char *kwnames[] = {
28098 (char *) "self",(char *) "win", NULL
28099 };
28100
28101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) goto fail;
28102 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28103 if (SWIG_arg_fail(1)) SWIG_fail;
28104 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28105 if (SWIG_arg_fail(2)) SWIG_fail;
28106 {
28107 PyThreadState* __tstate = wxPyBeginAllowThreads();
28108 (arg1)->MoveBeforeInTabOrder(arg2);
28109
28110 wxPyEndAllowThreads(__tstate);
28111 if (PyErr_Occurred()) SWIG_fail;
28112 }
28113 Py_INCREF(Py_None); resultobj = Py_None;
28114 return resultobj;
28115 fail:
28116 return NULL;
28117 }
28118
28119
28120 static PyObject *_wrap_Window_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
28121 PyObject *resultobj;
28122 wxWindow *arg1 = (wxWindow *) 0 ;
28123 PyObject *result;
28124 PyObject * obj0 = 0 ;
28125 char *kwnames[] = {
28126 (char *) "self", NULL
28127 };
28128
28129 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetChildren",kwnames,&obj0)) goto fail;
28130 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28131 if (SWIG_arg_fail(1)) SWIG_fail;
28132 {
28133 PyThreadState* __tstate = wxPyBeginAllowThreads();
28134 result = (PyObject *)wxWindow_GetChildren(arg1);
28135
28136 wxPyEndAllowThreads(__tstate);
28137 if (PyErr_Occurred()) SWIG_fail;
28138 }
28139 resultobj = result;
28140 return resultobj;
28141 fail:
28142 return NULL;
28143 }
28144
28145
28146 static PyObject *_wrap_Window_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
28147 PyObject *resultobj;
28148 wxWindow *arg1 = (wxWindow *) 0 ;
28149 wxWindow *result;
28150 PyObject * obj0 = 0 ;
28151 char *kwnames[] = {
28152 (char *) "self", NULL
28153 };
28154
28155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetParent",kwnames,&obj0)) goto fail;
28156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28157 if (SWIG_arg_fail(1)) SWIG_fail;
28158 {
28159 PyThreadState* __tstate = wxPyBeginAllowThreads();
28160 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
28161
28162 wxPyEndAllowThreads(__tstate);
28163 if (PyErr_Occurred()) SWIG_fail;
28164 }
28165 {
28166 resultobj = wxPyMake_wxObject(result, 0);
28167 }
28168 return resultobj;
28169 fail:
28170 return NULL;
28171 }
28172
28173
28174 static PyObject *_wrap_Window_GetGrandParent(PyObject *, PyObject *args, PyObject *kwargs) {
28175 PyObject *resultobj;
28176 wxWindow *arg1 = (wxWindow *) 0 ;
28177 wxWindow *result;
28178 PyObject * obj0 = 0 ;
28179 char *kwnames[] = {
28180 (char *) "self", NULL
28181 };
28182
28183 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetGrandParent",kwnames,&obj0)) goto fail;
28184 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28185 if (SWIG_arg_fail(1)) SWIG_fail;
28186 {
28187 PyThreadState* __tstate = wxPyBeginAllowThreads();
28188 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
28189
28190 wxPyEndAllowThreads(__tstate);
28191 if (PyErr_Occurred()) SWIG_fail;
28192 }
28193 {
28194 resultobj = wxPyMake_wxObject(result, 0);
28195 }
28196 return resultobj;
28197 fail:
28198 return NULL;
28199 }
28200
28201
28202 static PyObject *_wrap_Window_IsTopLevel(PyObject *, PyObject *args, PyObject *kwargs) {
28203 PyObject *resultobj;
28204 wxWindow *arg1 = (wxWindow *) 0 ;
28205 bool result;
28206 PyObject * obj0 = 0 ;
28207 char *kwnames[] = {
28208 (char *) "self", NULL
28209 };
28210
28211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_IsTopLevel",kwnames,&obj0)) goto fail;
28212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28213 if (SWIG_arg_fail(1)) SWIG_fail;
28214 {
28215 PyThreadState* __tstate = wxPyBeginAllowThreads();
28216 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
28217
28218 wxPyEndAllowThreads(__tstate);
28219 if (PyErr_Occurred()) SWIG_fail;
28220 }
28221 {
28222 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28223 }
28224 return resultobj;
28225 fail:
28226 return NULL;
28227 }
28228
28229
28230 static PyObject *_wrap_Window_Reparent(PyObject *, PyObject *args, PyObject *kwargs) {
28231 PyObject *resultobj;
28232 wxWindow *arg1 = (wxWindow *) 0 ;
28233 wxWindow *arg2 = (wxWindow *) 0 ;
28234 bool result;
28235 PyObject * obj0 = 0 ;
28236 PyObject * obj1 = 0 ;
28237 char *kwnames[] = {
28238 (char *) "self",(char *) "newParent", NULL
28239 };
28240
28241 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) goto fail;
28242 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28243 if (SWIG_arg_fail(1)) SWIG_fail;
28244 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28245 if (SWIG_arg_fail(2)) SWIG_fail;
28246 {
28247 PyThreadState* __tstate = wxPyBeginAllowThreads();
28248 result = (bool)(arg1)->Reparent(arg2);
28249
28250 wxPyEndAllowThreads(__tstate);
28251 if (PyErr_Occurred()) SWIG_fail;
28252 }
28253 {
28254 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28255 }
28256 return resultobj;
28257 fail:
28258 return NULL;
28259 }
28260
28261
28262 static PyObject *_wrap_Window_AddChild(PyObject *, PyObject *args, PyObject *kwargs) {
28263 PyObject *resultobj;
28264 wxWindow *arg1 = (wxWindow *) 0 ;
28265 wxWindow *arg2 = (wxWindow *) 0 ;
28266 PyObject * obj0 = 0 ;
28267 PyObject * obj1 = 0 ;
28268 char *kwnames[] = {
28269 (char *) "self",(char *) "child", NULL
28270 };
28271
28272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) goto fail;
28273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28274 if (SWIG_arg_fail(1)) SWIG_fail;
28275 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28276 if (SWIG_arg_fail(2)) SWIG_fail;
28277 {
28278 PyThreadState* __tstate = wxPyBeginAllowThreads();
28279 (arg1)->AddChild(arg2);
28280
28281 wxPyEndAllowThreads(__tstate);
28282 if (PyErr_Occurred()) SWIG_fail;
28283 }
28284 Py_INCREF(Py_None); resultobj = Py_None;
28285 return resultobj;
28286 fail:
28287 return NULL;
28288 }
28289
28290
28291 static PyObject *_wrap_Window_RemoveChild(PyObject *, PyObject *args, PyObject *kwargs) {
28292 PyObject *resultobj;
28293 wxWindow *arg1 = (wxWindow *) 0 ;
28294 wxWindow *arg2 = (wxWindow *) 0 ;
28295 PyObject * obj0 = 0 ;
28296 PyObject * obj1 = 0 ;
28297 char *kwnames[] = {
28298 (char *) "self",(char *) "child", NULL
28299 };
28300
28301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) goto fail;
28302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28303 if (SWIG_arg_fail(1)) SWIG_fail;
28304 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28305 if (SWIG_arg_fail(2)) SWIG_fail;
28306 {
28307 PyThreadState* __tstate = wxPyBeginAllowThreads();
28308 (arg1)->RemoveChild(arg2);
28309
28310 wxPyEndAllowThreads(__tstate);
28311 if (PyErr_Occurred()) SWIG_fail;
28312 }
28313 Py_INCREF(Py_None); resultobj = Py_None;
28314 return resultobj;
28315 fail:
28316 return NULL;
28317 }
28318
28319
28320 static PyObject *_wrap_Window_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
28321 PyObject *resultobj;
28322 wxWindow *arg1 = (wxWindow *) 0 ;
28323 long arg2 ;
28324 wxWindow *result;
28325 PyObject * obj0 = 0 ;
28326 PyObject * obj1 = 0 ;
28327 char *kwnames[] = {
28328 (char *) "self",(char *) "winid", NULL
28329 };
28330
28331 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) goto fail;
28332 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28333 if (SWIG_arg_fail(1)) SWIG_fail;
28334 {
28335 arg2 = (long)(SWIG_As_long(obj1));
28336 if (SWIG_arg_fail(2)) SWIG_fail;
28337 }
28338 {
28339 PyThreadState* __tstate = wxPyBeginAllowThreads();
28340 result = (wxWindow *)(arg1)->FindWindow(arg2);
28341
28342 wxPyEndAllowThreads(__tstate);
28343 if (PyErr_Occurred()) SWIG_fail;
28344 }
28345 {
28346 resultobj = wxPyMake_wxObject(result, 0);
28347 }
28348 return resultobj;
28349 fail:
28350 return NULL;
28351 }
28352
28353
28354 static PyObject *_wrap_Window_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
28355 PyObject *resultobj;
28356 wxWindow *arg1 = (wxWindow *) 0 ;
28357 wxString *arg2 = 0 ;
28358 wxWindow *result;
28359 bool temp2 = false ;
28360 PyObject * obj0 = 0 ;
28361 PyObject * obj1 = 0 ;
28362 char *kwnames[] = {
28363 (char *) "self",(char *) "name", NULL
28364 };
28365
28366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
28367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28368 if (SWIG_arg_fail(1)) SWIG_fail;
28369 {
28370 arg2 = wxString_in_helper(obj1);
28371 if (arg2 == NULL) SWIG_fail;
28372 temp2 = true;
28373 }
28374 {
28375 PyThreadState* __tstate = wxPyBeginAllowThreads();
28376 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
28377
28378 wxPyEndAllowThreads(__tstate);
28379 if (PyErr_Occurred()) SWIG_fail;
28380 }
28381 {
28382 resultobj = wxPyMake_wxObject(result, 0);
28383 }
28384 {
28385 if (temp2)
28386 delete arg2;
28387 }
28388 return resultobj;
28389 fail:
28390 {
28391 if (temp2)
28392 delete arg2;
28393 }
28394 return NULL;
28395 }
28396
28397
28398 static PyObject *_wrap_Window_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28399 PyObject *resultobj;
28400 wxWindow *arg1 = (wxWindow *) 0 ;
28401 wxEvtHandler *result;
28402 PyObject * obj0 = 0 ;
28403 char *kwnames[] = {
28404 (char *) "self", NULL
28405 };
28406
28407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetEventHandler",kwnames,&obj0)) goto fail;
28408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28409 if (SWIG_arg_fail(1)) SWIG_fail;
28410 {
28411 PyThreadState* __tstate = wxPyBeginAllowThreads();
28412 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
28413
28414 wxPyEndAllowThreads(__tstate);
28415 if (PyErr_Occurred()) SWIG_fail;
28416 }
28417 {
28418 resultobj = wxPyMake_wxObject(result, 0);
28419 }
28420 return resultobj;
28421 fail:
28422 return NULL;
28423 }
28424
28425
28426 static PyObject *_wrap_Window_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28427 PyObject *resultobj;
28428 wxWindow *arg1 = (wxWindow *) 0 ;
28429 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28430 PyObject * obj0 = 0 ;
28431 PyObject * obj1 = 0 ;
28432 char *kwnames[] = {
28433 (char *) "self",(char *) "handler", NULL
28434 };
28435
28436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
28437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28438 if (SWIG_arg_fail(1)) SWIG_fail;
28439 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28440 if (SWIG_arg_fail(2)) SWIG_fail;
28441 {
28442 PyThreadState* __tstate = wxPyBeginAllowThreads();
28443 (arg1)->SetEventHandler(arg2);
28444
28445 wxPyEndAllowThreads(__tstate);
28446 if (PyErr_Occurred()) SWIG_fail;
28447 }
28448 Py_INCREF(Py_None); resultobj = Py_None;
28449 return resultobj;
28450 fail:
28451 return NULL;
28452 }
28453
28454
28455 static PyObject *_wrap_Window_PushEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28456 PyObject *resultobj;
28457 wxWindow *arg1 = (wxWindow *) 0 ;
28458 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28459 PyObject * obj0 = 0 ;
28460 PyObject * obj1 = 0 ;
28461 char *kwnames[] = {
28462 (char *) "self",(char *) "handler", NULL
28463 };
28464
28465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) goto fail;
28466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28467 if (SWIG_arg_fail(1)) SWIG_fail;
28468 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28469 if (SWIG_arg_fail(2)) SWIG_fail;
28470 {
28471 PyThreadState* __tstate = wxPyBeginAllowThreads();
28472 (arg1)->PushEventHandler(arg2);
28473
28474 wxPyEndAllowThreads(__tstate);
28475 if (PyErr_Occurred()) SWIG_fail;
28476 }
28477 Py_INCREF(Py_None); resultobj = Py_None;
28478 return resultobj;
28479 fail:
28480 return NULL;
28481 }
28482
28483
28484 static PyObject *_wrap_Window_PopEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28485 PyObject *resultobj;
28486 wxWindow *arg1 = (wxWindow *) 0 ;
28487 bool arg2 = (bool) false ;
28488 wxEvtHandler *result;
28489 PyObject * obj0 = 0 ;
28490 PyObject * obj1 = 0 ;
28491 char *kwnames[] = {
28492 (char *) "self",(char *) "deleteHandler", NULL
28493 };
28494
28495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) goto fail;
28496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28497 if (SWIG_arg_fail(1)) SWIG_fail;
28498 if (obj1) {
28499 {
28500 arg2 = (bool)(SWIG_As_bool(obj1));
28501 if (SWIG_arg_fail(2)) SWIG_fail;
28502 }
28503 }
28504 {
28505 PyThreadState* __tstate = wxPyBeginAllowThreads();
28506 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
28507
28508 wxPyEndAllowThreads(__tstate);
28509 if (PyErr_Occurred()) SWIG_fail;
28510 }
28511 {
28512 resultobj = wxPyMake_wxObject(result, 0);
28513 }
28514 return resultobj;
28515 fail:
28516 return NULL;
28517 }
28518
28519
28520 static PyObject *_wrap_Window_RemoveEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
28521 PyObject *resultobj;
28522 wxWindow *arg1 = (wxWindow *) 0 ;
28523 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
28524 bool result;
28525 PyObject * obj0 = 0 ;
28526 PyObject * obj1 = 0 ;
28527 char *kwnames[] = {
28528 (char *) "self",(char *) "handler", NULL
28529 };
28530
28531 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) goto fail;
28532 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28533 if (SWIG_arg_fail(1)) SWIG_fail;
28534 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
28535 if (SWIG_arg_fail(2)) SWIG_fail;
28536 {
28537 PyThreadState* __tstate = wxPyBeginAllowThreads();
28538 result = (bool)(arg1)->RemoveEventHandler(arg2);
28539
28540 wxPyEndAllowThreads(__tstate);
28541 if (PyErr_Occurred()) SWIG_fail;
28542 }
28543 {
28544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28545 }
28546 return resultobj;
28547 fail:
28548 return NULL;
28549 }
28550
28551
28552 static PyObject *_wrap_Window_SetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28553 PyObject *resultobj;
28554 wxWindow *arg1 = (wxWindow *) 0 ;
28555 wxValidator *arg2 = 0 ;
28556 PyObject * obj0 = 0 ;
28557 PyObject * obj1 = 0 ;
28558 char *kwnames[] = {
28559 (char *) "self",(char *) "validator", NULL
28560 };
28561
28562 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) goto fail;
28563 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28564 if (SWIG_arg_fail(1)) SWIG_fail;
28565 {
28566 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
28567 if (SWIG_arg_fail(2)) SWIG_fail;
28568 if (arg2 == NULL) {
28569 SWIG_null_ref("wxValidator");
28570 }
28571 if (SWIG_arg_fail(2)) SWIG_fail;
28572 }
28573 {
28574 PyThreadState* __tstate = wxPyBeginAllowThreads();
28575 (arg1)->SetValidator((wxValidator const &)*arg2);
28576
28577 wxPyEndAllowThreads(__tstate);
28578 if (PyErr_Occurred()) SWIG_fail;
28579 }
28580 Py_INCREF(Py_None); resultobj = Py_None;
28581 return resultobj;
28582 fail:
28583 return NULL;
28584 }
28585
28586
28587 static PyObject *_wrap_Window_GetValidator(PyObject *, PyObject *args, PyObject *kwargs) {
28588 PyObject *resultobj;
28589 wxWindow *arg1 = (wxWindow *) 0 ;
28590 wxValidator *result;
28591 PyObject * obj0 = 0 ;
28592 char *kwnames[] = {
28593 (char *) "self", NULL
28594 };
28595
28596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetValidator",kwnames,&obj0)) goto fail;
28597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28598 if (SWIG_arg_fail(1)) SWIG_fail;
28599 {
28600 PyThreadState* __tstate = wxPyBeginAllowThreads();
28601 result = (wxValidator *)(arg1)->GetValidator();
28602
28603 wxPyEndAllowThreads(__tstate);
28604 if (PyErr_Occurred()) SWIG_fail;
28605 }
28606 {
28607 resultobj = wxPyMake_wxObject(result, 0);
28608 }
28609 return resultobj;
28610 fail:
28611 return NULL;
28612 }
28613
28614
28615 static PyObject *_wrap_Window_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
28616 PyObject *resultobj;
28617 wxWindow *arg1 = (wxWindow *) 0 ;
28618 bool result;
28619 PyObject * obj0 = 0 ;
28620 char *kwnames[] = {
28621 (char *) "self", NULL
28622 };
28623
28624 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Validate",kwnames,&obj0)) goto fail;
28625 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28626 if (SWIG_arg_fail(1)) SWIG_fail;
28627 {
28628 PyThreadState* __tstate = wxPyBeginAllowThreads();
28629 result = (bool)(arg1)->Validate();
28630
28631 wxPyEndAllowThreads(__tstate);
28632 if (PyErr_Occurred()) SWIG_fail;
28633 }
28634 {
28635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28636 }
28637 return resultobj;
28638 fail:
28639 return NULL;
28640 }
28641
28642
28643 static PyObject *_wrap_Window_TransferDataToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28644 PyObject *resultobj;
28645 wxWindow *arg1 = (wxWindow *) 0 ;
28646 bool result;
28647 PyObject * obj0 = 0 ;
28648 char *kwnames[] = {
28649 (char *) "self", NULL
28650 };
28651
28652 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataToWindow",kwnames,&obj0)) goto fail;
28653 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28654 if (SWIG_arg_fail(1)) SWIG_fail;
28655 {
28656 PyThreadState* __tstate = wxPyBeginAllowThreads();
28657 result = (bool)(arg1)->TransferDataToWindow();
28658
28659 wxPyEndAllowThreads(__tstate);
28660 if (PyErr_Occurred()) SWIG_fail;
28661 }
28662 {
28663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28664 }
28665 return resultobj;
28666 fail:
28667 return NULL;
28668 }
28669
28670
28671 static PyObject *_wrap_Window_TransferDataFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
28672 PyObject *resultobj;
28673 wxWindow *arg1 = (wxWindow *) 0 ;
28674 bool result;
28675 PyObject * obj0 = 0 ;
28676 char *kwnames[] = {
28677 (char *) "self", NULL
28678 };
28679
28680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_TransferDataFromWindow",kwnames,&obj0)) goto fail;
28681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28682 if (SWIG_arg_fail(1)) SWIG_fail;
28683 {
28684 PyThreadState* __tstate = wxPyBeginAllowThreads();
28685 result = (bool)(arg1)->TransferDataFromWindow();
28686
28687 wxPyEndAllowThreads(__tstate);
28688 if (PyErr_Occurred()) SWIG_fail;
28689 }
28690 {
28691 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28692 }
28693 return resultobj;
28694 fail:
28695 return NULL;
28696 }
28697
28698
28699 static PyObject *_wrap_Window_InitDialog(PyObject *, PyObject *args, PyObject *kwargs) {
28700 PyObject *resultobj;
28701 wxWindow *arg1 = (wxWindow *) 0 ;
28702 PyObject * obj0 = 0 ;
28703 char *kwnames[] = {
28704 (char *) "self", NULL
28705 };
28706
28707 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InitDialog",kwnames,&obj0)) goto fail;
28708 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28709 if (SWIG_arg_fail(1)) SWIG_fail;
28710 {
28711 PyThreadState* __tstate = wxPyBeginAllowThreads();
28712 (arg1)->InitDialog();
28713
28714 wxPyEndAllowThreads(__tstate);
28715 if (PyErr_Occurred()) SWIG_fail;
28716 }
28717 Py_INCREF(Py_None); resultobj = Py_None;
28718 return resultobj;
28719 fail:
28720 return NULL;
28721 }
28722
28723
28724 static PyObject *_wrap_Window_SetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28725 PyObject *resultobj;
28726 wxWindow *arg1 = (wxWindow *) 0 ;
28727 wxAcceleratorTable *arg2 = 0 ;
28728 PyObject * obj0 = 0 ;
28729 PyObject * obj1 = 0 ;
28730 char *kwnames[] = {
28731 (char *) "self",(char *) "accel", NULL
28732 };
28733
28734 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) goto fail;
28735 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28736 if (SWIG_arg_fail(1)) SWIG_fail;
28737 {
28738 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_EXCEPTION | 0);
28739 if (SWIG_arg_fail(2)) SWIG_fail;
28740 if (arg2 == NULL) {
28741 SWIG_null_ref("wxAcceleratorTable");
28742 }
28743 if (SWIG_arg_fail(2)) SWIG_fail;
28744 }
28745 {
28746 PyThreadState* __tstate = wxPyBeginAllowThreads();
28747 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
28748
28749 wxPyEndAllowThreads(__tstate);
28750 if (PyErr_Occurred()) SWIG_fail;
28751 }
28752 Py_INCREF(Py_None); resultobj = Py_None;
28753 return resultobj;
28754 fail:
28755 return NULL;
28756 }
28757
28758
28759 static PyObject *_wrap_Window_GetAcceleratorTable(PyObject *, PyObject *args, PyObject *kwargs) {
28760 PyObject *resultobj;
28761 wxWindow *arg1 = (wxWindow *) 0 ;
28762 wxAcceleratorTable *result;
28763 PyObject * obj0 = 0 ;
28764 char *kwnames[] = {
28765 (char *) "self", NULL
28766 };
28767
28768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAcceleratorTable",kwnames,&obj0)) goto fail;
28769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28770 if (SWIG_arg_fail(1)) SWIG_fail;
28771 {
28772 PyThreadState* __tstate = wxPyBeginAllowThreads();
28773 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
28774
28775 wxPyEndAllowThreads(__tstate);
28776 if (PyErr_Occurred()) SWIG_fail;
28777 }
28778 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorTable, 0);
28779 return resultobj;
28780 fail:
28781 return NULL;
28782 }
28783
28784
28785 static PyObject *_wrap_Window_RegisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28786 PyObject *resultobj;
28787 wxWindow *arg1 = (wxWindow *) 0 ;
28788 int arg2 ;
28789 int arg3 ;
28790 int arg4 ;
28791 bool result;
28792 PyObject * obj0 = 0 ;
28793 PyObject * obj1 = 0 ;
28794 PyObject * obj2 = 0 ;
28795 PyObject * obj3 = 0 ;
28796 char *kwnames[] = {
28797 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
28798 };
28799
28800 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
28801 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28802 if (SWIG_arg_fail(1)) SWIG_fail;
28803 {
28804 arg2 = (int)(SWIG_As_int(obj1));
28805 if (SWIG_arg_fail(2)) SWIG_fail;
28806 }
28807 {
28808 arg3 = (int)(SWIG_As_int(obj2));
28809 if (SWIG_arg_fail(3)) SWIG_fail;
28810 }
28811 {
28812 arg4 = (int)(SWIG_As_int(obj3));
28813 if (SWIG_arg_fail(4)) SWIG_fail;
28814 }
28815 {
28816 PyThreadState* __tstate = wxPyBeginAllowThreads();
28817 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
28818
28819 wxPyEndAllowThreads(__tstate);
28820 if (PyErr_Occurred()) SWIG_fail;
28821 }
28822 {
28823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28824 }
28825 return resultobj;
28826 fail:
28827 return NULL;
28828 }
28829
28830
28831 static PyObject *_wrap_Window_UnregisterHotKey(PyObject *, PyObject *args, PyObject *kwargs) {
28832 PyObject *resultobj;
28833 wxWindow *arg1 = (wxWindow *) 0 ;
28834 int arg2 ;
28835 bool result;
28836 PyObject * obj0 = 0 ;
28837 PyObject * obj1 = 0 ;
28838 char *kwnames[] = {
28839 (char *) "self",(char *) "hotkeyId", NULL
28840 };
28841
28842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) goto fail;
28843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28844 if (SWIG_arg_fail(1)) SWIG_fail;
28845 {
28846 arg2 = (int)(SWIG_As_int(obj1));
28847 if (SWIG_arg_fail(2)) SWIG_fail;
28848 }
28849 {
28850 PyThreadState* __tstate = wxPyBeginAllowThreads();
28851 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
28852
28853 wxPyEndAllowThreads(__tstate);
28854 if (PyErr_Occurred()) SWIG_fail;
28855 }
28856 {
28857 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28858 }
28859 return resultobj;
28860 fail:
28861 return NULL;
28862 }
28863
28864
28865 static PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28866 PyObject *resultobj;
28867 wxWindow *arg1 = (wxWindow *) 0 ;
28868 wxPoint *arg2 = 0 ;
28869 wxPoint result;
28870 wxPoint temp2 ;
28871 PyObject * obj0 = 0 ;
28872 PyObject * obj1 = 0 ;
28873 char *kwnames[] = {
28874 (char *) "self",(char *) "pt", NULL
28875 };
28876
28877 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) goto fail;
28878 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28879 if (SWIG_arg_fail(1)) SWIG_fail;
28880 {
28881 arg2 = &temp2;
28882 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28883 }
28884 {
28885 PyThreadState* __tstate = wxPyBeginAllowThreads();
28886 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28887
28888 wxPyEndAllowThreads(__tstate);
28889 if (PyErr_Occurred()) SWIG_fail;
28890 }
28891 {
28892 wxPoint * resultptr;
28893 resultptr = new wxPoint((wxPoint &)(result));
28894 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28895 }
28896 return resultobj;
28897 fail:
28898 return NULL;
28899 }
28900
28901
28902 static PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *, PyObject *args, PyObject *kwargs) {
28903 PyObject *resultobj;
28904 wxWindow *arg1 = (wxWindow *) 0 ;
28905 wxSize *arg2 = 0 ;
28906 wxSize result;
28907 wxSize temp2 ;
28908 PyObject * obj0 = 0 ;
28909 PyObject * obj1 = 0 ;
28910 char *kwnames[] = {
28911 (char *) "self",(char *) "sz", NULL
28912 };
28913
28914 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) goto fail;
28915 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28916 if (SWIG_arg_fail(1)) SWIG_fail;
28917 {
28918 arg2 = &temp2;
28919 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28920 }
28921 {
28922 PyThreadState* __tstate = wxPyBeginAllowThreads();
28923 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28924
28925 wxPyEndAllowThreads(__tstate);
28926 if (PyErr_Occurred()) SWIG_fail;
28927 }
28928 {
28929 wxSize * resultptr;
28930 resultptr = new wxSize((wxSize &)(result));
28931 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
28932 }
28933 return resultobj;
28934 fail:
28935 return NULL;
28936 }
28937
28938
28939 static PyObject *_wrap_Window_DLG_PNT(PyObject *, PyObject *args, PyObject *kwargs) {
28940 PyObject *resultobj;
28941 wxWindow *arg1 = (wxWindow *) 0 ;
28942 wxPoint *arg2 = 0 ;
28943 wxPoint result;
28944 wxPoint temp2 ;
28945 PyObject * obj0 = 0 ;
28946 PyObject * obj1 = 0 ;
28947 char *kwnames[] = {
28948 (char *) "self",(char *) "pt", NULL
28949 };
28950
28951 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) goto fail;
28952 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28953 if (SWIG_arg_fail(1)) SWIG_fail;
28954 {
28955 arg2 = &temp2;
28956 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
28957 }
28958 {
28959 PyThreadState* __tstate = wxPyBeginAllowThreads();
28960 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
28961
28962 wxPyEndAllowThreads(__tstate);
28963 if (PyErr_Occurred()) SWIG_fail;
28964 }
28965 {
28966 wxPoint * resultptr;
28967 resultptr = new wxPoint((wxPoint &)(result));
28968 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
28969 }
28970 return resultobj;
28971 fail:
28972 return NULL;
28973 }
28974
28975
28976 static PyObject *_wrap_Window_DLG_SZE(PyObject *, PyObject *args, PyObject *kwargs) {
28977 PyObject *resultobj;
28978 wxWindow *arg1 = (wxWindow *) 0 ;
28979 wxSize *arg2 = 0 ;
28980 wxSize result;
28981 wxSize temp2 ;
28982 PyObject * obj0 = 0 ;
28983 PyObject * obj1 = 0 ;
28984 char *kwnames[] = {
28985 (char *) "self",(char *) "sz", NULL
28986 };
28987
28988 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) goto fail;
28989 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
28990 if (SWIG_arg_fail(1)) SWIG_fail;
28991 {
28992 arg2 = &temp2;
28993 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
28994 }
28995 {
28996 PyThreadState* __tstate = wxPyBeginAllowThreads();
28997 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
28998
28999 wxPyEndAllowThreads(__tstate);
29000 if (PyErr_Occurred()) SWIG_fail;
29001 }
29002 {
29003 wxSize * resultptr;
29004 resultptr = new wxSize((wxSize &)(result));
29005 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29006 }
29007 return resultobj;
29008 fail:
29009 return NULL;
29010 }
29011
29012
29013 static PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29014 PyObject *resultobj;
29015 wxWindow *arg1 = (wxWindow *) 0 ;
29016 wxPoint *arg2 = 0 ;
29017 wxPoint result;
29018 wxPoint temp2 ;
29019 PyObject * obj0 = 0 ;
29020 PyObject * obj1 = 0 ;
29021 char *kwnames[] = {
29022 (char *) "self",(char *) "pt", NULL
29023 };
29024
29025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) goto fail;
29026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29027 if (SWIG_arg_fail(1)) SWIG_fail;
29028 {
29029 arg2 = &temp2;
29030 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29031 }
29032 {
29033 PyThreadState* __tstate = wxPyBeginAllowThreads();
29034 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
29035
29036 wxPyEndAllowThreads(__tstate);
29037 if (PyErr_Occurred()) SWIG_fail;
29038 }
29039 {
29040 wxPoint * resultptr;
29041 resultptr = new wxPoint((wxPoint &)(result));
29042 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
29043 }
29044 return resultobj;
29045 fail:
29046 return NULL;
29047 }
29048
29049
29050 static PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *, PyObject *args, PyObject *kwargs) {
29051 PyObject *resultobj;
29052 wxWindow *arg1 = (wxWindow *) 0 ;
29053 wxSize *arg2 = 0 ;
29054 wxSize result;
29055 wxSize temp2 ;
29056 PyObject * obj0 = 0 ;
29057 PyObject * obj1 = 0 ;
29058 char *kwnames[] = {
29059 (char *) "self",(char *) "sz", NULL
29060 };
29061
29062 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) goto fail;
29063 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29064 if (SWIG_arg_fail(1)) SWIG_fail;
29065 {
29066 arg2 = &temp2;
29067 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
29068 }
29069 {
29070 PyThreadState* __tstate = wxPyBeginAllowThreads();
29071 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
29072
29073 wxPyEndAllowThreads(__tstate);
29074 if (PyErr_Occurred()) SWIG_fail;
29075 }
29076 {
29077 wxSize * resultptr;
29078 resultptr = new wxSize((wxSize &)(result));
29079 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
29080 }
29081 return resultobj;
29082 fail:
29083 return NULL;
29084 }
29085
29086
29087 static PyObject *_wrap_Window_WarpPointer(PyObject *, PyObject *args, PyObject *kwargs) {
29088 PyObject *resultobj;
29089 wxWindow *arg1 = (wxWindow *) 0 ;
29090 int arg2 ;
29091 int arg3 ;
29092 PyObject * obj0 = 0 ;
29093 PyObject * obj1 = 0 ;
29094 PyObject * obj2 = 0 ;
29095 char *kwnames[] = {
29096 (char *) "self",(char *) "x",(char *) "y", NULL
29097 };
29098
29099 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) goto fail;
29100 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29101 if (SWIG_arg_fail(1)) SWIG_fail;
29102 {
29103 arg2 = (int)(SWIG_As_int(obj1));
29104 if (SWIG_arg_fail(2)) SWIG_fail;
29105 }
29106 {
29107 arg3 = (int)(SWIG_As_int(obj2));
29108 if (SWIG_arg_fail(3)) SWIG_fail;
29109 }
29110 {
29111 PyThreadState* __tstate = wxPyBeginAllowThreads();
29112 (arg1)->WarpPointer(arg2,arg3);
29113
29114 wxPyEndAllowThreads(__tstate);
29115 if (PyErr_Occurred()) SWIG_fail;
29116 }
29117 Py_INCREF(Py_None); resultobj = Py_None;
29118 return resultobj;
29119 fail:
29120 return NULL;
29121 }
29122
29123
29124 static PyObject *_wrap_Window_CaptureMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29125 PyObject *resultobj;
29126 wxWindow *arg1 = (wxWindow *) 0 ;
29127 PyObject * obj0 = 0 ;
29128 char *kwnames[] = {
29129 (char *) "self", NULL
29130 };
29131
29132 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_CaptureMouse",kwnames,&obj0)) goto fail;
29133 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29134 if (SWIG_arg_fail(1)) SWIG_fail;
29135 {
29136 PyThreadState* __tstate = wxPyBeginAllowThreads();
29137 (arg1)->CaptureMouse();
29138
29139 wxPyEndAllowThreads(__tstate);
29140 if (PyErr_Occurred()) SWIG_fail;
29141 }
29142 Py_INCREF(Py_None); resultobj = Py_None;
29143 return resultobj;
29144 fail:
29145 return NULL;
29146 }
29147
29148
29149 static PyObject *_wrap_Window_ReleaseMouse(PyObject *, PyObject *args, PyObject *kwargs) {
29150 PyObject *resultobj;
29151 wxWindow *arg1 = (wxWindow *) 0 ;
29152 PyObject * obj0 = 0 ;
29153 char *kwnames[] = {
29154 (char *) "self", NULL
29155 };
29156
29157 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ReleaseMouse",kwnames,&obj0)) goto fail;
29158 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29159 if (SWIG_arg_fail(1)) SWIG_fail;
29160 {
29161 PyThreadState* __tstate = wxPyBeginAllowThreads();
29162 (arg1)->ReleaseMouse();
29163
29164 wxPyEndAllowThreads(__tstate);
29165 if (PyErr_Occurred()) SWIG_fail;
29166 }
29167 Py_INCREF(Py_None); resultobj = Py_None;
29168 return resultobj;
29169 fail:
29170 return NULL;
29171 }
29172
29173
29174 static PyObject *_wrap_Window_GetCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29175 PyObject *resultobj;
29176 wxWindow *result;
29177 char *kwnames[] = {
29178 NULL
29179 };
29180
29181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Window_GetCapture",kwnames)) goto fail;
29182 {
29183 if (!wxPyCheckForApp()) SWIG_fail;
29184 PyThreadState* __tstate = wxPyBeginAllowThreads();
29185 result = (wxWindow *)wxWindow::GetCapture();
29186
29187 wxPyEndAllowThreads(__tstate);
29188 if (PyErr_Occurred()) SWIG_fail;
29189 }
29190 {
29191 resultobj = wxPyMake_wxObject(result, 0);
29192 }
29193 return resultobj;
29194 fail:
29195 return NULL;
29196 }
29197
29198
29199 static PyObject *_wrap_Window_HasCapture(PyObject *, PyObject *args, PyObject *kwargs) {
29200 PyObject *resultobj;
29201 wxWindow *arg1 = (wxWindow *) 0 ;
29202 bool result;
29203 PyObject * obj0 = 0 ;
29204 char *kwnames[] = {
29205 (char *) "self", NULL
29206 };
29207
29208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasCapture",kwnames,&obj0)) goto fail;
29209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29210 if (SWIG_arg_fail(1)) SWIG_fail;
29211 {
29212 PyThreadState* __tstate = wxPyBeginAllowThreads();
29213 result = (bool)((wxWindow const *)arg1)->HasCapture();
29214
29215 wxPyEndAllowThreads(__tstate);
29216 if (PyErr_Occurred()) SWIG_fail;
29217 }
29218 {
29219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29220 }
29221 return resultobj;
29222 fail:
29223 return NULL;
29224 }
29225
29226
29227 static PyObject *_wrap_Window_Refresh(PyObject *, PyObject *args, PyObject *kwargs) {
29228 PyObject *resultobj;
29229 wxWindow *arg1 = (wxWindow *) 0 ;
29230 bool arg2 = (bool) true ;
29231 wxRect *arg3 = (wxRect *) NULL ;
29232 PyObject * obj0 = 0 ;
29233 PyObject * obj1 = 0 ;
29234 PyObject * obj2 = 0 ;
29235 char *kwnames[] = {
29236 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
29237 };
29238
29239 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) goto fail;
29240 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29241 if (SWIG_arg_fail(1)) SWIG_fail;
29242 if (obj1) {
29243 {
29244 arg2 = (bool)(SWIG_As_bool(obj1));
29245 if (SWIG_arg_fail(2)) SWIG_fail;
29246 }
29247 }
29248 if (obj2) {
29249 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
29250 if (SWIG_arg_fail(3)) SWIG_fail;
29251 }
29252 {
29253 PyThreadState* __tstate = wxPyBeginAllowThreads();
29254 (arg1)->Refresh(arg2,(wxRect const *)arg3);
29255
29256 wxPyEndAllowThreads(__tstate);
29257 if (PyErr_Occurred()) SWIG_fail;
29258 }
29259 Py_INCREF(Py_None); resultobj = Py_None;
29260 return resultobj;
29261 fail:
29262 return NULL;
29263 }
29264
29265
29266 static PyObject *_wrap_Window_RefreshRect(PyObject *, PyObject *args, PyObject *kwargs) {
29267 PyObject *resultobj;
29268 wxWindow *arg1 = (wxWindow *) 0 ;
29269 wxRect *arg2 = 0 ;
29270 bool arg3 = (bool) true ;
29271 wxRect temp2 ;
29272 PyObject * obj0 = 0 ;
29273 PyObject * obj1 = 0 ;
29274 PyObject * obj2 = 0 ;
29275 char *kwnames[] = {
29276 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
29277 };
29278
29279 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) goto fail;
29280 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29281 if (SWIG_arg_fail(1)) SWIG_fail;
29282 {
29283 arg2 = &temp2;
29284 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29285 }
29286 if (obj2) {
29287 {
29288 arg3 = (bool)(SWIG_As_bool(obj2));
29289 if (SWIG_arg_fail(3)) SWIG_fail;
29290 }
29291 }
29292 {
29293 PyThreadState* __tstate = wxPyBeginAllowThreads();
29294 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
29295
29296 wxPyEndAllowThreads(__tstate);
29297 if (PyErr_Occurred()) SWIG_fail;
29298 }
29299 Py_INCREF(Py_None); resultobj = Py_None;
29300 return resultobj;
29301 fail:
29302 return NULL;
29303 }
29304
29305
29306 static PyObject *_wrap_Window_Update(PyObject *, PyObject *args, PyObject *kwargs) {
29307 PyObject *resultobj;
29308 wxWindow *arg1 = (wxWindow *) 0 ;
29309 PyObject * obj0 = 0 ;
29310 char *kwnames[] = {
29311 (char *) "self", NULL
29312 };
29313
29314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Update",kwnames,&obj0)) goto fail;
29315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29316 if (SWIG_arg_fail(1)) SWIG_fail;
29317 {
29318 PyThreadState* __tstate = wxPyBeginAllowThreads();
29319 (arg1)->Update();
29320
29321 wxPyEndAllowThreads(__tstate);
29322 if (PyErr_Occurred()) SWIG_fail;
29323 }
29324 Py_INCREF(Py_None); resultobj = Py_None;
29325 return resultobj;
29326 fail:
29327 return NULL;
29328 }
29329
29330
29331 static PyObject *_wrap_Window_ClearBackground(PyObject *, PyObject *args, PyObject *kwargs) {
29332 PyObject *resultobj;
29333 wxWindow *arg1 = (wxWindow *) 0 ;
29334 PyObject * obj0 = 0 ;
29335 char *kwnames[] = {
29336 (char *) "self", NULL
29337 };
29338
29339 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ClearBackground",kwnames,&obj0)) goto fail;
29340 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29341 if (SWIG_arg_fail(1)) SWIG_fail;
29342 {
29343 PyThreadState* __tstate = wxPyBeginAllowThreads();
29344 (arg1)->ClearBackground();
29345
29346 wxPyEndAllowThreads(__tstate);
29347 if (PyErr_Occurred()) SWIG_fail;
29348 }
29349 Py_INCREF(Py_None); resultobj = Py_None;
29350 return resultobj;
29351 fail:
29352 return NULL;
29353 }
29354
29355
29356 static PyObject *_wrap_Window_Freeze(PyObject *, PyObject *args, PyObject *kwargs) {
29357 PyObject *resultobj;
29358 wxWindow *arg1 = (wxWindow *) 0 ;
29359 PyObject * obj0 = 0 ;
29360 char *kwnames[] = {
29361 (char *) "self", NULL
29362 };
29363
29364 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Freeze",kwnames,&obj0)) goto fail;
29365 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29366 if (SWIG_arg_fail(1)) SWIG_fail;
29367 {
29368 PyThreadState* __tstate = wxPyBeginAllowThreads();
29369 (arg1)->Freeze();
29370
29371 wxPyEndAllowThreads(__tstate);
29372 if (PyErr_Occurred()) SWIG_fail;
29373 }
29374 Py_INCREF(Py_None); resultobj = Py_None;
29375 return resultobj;
29376 fail:
29377 return NULL;
29378 }
29379
29380
29381 static PyObject *_wrap_Window_Thaw(PyObject *, PyObject *args, PyObject *kwargs) {
29382 PyObject *resultobj;
29383 wxWindow *arg1 = (wxWindow *) 0 ;
29384 PyObject * obj0 = 0 ;
29385 char *kwnames[] = {
29386 (char *) "self", NULL
29387 };
29388
29389 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Thaw",kwnames,&obj0)) goto fail;
29390 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29391 if (SWIG_arg_fail(1)) SWIG_fail;
29392 {
29393 PyThreadState* __tstate = wxPyBeginAllowThreads();
29394 (arg1)->Thaw();
29395
29396 wxPyEndAllowThreads(__tstate);
29397 if (PyErr_Occurred()) SWIG_fail;
29398 }
29399 Py_INCREF(Py_None); resultobj = Py_None;
29400 return resultobj;
29401 fail:
29402 return NULL;
29403 }
29404
29405
29406 static PyObject *_wrap_Window_PrepareDC(PyObject *, PyObject *args, PyObject *kwargs) {
29407 PyObject *resultobj;
29408 wxWindow *arg1 = (wxWindow *) 0 ;
29409 wxDC *arg2 = 0 ;
29410 PyObject * obj0 = 0 ;
29411 PyObject * obj1 = 0 ;
29412 char *kwnames[] = {
29413 (char *) "self",(char *) "dc", NULL
29414 };
29415
29416 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) goto fail;
29417 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29418 if (SWIG_arg_fail(1)) SWIG_fail;
29419 {
29420 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxDC, SWIG_POINTER_EXCEPTION | 0);
29421 if (SWIG_arg_fail(2)) SWIG_fail;
29422 if (arg2 == NULL) {
29423 SWIG_null_ref("wxDC");
29424 }
29425 if (SWIG_arg_fail(2)) SWIG_fail;
29426 }
29427 {
29428 PyThreadState* __tstate = wxPyBeginAllowThreads();
29429 (arg1)->PrepareDC(*arg2);
29430
29431 wxPyEndAllowThreads(__tstate);
29432 if (PyErr_Occurred()) SWIG_fail;
29433 }
29434 Py_INCREF(Py_None); resultobj = Py_None;
29435 return resultobj;
29436 fail:
29437 return NULL;
29438 }
29439
29440
29441 static PyObject *_wrap_Window_GetUpdateRegion(PyObject *, PyObject *args, PyObject *kwargs) {
29442 PyObject *resultobj;
29443 wxWindow *arg1 = (wxWindow *) 0 ;
29444 wxRegion *result;
29445 PyObject * obj0 = 0 ;
29446 char *kwnames[] = {
29447 (char *) "self", NULL
29448 };
29449
29450 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateRegion",kwnames,&obj0)) goto fail;
29451 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29452 if (SWIG_arg_fail(1)) SWIG_fail;
29453 {
29454 PyThreadState* __tstate = wxPyBeginAllowThreads();
29455 {
29456 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
29457 result = (wxRegion *) &_result_ref;
29458 }
29459
29460 wxPyEndAllowThreads(__tstate);
29461 if (PyErr_Occurred()) SWIG_fail;
29462 }
29463 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxRegion, 0);
29464 return resultobj;
29465 fail:
29466 return NULL;
29467 }
29468
29469
29470 static PyObject *_wrap_Window_GetUpdateClientRect(PyObject *, PyObject *args, PyObject *kwargs) {
29471 PyObject *resultobj;
29472 wxWindow *arg1 = (wxWindow *) 0 ;
29473 wxRect result;
29474 PyObject * obj0 = 0 ;
29475 char *kwnames[] = {
29476 (char *) "self", NULL
29477 };
29478
29479 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetUpdateClientRect",kwnames,&obj0)) goto fail;
29480 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29481 if (SWIG_arg_fail(1)) SWIG_fail;
29482 {
29483 PyThreadState* __tstate = wxPyBeginAllowThreads();
29484 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
29485
29486 wxPyEndAllowThreads(__tstate);
29487 if (PyErr_Occurred()) SWIG_fail;
29488 }
29489 {
29490 wxRect * resultptr;
29491 resultptr = new wxRect((wxRect &)(result));
29492 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
29493 }
29494 return resultobj;
29495 fail:
29496 return NULL;
29497 }
29498
29499
29500 static PyObject *_wrap_Window_IsExposed(PyObject *, PyObject *args, PyObject *kwargs) {
29501 PyObject *resultobj;
29502 wxWindow *arg1 = (wxWindow *) 0 ;
29503 int arg2 ;
29504 int arg3 ;
29505 int arg4 = (int) 1 ;
29506 int arg5 = (int) 1 ;
29507 bool result;
29508 PyObject * obj0 = 0 ;
29509 PyObject * obj1 = 0 ;
29510 PyObject * obj2 = 0 ;
29511 PyObject * obj3 = 0 ;
29512 PyObject * obj4 = 0 ;
29513 char *kwnames[] = {
29514 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
29515 };
29516
29517 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
29518 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29519 if (SWIG_arg_fail(1)) SWIG_fail;
29520 {
29521 arg2 = (int)(SWIG_As_int(obj1));
29522 if (SWIG_arg_fail(2)) SWIG_fail;
29523 }
29524 {
29525 arg3 = (int)(SWIG_As_int(obj2));
29526 if (SWIG_arg_fail(3)) SWIG_fail;
29527 }
29528 if (obj3) {
29529 {
29530 arg4 = (int)(SWIG_As_int(obj3));
29531 if (SWIG_arg_fail(4)) SWIG_fail;
29532 }
29533 }
29534 if (obj4) {
29535 {
29536 arg5 = (int)(SWIG_As_int(obj4));
29537 if (SWIG_arg_fail(5)) SWIG_fail;
29538 }
29539 }
29540 {
29541 PyThreadState* __tstate = wxPyBeginAllowThreads();
29542 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
29543
29544 wxPyEndAllowThreads(__tstate);
29545 if (PyErr_Occurred()) SWIG_fail;
29546 }
29547 {
29548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29549 }
29550 return resultobj;
29551 fail:
29552 return NULL;
29553 }
29554
29555
29556 static PyObject *_wrap_Window_IsExposedPoint(PyObject *, PyObject *args, PyObject *kwargs) {
29557 PyObject *resultobj;
29558 wxWindow *arg1 = (wxWindow *) 0 ;
29559 wxPoint *arg2 = 0 ;
29560 bool result;
29561 wxPoint temp2 ;
29562 PyObject * obj0 = 0 ;
29563 PyObject * obj1 = 0 ;
29564 char *kwnames[] = {
29565 (char *) "self",(char *) "pt", NULL
29566 };
29567
29568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) goto fail;
29569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29570 if (SWIG_arg_fail(1)) SWIG_fail;
29571 {
29572 arg2 = &temp2;
29573 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29574 }
29575 {
29576 PyThreadState* __tstate = wxPyBeginAllowThreads();
29577 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
29578
29579 wxPyEndAllowThreads(__tstate);
29580 if (PyErr_Occurred()) SWIG_fail;
29581 }
29582 {
29583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29584 }
29585 return resultobj;
29586 fail:
29587 return NULL;
29588 }
29589
29590
29591 static PyObject *_wrap_Window_IsExposedRect(PyObject *, PyObject *args, PyObject *kwargs) {
29592 PyObject *resultobj;
29593 wxWindow *arg1 = (wxWindow *) 0 ;
29594 wxRect *arg2 = 0 ;
29595 bool result;
29596 wxRect temp2 ;
29597 PyObject * obj0 = 0 ;
29598 PyObject * obj1 = 0 ;
29599 char *kwnames[] = {
29600 (char *) "self",(char *) "rect", NULL
29601 };
29602
29603 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) goto fail;
29604 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29605 if (SWIG_arg_fail(1)) SWIG_fail;
29606 {
29607 arg2 = &temp2;
29608 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
29609 }
29610 {
29611 PyThreadState* __tstate = wxPyBeginAllowThreads();
29612 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
29613
29614 wxPyEndAllowThreads(__tstate);
29615 if (PyErr_Occurred()) SWIG_fail;
29616 }
29617 {
29618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29619 }
29620 return resultobj;
29621 fail:
29622 return NULL;
29623 }
29624
29625
29626 static PyObject *_wrap_Window_GetDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29627 PyObject *resultobj;
29628 wxWindow *arg1 = (wxWindow *) 0 ;
29629 wxVisualAttributes result;
29630 PyObject * obj0 = 0 ;
29631 char *kwnames[] = {
29632 (char *) "self", NULL
29633 };
29634
29635 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDefaultAttributes",kwnames,&obj0)) goto fail;
29636 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29637 if (SWIG_arg_fail(1)) SWIG_fail;
29638 {
29639 PyThreadState* __tstate = wxPyBeginAllowThreads();
29640 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
29641
29642 wxPyEndAllowThreads(__tstate);
29643 if (PyErr_Occurred()) SWIG_fail;
29644 }
29645 {
29646 wxVisualAttributes * resultptr;
29647 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29648 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29649 }
29650 return resultobj;
29651 fail:
29652 return NULL;
29653 }
29654
29655
29656 static PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
29657 PyObject *resultobj;
29658 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
29659 wxVisualAttributes result;
29660 PyObject * obj0 = 0 ;
29661 char *kwnames[] = {
29662 (char *) "variant", NULL
29663 };
29664
29665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
29666 if (obj0) {
29667 {
29668 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
29669 if (SWIG_arg_fail(1)) SWIG_fail;
29670 }
29671 }
29672 {
29673 if (!wxPyCheckForApp()) SWIG_fail;
29674 PyThreadState* __tstate = wxPyBeginAllowThreads();
29675 result = wxWindow::GetClassDefaultAttributes((wxWindowVariant )arg1);
29676
29677 wxPyEndAllowThreads(__tstate);
29678 if (PyErr_Occurred()) SWIG_fail;
29679 }
29680 {
29681 wxVisualAttributes * resultptr;
29682 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
29683 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
29684 }
29685 return resultobj;
29686 fail:
29687 return NULL;
29688 }
29689
29690
29691 static PyObject *_wrap_Window_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29692 PyObject *resultobj;
29693 wxWindow *arg1 = (wxWindow *) 0 ;
29694 wxColour *arg2 = 0 ;
29695 bool result;
29696 wxColour temp2 ;
29697 PyObject * obj0 = 0 ;
29698 PyObject * obj1 = 0 ;
29699 char *kwnames[] = {
29700 (char *) "self",(char *) "colour", NULL
29701 };
29702
29703 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29704 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29705 if (SWIG_arg_fail(1)) SWIG_fail;
29706 {
29707 arg2 = &temp2;
29708 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29709 }
29710 {
29711 PyThreadState* __tstate = wxPyBeginAllowThreads();
29712 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
29713
29714 wxPyEndAllowThreads(__tstate);
29715 if (PyErr_Occurred()) SWIG_fail;
29716 }
29717 {
29718 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29719 }
29720 return resultobj;
29721 fail:
29722 return NULL;
29723 }
29724
29725
29726 static PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29727 PyObject *resultobj;
29728 wxWindow *arg1 = (wxWindow *) 0 ;
29729 wxColour *arg2 = 0 ;
29730 wxColour temp2 ;
29731 PyObject * obj0 = 0 ;
29732 PyObject * obj1 = 0 ;
29733 char *kwnames[] = {
29734 (char *) "self",(char *) "colour", NULL
29735 };
29736
29737 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
29738 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29739 if (SWIG_arg_fail(1)) SWIG_fail;
29740 {
29741 arg2 = &temp2;
29742 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29743 }
29744 {
29745 PyThreadState* __tstate = wxPyBeginAllowThreads();
29746 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
29747
29748 wxPyEndAllowThreads(__tstate);
29749 if (PyErr_Occurred()) SWIG_fail;
29750 }
29751 Py_INCREF(Py_None); resultobj = Py_None;
29752 return resultobj;
29753 fail:
29754 return NULL;
29755 }
29756
29757
29758 static PyObject *_wrap_Window_SetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29759 PyObject *resultobj;
29760 wxWindow *arg1 = (wxWindow *) 0 ;
29761 wxColour *arg2 = 0 ;
29762 bool result;
29763 wxColour temp2 ;
29764 PyObject * obj0 = 0 ;
29765 PyObject * obj1 = 0 ;
29766 char *kwnames[] = {
29767 (char *) "self",(char *) "colour", NULL
29768 };
29769
29770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29772 if (SWIG_arg_fail(1)) SWIG_fail;
29773 {
29774 arg2 = &temp2;
29775 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29776 }
29777 {
29778 PyThreadState* __tstate = wxPyBeginAllowThreads();
29779 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
29780
29781 wxPyEndAllowThreads(__tstate);
29782 if (PyErr_Occurred()) SWIG_fail;
29783 }
29784 {
29785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29786 }
29787 return resultobj;
29788 fail:
29789 return NULL;
29790 }
29791
29792
29793 static PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29794 PyObject *resultobj;
29795 wxWindow *arg1 = (wxWindow *) 0 ;
29796 wxColour *arg2 = 0 ;
29797 wxColour temp2 ;
29798 PyObject * obj0 = 0 ;
29799 PyObject * obj1 = 0 ;
29800 char *kwnames[] = {
29801 (char *) "self",(char *) "colour", NULL
29802 };
29803
29804 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) goto fail;
29805 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29806 if (SWIG_arg_fail(1)) SWIG_fail;
29807 {
29808 arg2 = &temp2;
29809 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
29810 }
29811 {
29812 PyThreadState* __tstate = wxPyBeginAllowThreads();
29813 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
29814
29815 wxPyEndAllowThreads(__tstate);
29816 if (PyErr_Occurred()) SWIG_fail;
29817 }
29818 Py_INCREF(Py_None); resultobj = Py_None;
29819 return resultobj;
29820 fail:
29821 return NULL;
29822 }
29823
29824
29825 static PyObject *_wrap_Window_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29826 PyObject *resultobj;
29827 wxWindow *arg1 = (wxWindow *) 0 ;
29828 wxColour result;
29829 PyObject * obj0 = 0 ;
29830 char *kwnames[] = {
29831 (char *) "self", NULL
29832 };
29833
29834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundColour",kwnames,&obj0)) goto fail;
29835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29836 if (SWIG_arg_fail(1)) SWIG_fail;
29837 {
29838 PyThreadState* __tstate = wxPyBeginAllowThreads();
29839 result = ((wxWindow const *)arg1)->GetBackgroundColour();
29840
29841 wxPyEndAllowThreads(__tstate);
29842 if (PyErr_Occurred()) SWIG_fail;
29843 }
29844 {
29845 wxColour * resultptr;
29846 resultptr = new wxColour((wxColour &)(result));
29847 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29848 }
29849 return resultobj;
29850 fail:
29851 return NULL;
29852 }
29853
29854
29855 static PyObject *_wrap_Window_GetForegroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29856 PyObject *resultobj;
29857 wxWindow *arg1 = (wxWindow *) 0 ;
29858 wxColour result;
29859 PyObject * obj0 = 0 ;
29860 char *kwnames[] = {
29861 (char *) "self", NULL
29862 };
29863
29864 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetForegroundColour",kwnames,&obj0)) goto fail;
29865 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29866 if (SWIG_arg_fail(1)) SWIG_fail;
29867 {
29868 PyThreadState* __tstate = wxPyBeginAllowThreads();
29869 result = ((wxWindow const *)arg1)->GetForegroundColour();
29870
29871 wxPyEndAllowThreads(__tstate);
29872 if (PyErr_Occurred()) SWIG_fail;
29873 }
29874 {
29875 wxColour * resultptr;
29876 resultptr = new wxColour((wxColour &)(result));
29877 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
29878 }
29879 return resultobj;
29880 fail:
29881 return NULL;
29882 }
29883
29884
29885 static PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
29886 PyObject *resultobj;
29887 wxWindow *arg1 = (wxWindow *) 0 ;
29888 bool result;
29889 PyObject * obj0 = 0 ;
29890 char *kwnames[] = {
29891 (char *) "self", NULL
29892 };
29893
29894 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritsBackgroundColour",kwnames,&obj0)) goto fail;
29895 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29896 if (SWIG_arg_fail(1)) SWIG_fail;
29897 {
29898 PyThreadState* __tstate = wxPyBeginAllowThreads();
29899 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
29900
29901 wxPyEndAllowThreads(__tstate);
29902 if (PyErr_Occurred()) SWIG_fail;
29903 }
29904 {
29905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29906 }
29907 return resultobj;
29908 fail:
29909 return NULL;
29910 }
29911
29912
29913 static PyObject *_wrap_Window_UseBgCol(PyObject *, PyObject *args, PyObject *kwargs) {
29914 PyObject *resultobj;
29915 wxWindow *arg1 = (wxWindow *) 0 ;
29916 bool result;
29917 PyObject * obj0 = 0 ;
29918 char *kwnames[] = {
29919 (char *) "self", NULL
29920 };
29921
29922 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_UseBgCol",kwnames,&obj0)) goto fail;
29923 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29924 if (SWIG_arg_fail(1)) SWIG_fail;
29925 {
29926 PyThreadState* __tstate = wxPyBeginAllowThreads();
29927 result = (bool)((wxWindow const *)arg1)->UseBgCol();
29928
29929 wxPyEndAllowThreads(__tstate);
29930 if (PyErr_Occurred()) SWIG_fail;
29931 }
29932 {
29933 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29934 }
29935 return resultobj;
29936 fail:
29937 return NULL;
29938 }
29939
29940
29941 static PyObject *_wrap_Window_SetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29942 PyObject *resultobj;
29943 wxWindow *arg1 = (wxWindow *) 0 ;
29944 wxBackgroundStyle arg2 ;
29945 bool result;
29946 PyObject * obj0 = 0 ;
29947 PyObject * obj1 = 0 ;
29948 char *kwnames[] = {
29949 (char *) "self",(char *) "style", NULL
29950 };
29951
29952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) goto fail;
29953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29954 if (SWIG_arg_fail(1)) SWIG_fail;
29955 {
29956 arg2 = (wxBackgroundStyle)(SWIG_As_int(obj1));
29957 if (SWIG_arg_fail(2)) SWIG_fail;
29958 }
29959 {
29960 PyThreadState* __tstate = wxPyBeginAllowThreads();
29961 result = (bool)(arg1)->SetBackgroundStyle((wxBackgroundStyle )arg2);
29962
29963 wxPyEndAllowThreads(__tstate);
29964 if (PyErr_Occurred()) SWIG_fail;
29965 }
29966 {
29967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29968 }
29969 return resultobj;
29970 fail:
29971 return NULL;
29972 }
29973
29974
29975 static PyObject *_wrap_Window_GetBackgroundStyle(PyObject *, PyObject *args, PyObject *kwargs) {
29976 PyObject *resultobj;
29977 wxWindow *arg1 = (wxWindow *) 0 ;
29978 wxBackgroundStyle result;
29979 PyObject * obj0 = 0 ;
29980 char *kwnames[] = {
29981 (char *) "self", NULL
29982 };
29983
29984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetBackgroundStyle",kwnames,&obj0)) goto fail;
29985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
29986 if (SWIG_arg_fail(1)) SWIG_fail;
29987 {
29988 PyThreadState* __tstate = wxPyBeginAllowThreads();
29989 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
29990
29991 wxPyEndAllowThreads(__tstate);
29992 if (PyErr_Occurred()) SWIG_fail;
29993 }
29994 resultobj = SWIG_From_int((result));
29995 return resultobj;
29996 fail:
29997 return NULL;
29998 }
29999
30000
30001 static PyObject *_wrap_Window_HasTransparentBackground(PyObject *, PyObject *args, PyObject *kwargs) {
30002 PyObject *resultobj;
30003 wxWindow *arg1 = (wxWindow *) 0 ;
30004 bool result;
30005 PyObject * obj0 = 0 ;
30006 char *kwnames[] = {
30007 (char *) "self", NULL
30008 };
30009
30010 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_HasTransparentBackground",kwnames,&obj0)) goto fail;
30011 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30012 if (SWIG_arg_fail(1)) SWIG_fail;
30013 {
30014 PyThreadState* __tstate = wxPyBeginAllowThreads();
30015 result = (bool)(arg1)->HasTransparentBackground();
30016
30017 wxPyEndAllowThreads(__tstate);
30018 if (PyErr_Occurred()) SWIG_fail;
30019 }
30020 {
30021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30022 }
30023 return resultobj;
30024 fail:
30025 return NULL;
30026 }
30027
30028
30029 static PyObject *_wrap_Window_SetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30030 PyObject *resultobj;
30031 wxWindow *arg1 = (wxWindow *) 0 ;
30032 wxCursor *arg2 = 0 ;
30033 bool result;
30034 PyObject * obj0 = 0 ;
30035 PyObject * obj1 = 0 ;
30036 char *kwnames[] = {
30037 (char *) "self",(char *) "cursor", NULL
30038 };
30039
30040 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) goto fail;
30041 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30042 if (SWIG_arg_fail(1)) SWIG_fail;
30043 {
30044 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCursor, SWIG_POINTER_EXCEPTION | 0);
30045 if (SWIG_arg_fail(2)) SWIG_fail;
30046 if (arg2 == NULL) {
30047 SWIG_null_ref("wxCursor");
30048 }
30049 if (SWIG_arg_fail(2)) SWIG_fail;
30050 }
30051 {
30052 PyThreadState* __tstate = wxPyBeginAllowThreads();
30053 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
30054
30055 wxPyEndAllowThreads(__tstate);
30056 if (PyErr_Occurred()) SWIG_fail;
30057 }
30058 {
30059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30060 }
30061 return resultobj;
30062 fail:
30063 return NULL;
30064 }
30065
30066
30067 static PyObject *_wrap_Window_GetCursor(PyObject *, PyObject *args, PyObject *kwargs) {
30068 PyObject *resultobj;
30069 wxWindow *arg1 = (wxWindow *) 0 ;
30070 wxCursor result;
30071 PyObject * obj0 = 0 ;
30072 char *kwnames[] = {
30073 (char *) "self", NULL
30074 };
30075
30076 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCursor",kwnames,&obj0)) goto fail;
30077 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30078 if (SWIG_arg_fail(1)) SWIG_fail;
30079 {
30080 PyThreadState* __tstate = wxPyBeginAllowThreads();
30081 result = (arg1)->GetCursor();
30082
30083 wxPyEndAllowThreads(__tstate);
30084 if (PyErr_Occurred()) SWIG_fail;
30085 }
30086 {
30087 wxCursor * resultptr;
30088 resultptr = new wxCursor((wxCursor &)(result));
30089 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxCursor, 1);
30090 }
30091 return resultobj;
30092 fail:
30093 return NULL;
30094 }
30095
30096
30097 static PyObject *_wrap_Window_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30098 PyObject *resultobj;
30099 wxWindow *arg1 = (wxWindow *) 0 ;
30100 wxFont *arg2 = 0 ;
30101 bool result;
30102 PyObject * obj0 = 0 ;
30103 PyObject * obj1 = 0 ;
30104 char *kwnames[] = {
30105 (char *) "self",(char *) "font", NULL
30106 };
30107
30108 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) goto fail;
30109 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30110 if (SWIG_arg_fail(1)) SWIG_fail;
30111 {
30112 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30113 if (SWIG_arg_fail(2)) SWIG_fail;
30114 if (arg2 == NULL) {
30115 SWIG_null_ref("wxFont");
30116 }
30117 if (SWIG_arg_fail(2)) SWIG_fail;
30118 }
30119 {
30120 PyThreadState* __tstate = wxPyBeginAllowThreads();
30121 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
30122
30123 wxPyEndAllowThreads(__tstate);
30124 if (PyErr_Occurred()) SWIG_fail;
30125 }
30126 {
30127 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30128 }
30129 return resultobj;
30130 fail:
30131 return NULL;
30132 }
30133
30134
30135 static PyObject *_wrap_Window_SetOwnFont(PyObject *, PyObject *args, PyObject *kwargs) {
30136 PyObject *resultobj;
30137 wxWindow *arg1 = (wxWindow *) 0 ;
30138 wxFont *arg2 = 0 ;
30139 PyObject * obj0 = 0 ;
30140 PyObject * obj1 = 0 ;
30141 char *kwnames[] = {
30142 (char *) "self",(char *) "font", NULL
30143 };
30144
30145 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) goto fail;
30146 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30147 if (SWIG_arg_fail(1)) SWIG_fail;
30148 {
30149 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30150 if (SWIG_arg_fail(2)) SWIG_fail;
30151 if (arg2 == NULL) {
30152 SWIG_null_ref("wxFont");
30153 }
30154 if (SWIG_arg_fail(2)) SWIG_fail;
30155 }
30156 {
30157 PyThreadState* __tstate = wxPyBeginAllowThreads();
30158 (arg1)->SetOwnFont((wxFont const &)*arg2);
30159
30160 wxPyEndAllowThreads(__tstate);
30161 if (PyErr_Occurred()) SWIG_fail;
30162 }
30163 Py_INCREF(Py_None); resultobj = Py_None;
30164 return resultobj;
30165 fail:
30166 return NULL;
30167 }
30168
30169
30170 static PyObject *_wrap_Window_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
30171 PyObject *resultobj;
30172 wxWindow *arg1 = (wxWindow *) 0 ;
30173 wxFont result;
30174 PyObject * obj0 = 0 ;
30175 char *kwnames[] = {
30176 (char *) "self", NULL
30177 };
30178
30179 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetFont",kwnames,&obj0)) goto fail;
30180 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30181 if (SWIG_arg_fail(1)) SWIG_fail;
30182 {
30183 PyThreadState* __tstate = wxPyBeginAllowThreads();
30184 result = (arg1)->GetFont();
30185
30186 wxPyEndAllowThreads(__tstate);
30187 if (PyErr_Occurred()) SWIG_fail;
30188 }
30189 {
30190 wxFont * resultptr;
30191 resultptr = new wxFont((wxFont &)(result));
30192 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
30193 }
30194 return resultobj;
30195 fail:
30196 return NULL;
30197 }
30198
30199
30200 static PyObject *_wrap_Window_SetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30201 PyObject *resultobj;
30202 wxWindow *arg1 = (wxWindow *) 0 ;
30203 wxCaret *arg2 = (wxCaret *) 0 ;
30204 PyObject * obj0 = 0 ;
30205 PyObject * obj1 = 0 ;
30206 char *kwnames[] = {
30207 (char *) "self",(char *) "caret", NULL
30208 };
30209
30210 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) goto fail;
30211 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30212 if (SWIG_arg_fail(1)) SWIG_fail;
30213 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCaret, SWIG_POINTER_EXCEPTION | 0);
30214 if (SWIG_arg_fail(2)) SWIG_fail;
30215 {
30216 PyThreadState* __tstate = wxPyBeginAllowThreads();
30217 (arg1)->SetCaret(arg2);
30218
30219 wxPyEndAllowThreads(__tstate);
30220 if (PyErr_Occurred()) SWIG_fail;
30221 }
30222 Py_INCREF(Py_None); resultobj = Py_None;
30223 return resultobj;
30224 fail:
30225 return NULL;
30226 }
30227
30228
30229 static PyObject *_wrap_Window_GetCaret(PyObject *, PyObject *args, PyObject *kwargs) {
30230 PyObject *resultobj;
30231 wxWindow *arg1 = (wxWindow *) 0 ;
30232 wxCaret *result;
30233 PyObject * obj0 = 0 ;
30234 char *kwnames[] = {
30235 (char *) "self", NULL
30236 };
30237
30238 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCaret",kwnames,&obj0)) goto fail;
30239 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30240 if (SWIG_arg_fail(1)) SWIG_fail;
30241 {
30242 PyThreadState* __tstate = wxPyBeginAllowThreads();
30243 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
30244
30245 wxPyEndAllowThreads(__tstate);
30246 if (PyErr_Occurred()) SWIG_fail;
30247 }
30248 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxCaret, 0);
30249 return resultobj;
30250 fail:
30251 return NULL;
30252 }
30253
30254
30255 static PyObject *_wrap_Window_GetCharHeight(PyObject *, PyObject *args, PyObject *kwargs) {
30256 PyObject *resultobj;
30257 wxWindow *arg1 = (wxWindow *) 0 ;
30258 int result;
30259 PyObject * obj0 = 0 ;
30260 char *kwnames[] = {
30261 (char *) "self", NULL
30262 };
30263
30264 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharHeight",kwnames,&obj0)) goto fail;
30265 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30266 if (SWIG_arg_fail(1)) SWIG_fail;
30267 {
30268 PyThreadState* __tstate = wxPyBeginAllowThreads();
30269 result = (int)((wxWindow const *)arg1)->GetCharHeight();
30270
30271 wxPyEndAllowThreads(__tstate);
30272 if (PyErr_Occurred()) SWIG_fail;
30273 }
30274 {
30275 resultobj = SWIG_From_int((int)(result));
30276 }
30277 return resultobj;
30278 fail:
30279 return NULL;
30280 }
30281
30282
30283 static PyObject *_wrap_Window_GetCharWidth(PyObject *, PyObject *args, PyObject *kwargs) {
30284 PyObject *resultobj;
30285 wxWindow *arg1 = (wxWindow *) 0 ;
30286 int result;
30287 PyObject * obj0 = 0 ;
30288 char *kwnames[] = {
30289 (char *) "self", NULL
30290 };
30291
30292 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetCharWidth",kwnames,&obj0)) goto fail;
30293 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30294 if (SWIG_arg_fail(1)) SWIG_fail;
30295 {
30296 PyThreadState* __tstate = wxPyBeginAllowThreads();
30297 result = (int)((wxWindow const *)arg1)->GetCharWidth();
30298
30299 wxPyEndAllowThreads(__tstate);
30300 if (PyErr_Occurred()) SWIG_fail;
30301 }
30302 {
30303 resultobj = SWIG_From_int((int)(result));
30304 }
30305 return resultobj;
30306 fail:
30307 return NULL;
30308 }
30309
30310
30311 static PyObject *_wrap_Window_GetTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30312 PyObject *resultobj;
30313 wxWindow *arg1 = (wxWindow *) 0 ;
30314 wxString *arg2 = 0 ;
30315 int *arg3 = (int *) 0 ;
30316 int *arg4 = (int *) 0 ;
30317 bool temp2 = false ;
30318 int temp3 ;
30319 int res3 = 0 ;
30320 int temp4 ;
30321 int res4 = 0 ;
30322 PyObject * obj0 = 0 ;
30323 PyObject * obj1 = 0 ;
30324 char *kwnames[] = {
30325 (char *) "self",(char *) "string", NULL
30326 };
30327
30328 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30329 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30330 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) goto fail;
30331 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30332 if (SWIG_arg_fail(1)) SWIG_fail;
30333 {
30334 arg2 = wxString_in_helper(obj1);
30335 if (arg2 == NULL) SWIG_fail;
30336 temp2 = true;
30337 }
30338 {
30339 PyThreadState* __tstate = wxPyBeginAllowThreads();
30340 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
30341
30342 wxPyEndAllowThreads(__tstate);
30343 if (PyErr_Occurred()) SWIG_fail;
30344 }
30345 Py_INCREF(Py_None); resultobj = Py_None;
30346 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30347 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30348 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30349 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30350 {
30351 if (temp2)
30352 delete arg2;
30353 }
30354 return resultobj;
30355 fail:
30356 {
30357 if (temp2)
30358 delete arg2;
30359 }
30360 return NULL;
30361 }
30362
30363
30364 static PyObject *_wrap_Window_GetFullTextExtent(PyObject *, PyObject *args, PyObject *kwargs) {
30365 PyObject *resultobj;
30366 wxWindow *arg1 = (wxWindow *) 0 ;
30367 wxString *arg2 = 0 ;
30368 int *arg3 = (int *) 0 ;
30369 int *arg4 = (int *) 0 ;
30370 int *arg5 = (int *) 0 ;
30371 int *arg6 = (int *) 0 ;
30372 wxFont *arg7 = (wxFont *) NULL ;
30373 bool temp2 = false ;
30374 int temp3 ;
30375 int res3 = 0 ;
30376 int temp4 ;
30377 int res4 = 0 ;
30378 int temp5 ;
30379 int res5 = 0 ;
30380 int temp6 ;
30381 int res6 = 0 ;
30382 PyObject * obj0 = 0 ;
30383 PyObject * obj1 = 0 ;
30384 PyObject * obj2 = 0 ;
30385 char *kwnames[] = {
30386 (char *) "self",(char *) "string",(char *) "font", NULL
30387 };
30388
30389 arg3 = &temp3; res3 = SWIG_NEWOBJ;
30390 arg4 = &temp4; res4 = SWIG_NEWOBJ;
30391 arg5 = &temp5; res5 = SWIG_NEWOBJ;
30392 arg6 = &temp6; res6 = SWIG_NEWOBJ;
30393 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) goto fail;
30394 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30395 if (SWIG_arg_fail(1)) SWIG_fail;
30396 {
30397 arg2 = wxString_in_helper(obj1);
30398 if (arg2 == NULL) SWIG_fail;
30399 temp2 = true;
30400 }
30401 if (obj2) {
30402 SWIG_Python_ConvertPtr(obj2, (void **)&arg7, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
30403 if (SWIG_arg_fail(7)) SWIG_fail;
30404 }
30405 {
30406 PyThreadState* __tstate = wxPyBeginAllowThreads();
30407 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
30408
30409 wxPyEndAllowThreads(__tstate);
30410 if (PyErr_Occurred()) SWIG_fail;
30411 }
30412 Py_INCREF(Py_None); resultobj = Py_None;
30413 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30414 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30415 resultobj = t_output_helper(resultobj, ((res4 == SWIG_NEWOBJ) ?
30416 SWIG_From_int((*arg4)) : SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, 0)));
30417 resultobj = t_output_helper(resultobj, ((res5 == SWIG_NEWOBJ) ?
30418 SWIG_From_int((*arg5)) : SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, 0)));
30419 resultobj = t_output_helper(resultobj, ((res6 == SWIG_NEWOBJ) ?
30420 SWIG_From_int((*arg6)) : SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, 0)));
30421 {
30422 if (temp2)
30423 delete arg2;
30424 }
30425 return resultobj;
30426 fail:
30427 {
30428 if (temp2)
30429 delete arg2;
30430 }
30431 return NULL;
30432 }
30433
30434
30435 static PyObject *_wrap_Window_ClientToScreenXY(PyObject *, PyObject *args, PyObject *kwargs) {
30436 PyObject *resultobj;
30437 wxWindow *arg1 = (wxWindow *) 0 ;
30438 int *arg2 = (int *) 0 ;
30439 int *arg3 = (int *) 0 ;
30440 int temp2 ;
30441 int res2 = 0 ;
30442 int temp3 ;
30443 int res3 = 0 ;
30444 PyObject * obj0 = 0 ;
30445 PyObject * obj1 = 0 ;
30446 PyObject * obj2 = 0 ;
30447 char *kwnames[] = {
30448 (char *) "self",(char *) "x",(char *) "y", NULL
30449 };
30450
30451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30453 if (SWIG_arg_fail(1)) SWIG_fail;
30454 {
30455 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30456 temp2 = SWIG_As_int(obj1);
30457 if (SWIG_arg_fail(2)) SWIG_fail;
30458 arg2 = &temp2;
30459 res2 = SWIG_NEWOBJ;
30460 }
30461 }
30462 {
30463 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30464 temp3 = SWIG_As_int(obj2);
30465 if (SWIG_arg_fail(3)) SWIG_fail;
30466 arg3 = &temp3;
30467 res3 = SWIG_NEWOBJ;
30468 }
30469 }
30470 {
30471 PyThreadState* __tstate = wxPyBeginAllowThreads();
30472 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
30473
30474 wxPyEndAllowThreads(__tstate);
30475 if (PyErr_Occurred()) SWIG_fail;
30476 }
30477 Py_INCREF(Py_None); resultobj = Py_None;
30478 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30479 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30480 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30481 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30482 return resultobj;
30483 fail:
30484 return NULL;
30485 }
30486
30487
30488 static PyObject *_wrap_Window_ScreenToClientXY(PyObject *, PyObject *args, PyObject *kwargs) {
30489 PyObject *resultobj;
30490 wxWindow *arg1 = (wxWindow *) 0 ;
30491 int *arg2 = (int *) 0 ;
30492 int *arg3 = (int *) 0 ;
30493 int temp2 ;
30494 int res2 = 0 ;
30495 int temp3 ;
30496 int res3 = 0 ;
30497 PyObject * obj0 = 0 ;
30498 PyObject * obj1 = 0 ;
30499 PyObject * obj2 = 0 ;
30500 char *kwnames[] = {
30501 (char *) "self",(char *) "x",(char *) "y", NULL
30502 };
30503
30504 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30505 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30506 if (SWIG_arg_fail(1)) SWIG_fail;
30507 {
30508 if (!(SWIG_ConvertPtr(obj1,(void **)(&arg2),SWIGTYPE_p_int,0) != -1)) {
30509 temp2 = SWIG_As_int(obj1);
30510 if (SWIG_arg_fail(2)) SWIG_fail;
30511 arg2 = &temp2;
30512 res2 = SWIG_NEWOBJ;
30513 }
30514 }
30515 {
30516 if (!(SWIG_ConvertPtr(obj2,(void **)(&arg3),SWIGTYPE_p_int,0) != -1)) {
30517 temp3 = SWIG_As_int(obj2);
30518 if (SWIG_arg_fail(3)) SWIG_fail;
30519 arg3 = &temp3;
30520 res3 = SWIG_NEWOBJ;
30521 }
30522 }
30523 {
30524 PyThreadState* __tstate = wxPyBeginAllowThreads();
30525 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
30526
30527 wxPyEndAllowThreads(__tstate);
30528 if (PyErr_Occurred()) SWIG_fail;
30529 }
30530 Py_INCREF(Py_None); resultobj = Py_None;
30531 resultobj = t_output_helper(resultobj, ((res2 == SWIG_NEWOBJ) ?
30532 SWIG_From_int((*arg2)) : SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, 0)));
30533 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
30534 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
30535 return resultobj;
30536 fail:
30537 return NULL;
30538 }
30539
30540
30541 static PyObject *_wrap_Window_ClientToScreen(PyObject *, PyObject *args, PyObject *kwargs) {
30542 PyObject *resultobj;
30543 wxWindow *arg1 = (wxWindow *) 0 ;
30544 wxPoint *arg2 = 0 ;
30545 wxPoint result;
30546 wxPoint temp2 ;
30547 PyObject * obj0 = 0 ;
30548 PyObject * obj1 = 0 ;
30549 char *kwnames[] = {
30550 (char *) "self",(char *) "pt", NULL
30551 };
30552
30553 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) goto fail;
30554 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30555 if (SWIG_arg_fail(1)) SWIG_fail;
30556 {
30557 arg2 = &temp2;
30558 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30559 }
30560 {
30561 PyThreadState* __tstate = wxPyBeginAllowThreads();
30562 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
30563
30564 wxPyEndAllowThreads(__tstate);
30565 if (PyErr_Occurred()) SWIG_fail;
30566 }
30567 {
30568 wxPoint * resultptr;
30569 resultptr = new wxPoint((wxPoint &)(result));
30570 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30571 }
30572 return resultobj;
30573 fail:
30574 return NULL;
30575 }
30576
30577
30578 static PyObject *_wrap_Window_ScreenToClient(PyObject *, PyObject *args, PyObject *kwargs) {
30579 PyObject *resultobj;
30580 wxWindow *arg1 = (wxWindow *) 0 ;
30581 wxPoint *arg2 = 0 ;
30582 wxPoint result;
30583 wxPoint temp2 ;
30584 PyObject * obj0 = 0 ;
30585 PyObject * obj1 = 0 ;
30586 char *kwnames[] = {
30587 (char *) "self",(char *) "pt", NULL
30588 };
30589
30590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",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 arg2 = &temp2;
30595 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30596 }
30597 {
30598 PyThreadState* __tstate = wxPyBeginAllowThreads();
30599 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
30600
30601 wxPyEndAllowThreads(__tstate);
30602 if (PyErr_Occurred()) SWIG_fail;
30603 }
30604 {
30605 wxPoint * resultptr;
30606 resultptr = new wxPoint((wxPoint &)(result));
30607 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
30608 }
30609 return resultobj;
30610 fail:
30611 return NULL;
30612 }
30613
30614
30615 static PyObject *_wrap_Window_HitTestXY(PyObject *, PyObject *args, PyObject *kwargs) {
30616 PyObject *resultobj;
30617 wxWindow *arg1 = (wxWindow *) 0 ;
30618 int arg2 ;
30619 int arg3 ;
30620 wxHitTest result;
30621 PyObject * obj0 = 0 ;
30622 PyObject * obj1 = 0 ;
30623 PyObject * obj2 = 0 ;
30624 char *kwnames[] = {
30625 (char *) "self",(char *) "x",(char *) "y", NULL
30626 };
30627
30628 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) goto fail;
30629 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30630 if (SWIG_arg_fail(1)) SWIG_fail;
30631 {
30632 arg2 = (int)(SWIG_As_int(obj1));
30633 if (SWIG_arg_fail(2)) SWIG_fail;
30634 }
30635 {
30636 arg3 = (int)(SWIG_As_int(obj2));
30637 if (SWIG_arg_fail(3)) SWIG_fail;
30638 }
30639 {
30640 PyThreadState* __tstate = wxPyBeginAllowThreads();
30641 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
30642
30643 wxPyEndAllowThreads(__tstate);
30644 if (PyErr_Occurred()) SWIG_fail;
30645 }
30646 resultobj = SWIG_From_int((result));
30647 return resultobj;
30648 fail:
30649 return NULL;
30650 }
30651
30652
30653 static PyObject *_wrap_Window_HitTest(PyObject *, PyObject *args, PyObject *kwargs) {
30654 PyObject *resultobj;
30655 wxWindow *arg1 = (wxWindow *) 0 ;
30656 wxPoint *arg2 = 0 ;
30657 wxHitTest result;
30658 wxPoint temp2 ;
30659 PyObject * obj0 = 0 ;
30660 PyObject * obj1 = 0 ;
30661 char *kwnames[] = {
30662 (char *) "self",(char *) "pt", NULL
30663 };
30664
30665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) goto fail;
30666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30667 if (SWIG_arg_fail(1)) SWIG_fail;
30668 {
30669 arg2 = &temp2;
30670 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30671 }
30672 {
30673 PyThreadState* __tstate = wxPyBeginAllowThreads();
30674 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
30675
30676 wxPyEndAllowThreads(__tstate);
30677 if (PyErr_Occurred()) SWIG_fail;
30678 }
30679 resultobj = SWIG_From_int((result));
30680 return resultobj;
30681 fail:
30682 return NULL;
30683 }
30684
30685
30686 static PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *, PyObject *args) {
30687 PyObject *resultobj;
30688 wxWindow *arg1 = (wxWindow *) 0 ;
30689 long arg2 ;
30690 wxBorder result;
30691 PyObject * obj0 = 0 ;
30692 PyObject * obj1 = 0 ;
30693
30694 if(!PyArg_ParseTuple(args,(char *)"OO:Window_GetBorder",&obj0,&obj1)) goto fail;
30695 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30696 if (SWIG_arg_fail(1)) SWIG_fail;
30697 {
30698 arg2 = (long)(SWIG_As_long(obj1));
30699 if (SWIG_arg_fail(2)) SWIG_fail;
30700 }
30701 {
30702 PyThreadState* __tstate = wxPyBeginAllowThreads();
30703 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
30704
30705 wxPyEndAllowThreads(__tstate);
30706 if (PyErr_Occurred()) SWIG_fail;
30707 }
30708 resultobj = SWIG_From_int((result));
30709 return resultobj;
30710 fail:
30711 return NULL;
30712 }
30713
30714
30715 static PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *, PyObject *args) {
30716 PyObject *resultobj;
30717 wxWindow *arg1 = (wxWindow *) 0 ;
30718 wxBorder result;
30719 PyObject * obj0 = 0 ;
30720
30721 if(!PyArg_ParseTuple(args,(char *)"O:Window_GetBorder",&obj0)) goto fail;
30722 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30723 if (SWIG_arg_fail(1)) SWIG_fail;
30724 {
30725 PyThreadState* __tstate = wxPyBeginAllowThreads();
30726 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
30727
30728 wxPyEndAllowThreads(__tstate);
30729 if (PyErr_Occurred()) SWIG_fail;
30730 }
30731 resultobj = SWIG_From_int((result));
30732 return resultobj;
30733 fail:
30734 return NULL;
30735 }
30736
30737
30738 static PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
30739 int argc;
30740 PyObject *argv[3];
30741 int ii;
30742
30743 argc = PyObject_Length(args);
30744 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
30745 argv[ii] = PyTuple_GetItem(args,ii);
30746 }
30747 if (argc == 1) {
30748 int _v;
30749 {
30750 void *ptr;
30751 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30752 _v = 0;
30753 PyErr_Clear();
30754 } else {
30755 _v = 1;
30756 }
30757 }
30758 if (_v) {
30759 return _wrap_Window_GetBorder__SWIG_1(self,args);
30760 }
30761 }
30762 if (argc == 2) {
30763 int _v;
30764 {
30765 void *ptr;
30766 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
30767 _v = 0;
30768 PyErr_Clear();
30769 } else {
30770 _v = 1;
30771 }
30772 }
30773 if (_v) {
30774 _v = SWIG_Check_long(argv[1]);
30775 if (_v) {
30776 return _wrap_Window_GetBorder__SWIG_0(self,args);
30777 }
30778 }
30779 }
30780
30781 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
30782 return NULL;
30783 }
30784
30785
30786 static PyObject *_wrap_Window_UpdateWindowUI(PyObject *, PyObject *args, PyObject *kwargs) {
30787 PyObject *resultobj;
30788 wxWindow *arg1 = (wxWindow *) 0 ;
30789 long arg2 = (long) wxUPDATE_UI_NONE ;
30790 PyObject * obj0 = 0 ;
30791 PyObject * obj1 = 0 ;
30792 char *kwnames[] = {
30793 (char *) "self",(char *) "flags", NULL
30794 };
30795
30796 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) goto fail;
30797 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30798 if (SWIG_arg_fail(1)) SWIG_fail;
30799 if (obj1) {
30800 {
30801 arg2 = (long)(SWIG_As_long(obj1));
30802 if (SWIG_arg_fail(2)) SWIG_fail;
30803 }
30804 }
30805 {
30806 PyThreadState* __tstate = wxPyBeginAllowThreads();
30807 (arg1)->UpdateWindowUI(arg2);
30808
30809 wxPyEndAllowThreads(__tstate);
30810 if (PyErr_Occurred()) SWIG_fail;
30811 }
30812 Py_INCREF(Py_None); resultobj = Py_None;
30813 return resultobj;
30814 fail:
30815 return NULL;
30816 }
30817
30818
30819 static PyObject *_wrap_Window_PopupMenuXY(PyObject *, PyObject *args, PyObject *kwargs) {
30820 PyObject *resultobj;
30821 wxWindow *arg1 = (wxWindow *) 0 ;
30822 wxMenu *arg2 = (wxMenu *) 0 ;
30823 int arg3 = (int) -1 ;
30824 int arg4 = (int) -1 ;
30825 bool result;
30826 PyObject * obj0 = 0 ;
30827 PyObject * obj1 = 0 ;
30828 PyObject * obj2 = 0 ;
30829 PyObject * obj3 = 0 ;
30830 char *kwnames[] = {
30831 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
30832 };
30833
30834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
30835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30836 if (SWIG_arg_fail(1)) SWIG_fail;
30837 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30838 if (SWIG_arg_fail(2)) SWIG_fail;
30839 if (obj2) {
30840 {
30841 arg3 = (int)(SWIG_As_int(obj2));
30842 if (SWIG_arg_fail(3)) SWIG_fail;
30843 }
30844 }
30845 if (obj3) {
30846 {
30847 arg4 = (int)(SWIG_As_int(obj3));
30848 if (SWIG_arg_fail(4)) SWIG_fail;
30849 }
30850 }
30851 {
30852 PyThreadState* __tstate = wxPyBeginAllowThreads();
30853 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
30854
30855 wxPyEndAllowThreads(__tstate);
30856 if (PyErr_Occurred()) SWIG_fail;
30857 }
30858 {
30859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30860 }
30861 return resultobj;
30862 fail:
30863 return NULL;
30864 }
30865
30866
30867 static PyObject *_wrap_Window_PopupMenu(PyObject *, PyObject *args, PyObject *kwargs) {
30868 PyObject *resultobj;
30869 wxWindow *arg1 = (wxWindow *) 0 ;
30870 wxMenu *arg2 = (wxMenu *) 0 ;
30871 wxPoint const &arg3_defvalue = wxDefaultPosition ;
30872 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
30873 bool result;
30874 wxPoint temp3 ;
30875 PyObject * obj0 = 0 ;
30876 PyObject * obj1 = 0 ;
30877 PyObject * obj2 = 0 ;
30878 char *kwnames[] = {
30879 (char *) "self",(char *) "menu",(char *) "pos", NULL
30880 };
30881
30882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) goto fail;
30883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30884 if (SWIG_arg_fail(1)) SWIG_fail;
30885 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
30886 if (SWIG_arg_fail(2)) SWIG_fail;
30887 if (obj2) {
30888 {
30889 arg3 = &temp3;
30890 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
30891 }
30892 }
30893 {
30894 PyThreadState* __tstate = wxPyBeginAllowThreads();
30895 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
30896
30897 wxPyEndAllowThreads(__tstate);
30898 if (PyErr_Occurred()) SWIG_fail;
30899 }
30900 {
30901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30902 }
30903 return resultobj;
30904 fail:
30905 return NULL;
30906 }
30907
30908
30909 static PyObject *_wrap_Window_GetHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30910 PyObject *resultobj;
30911 wxWindow *arg1 = (wxWindow *) 0 ;
30912 long result;
30913 PyObject * obj0 = 0 ;
30914 char *kwnames[] = {
30915 (char *) "self", NULL
30916 };
30917
30918 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHandle",kwnames,&obj0)) goto fail;
30919 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30920 if (SWIG_arg_fail(1)) SWIG_fail;
30921 {
30922 PyThreadState* __tstate = wxPyBeginAllowThreads();
30923 result = (long)wxWindow_GetHandle(arg1);
30924
30925 wxPyEndAllowThreads(__tstate);
30926 if (PyErr_Occurred()) SWIG_fail;
30927 }
30928 {
30929 resultobj = SWIG_From_long((long)(result));
30930 }
30931 return resultobj;
30932 fail:
30933 return NULL;
30934 }
30935
30936
30937 static PyObject *_wrap_Window_AssociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30938 PyObject *resultobj;
30939 wxWindow *arg1 = (wxWindow *) 0 ;
30940 long arg2 ;
30941 PyObject * obj0 = 0 ;
30942 PyObject * obj1 = 0 ;
30943 char *kwnames[] = {
30944 (char *) "self",(char *) "handle", NULL
30945 };
30946
30947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) goto fail;
30948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30949 if (SWIG_arg_fail(1)) SWIG_fail;
30950 {
30951 arg2 = (long)(SWIG_As_long(obj1));
30952 if (SWIG_arg_fail(2)) SWIG_fail;
30953 }
30954 {
30955 PyThreadState* __tstate = wxPyBeginAllowThreads();
30956 wxWindow_AssociateHandle(arg1,arg2);
30957
30958 wxPyEndAllowThreads(__tstate);
30959 if (PyErr_Occurred()) SWIG_fail;
30960 }
30961 Py_INCREF(Py_None); resultobj = Py_None;
30962 return resultobj;
30963 fail:
30964 return NULL;
30965 }
30966
30967
30968 static PyObject *_wrap_Window_DissociateHandle(PyObject *, PyObject *args, PyObject *kwargs) {
30969 PyObject *resultobj;
30970 wxWindow *arg1 = (wxWindow *) 0 ;
30971 PyObject * obj0 = 0 ;
30972 char *kwnames[] = {
30973 (char *) "self", NULL
30974 };
30975
30976 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_DissociateHandle",kwnames,&obj0)) goto fail;
30977 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
30978 if (SWIG_arg_fail(1)) SWIG_fail;
30979 {
30980 PyThreadState* __tstate = wxPyBeginAllowThreads();
30981 (arg1)->DissociateHandle();
30982
30983 wxPyEndAllowThreads(__tstate);
30984 if (PyErr_Occurred()) SWIG_fail;
30985 }
30986 Py_INCREF(Py_None); resultobj = Py_None;
30987 return resultobj;
30988 fail:
30989 return NULL;
30990 }
30991
30992
30993 static PyObject *_wrap_Window_HasScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
30994 PyObject *resultobj;
30995 wxWindow *arg1 = (wxWindow *) 0 ;
30996 int arg2 ;
30997 bool result;
30998 PyObject * obj0 = 0 ;
30999 PyObject * obj1 = 0 ;
31000 char *kwnames[] = {
31001 (char *) "self",(char *) "orient", NULL
31002 };
31003
31004 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) goto fail;
31005 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31006 if (SWIG_arg_fail(1)) SWIG_fail;
31007 {
31008 arg2 = (int)(SWIG_As_int(obj1));
31009 if (SWIG_arg_fail(2)) SWIG_fail;
31010 }
31011 {
31012 PyThreadState* __tstate = wxPyBeginAllowThreads();
31013 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
31014
31015 wxPyEndAllowThreads(__tstate);
31016 if (PyErr_Occurred()) SWIG_fail;
31017 }
31018 {
31019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31020 }
31021 return resultobj;
31022 fail:
31023 return NULL;
31024 }
31025
31026
31027 static PyObject *_wrap_Window_SetScrollbar(PyObject *, PyObject *args, PyObject *kwargs) {
31028 PyObject *resultobj;
31029 wxWindow *arg1 = (wxWindow *) 0 ;
31030 int arg2 ;
31031 int arg3 ;
31032 int arg4 ;
31033 int arg5 ;
31034 bool arg6 = (bool) true ;
31035 PyObject * obj0 = 0 ;
31036 PyObject * obj1 = 0 ;
31037 PyObject * obj2 = 0 ;
31038 PyObject * obj3 = 0 ;
31039 PyObject * obj4 = 0 ;
31040 PyObject * obj5 = 0 ;
31041 char *kwnames[] = {
31042 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
31043 };
31044
31045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
31046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31047 if (SWIG_arg_fail(1)) SWIG_fail;
31048 {
31049 arg2 = (int)(SWIG_As_int(obj1));
31050 if (SWIG_arg_fail(2)) SWIG_fail;
31051 }
31052 {
31053 arg3 = (int)(SWIG_As_int(obj2));
31054 if (SWIG_arg_fail(3)) SWIG_fail;
31055 }
31056 {
31057 arg4 = (int)(SWIG_As_int(obj3));
31058 if (SWIG_arg_fail(4)) SWIG_fail;
31059 }
31060 {
31061 arg5 = (int)(SWIG_As_int(obj4));
31062 if (SWIG_arg_fail(5)) SWIG_fail;
31063 }
31064 if (obj5) {
31065 {
31066 arg6 = (bool)(SWIG_As_bool(obj5));
31067 if (SWIG_arg_fail(6)) SWIG_fail;
31068 }
31069 }
31070 {
31071 PyThreadState* __tstate = wxPyBeginAllowThreads();
31072 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
31073
31074 wxPyEndAllowThreads(__tstate);
31075 if (PyErr_Occurred()) SWIG_fail;
31076 }
31077 Py_INCREF(Py_None); resultobj = Py_None;
31078 return resultobj;
31079 fail:
31080 return NULL;
31081 }
31082
31083
31084 static PyObject *_wrap_Window_SetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31085 PyObject *resultobj;
31086 wxWindow *arg1 = (wxWindow *) 0 ;
31087 int arg2 ;
31088 int arg3 ;
31089 bool arg4 = (bool) true ;
31090 PyObject * obj0 = 0 ;
31091 PyObject * obj1 = 0 ;
31092 PyObject * obj2 = 0 ;
31093 PyObject * obj3 = 0 ;
31094 char *kwnames[] = {
31095 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
31096 };
31097
31098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31100 if (SWIG_arg_fail(1)) SWIG_fail;
31101 {
31102 arg2 = (int)(SWIG_As_int(obj1));
31103 if (SWIG_arg_fail(2)) SWIG_fail;
31104 }
31105 {
31106 arg3 = (int)(SWIG_As_int(obj2));
31107 if (SWIG_arg_fail(3)) SWIG_fail;
31108 }
31109 if (obj3) {
31110 {
31111 arg4 = (bool)(SWIG_As_bool(obj3));
31112 if (SWIG_arg_fail(4)) SWIG_fail;
31113 }
31114 }
31115 {
31116 PyThreadState* __tstate = wxPyBeginAllowThreads();
31117 (arg1)->SetScrollPos(arg2,arg3,arg4);
31118
31119 wxPyEndAllowThreads(__tstate);
31120 if (PyErr_Occurred()) SWIG_fail;
31121 }
31122 Py_INCREF(Py_None); resultobj = Py_None;
31123 return resultobj;
31124 fail:
31125 return NULL;
31126 }
31127
31128
31129 static PyObject *_wrap_Window_GetScrollPos(PyObject *, PyObject *args, PyObject *kwargs) {
31130 PyObject *resultobj;
31131 wxWindow *arg1 = (wxWindow *) 0 ;
31132 int arg2 ;
31133 int result;
31134 PyObject * obj0 = 0 ;
31135 PyObject * obj1 = 0 ;
31136 char *kwnames[] = {
31137 (char *) "self",(char *) "orientation", NULL
31138 };
31139
31140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) goto fail;
31141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31142 if (SWIG_arg_fail(1)) SWIG_fail;
31143 {
31144 arg2 = (int)(SWIG_As_int(obj1));
31145 if (SWIG_arg_fail(2)) SWIG_fail;
31146 }
31147 {
31148 PyThreadState* __tstate = wxPyBeginAllowThreads();
31149 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
31150
31151 wxPyEndAllowThreads(__tstate);
31152 if (PyErr_Occurred()) SWIG_fail;
31153 }
31154 {
31155 resultobj = SWIG_From_int((int)(result));
31156 }
31157 return resultobj;
31158 fail:
31159 return NULL;
31160 }
31161
31162
31163 static PyObject *_wrap_Window_GetScrollThumb(PyObject *, PyObject *args, PyObject *kwargs) {
31164 PyObject *resultobj;
31165 wxWindow *arg1 = (wxWindow *) 0 ;
31166 int arg2 ;
31167 int result;
31168 PyObject * obj0 = 0 ;
31169 PyObject * obj1 = 0 ;
31170 char *kwnames[] = {
31171 (char *) "self",(char *) "orientation", NULL
31172 };
31173
31174 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) goto fail;
31175 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31176 if (SWIG_arg_fail(1)) SWIG_fail;
31177 {
31178 arg2 = (int)(SWIG_As_int(obj1));
31179 if (SWIG_arg_fail(2)) SWIG_fail;
31180 }
31181 {
31182 PyThreadState* __tstate = wxPyBeginAllowThreads();
31183 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
31184
31185 wxPyEndAllowThreads(__tstate);
31186 if (PyErr_Occurred()) SWIG_fail;
31187 }
31188 {
31189 resultobj = SWIG_From_int((int)(result));
31190 }
31191 return resultobj;
31192 fail:
31193 return NULL;
31194 }
31195
31196
31197 static PyObject *_wrap_Window_GetScrollRange(PyObject *, PyObject *args, PyObject *kwargs) {
31198 PyObject *resultobj;
31199 wxWindow *arg1 = (wxWindow *) 0 ;
31200 int arg2 ;
31201 int result;
31202 PyObject * obj0 = 0 ;
31203 PyObject * obj1 = 0 ;
31204 char *kwnames[] = {
31205 (char *) "self",(char *) "orientation", NULL
31206 };
31207
31208 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) goto fail;
31209 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31210 if (SWIG_arg_fail(1)) SWIG_fail;
31211 {
31212 arg2 = (int)(SWIG_As_int(obj1));
31213 if (SWIG_arg_fail(2)) SWIG_fail;
31214 }
31215 {
31216 PyThreadState* __tstate = wxPyBeginAllowThreads();
31217 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
31218
31219 wxPyEndAllowThreads(__tstate);
31220 if (PyErr_Occurred()) SWIG_fail;
31221 }
31222 {
31223 resultobj = SWIG_From_int((int)(result));
31224 }
31225 return resultobj;
31226 fail:
31227 return NULL;
31228 }
31229
31230
31231 static PyObject *_wrap_Window_ScrollWindow(PyObject *, PyObject *args, PyObject *kwargs) {
31232 PyObject *resultobj;
31233 wxWindow *arg1 = (wxWindow *) 0 ;
31234 int arg2 ;
31235 int arg3 ;
31236 wxRect *arg4 = (wxRect *) NULL ;
31237 PyObject * obj0 = 0 ;
31238 PyObject * obj1 = 0 ;
31239 PyObject * obj2 = 0 ;
31240 PyObject * obj3 = 0 ;
31241 char *kwnames[] = {
31242 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
31243 };
31244
31245 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
31246 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31247 if (SWIG_arg_fail(1)) SWIG_fail;
31248 {
31249 arg2 = (int)(SWIG_As_int(obj1));
31250 if (SWIG_arg_fail(2)) SWIG_fail;
31251 }
31252 {
31253 arg3 = (int)(SWIG_As_int(obj2));
31254 if (SWIG_arg_fail(3)) SWIG_fail;
31255 }
31256 if (obj3) {
31257 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxRect, SWIG_POINTER_EXCEPTION | 0);
31258 if (SWIG_arg_fail(4)) SWIG_fail;
31259 }
31260 {
31261 PyThreadState* __tstate = wxPyBeginAllowThreads();
31262 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
31263
31264 wxPyEndAllowThreads(__tstate);
31265 if (PyErr_Occurred()) SWIG_fail;
31266 }
31267 Py_INCREF(Py_None); resultobj = Py_None;
31268 return resultobj;
31269 fail:
31270 return NULL;
31271 }
31272
31273
31274 static PyObject *_wrap_Window_ScrollLines(PyObject *, PyObject *args, PyObject *kwargs) {
31275 PyObject *resultobj;
31276 wxWindow *arg1 = (wxWindow *) 0 ;
31277 int arg2 ;
31278 bool result;
31279 PyObject * obj0 = 0 ;
31280 PyObject * obj1 = 0 ;
31281 char *kwnames[] = {
31282 (char *) "self",(char *) "lines", NULL
31283 };
31284
31285 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) goto fail;
31286 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31287 if (SWIG_arg_fail(1)) SWIG_fail;
31288 {
31289 arg2 = (int)(SWIG_As_int(obj1));
31290 if (SWIG_arg_fail(2)) SWIG_fail;
31291 }
31292 {
31293 PyThreadState* __tstate = wxPyBeginAllowThreads();
31294 result = (bool)(arg1)->ScrollLines(arg2);
31295
31296 wxPyEndAllowThreads(__tstate);
31297 if (PyErr_Occurred()) SWIG_fail;
31298 }
31299 {
31300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31301 }
31302 return resultobj;
31303 fail:
31304 return NULL;
31305 }
31306
31307
31308 static PyObject *_wrap_Window_ScrollPages(PyObject *, PyObject *args, PyObject *kwargs) {
31309 PyObject *resultobj;
31310 wxWindow *arg1 = (wxWindow *) 0 ;
31311 int arg2 ;
31312 bool result;
31313 PyObject * obj0 = 0 ;
31314 PyObject * obj1 = 0 ;
31315 char *kwnames[] = {
31316 (char *) "self",(char *) "pages", NULL
31317 };
31318
31319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) goto fail;
31320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31321 if (SWIG_arg_fail(1)) SWIG_fail;
31322 {
31323 arg2 = (int)(SWIG_As_int(obj1));
31324 if (SWIG_arg_fail(2)) SWIG_fail;
31325 }
31326 {
31327 PyThreadState* __tstate = wxPyBeginAllowThreads();
31328 result = (bool)(arg1)->ScrollPages(arg2);
31329
31330 wxPyEndAllowThreads(__tstate);
31331 if (PyErr_Occurred()) SWIG_fail;
31332 }
31333 {
31334 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31335 }
31336 return resultobj;
31337 fail:
31338 return NULL;
31339 }
31340
31341
31342 static PyObject *_wrap_Window_LineUp(PyObject *, PyObject *args, PyObject *kwargs) {
31343 PyObject *resultobj;
31344 wxWindow *arg1 = (wxWindow *) 0 ;
31345 bool result;
31346 PyObject * obj0 = 0 ;
31347 char *kwnames[] = {
31348 (char *) "self", NULL
31349 };
31350
31351 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineUp",kwnames,&obj0)) goto fail;
31352 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31353 if (SWIG_arg_fail(1)) SWIG_fail;
31354 {
31355 PyThreadState* __tstate = wxPyBeginAllowThreads();
31356 result = (bool)(arg1)->LineUp();
31357
31358 wxPyEndAllowThreads(__tstate);
31359 if (PyErr_Occurred()) SWIG_fail;
31360 }
31361 {
31362 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31363 }
31364 return resultobj;
31365 fail:
31366 return NULL;
31367 }
31368
31369
31370 static PyObject *_wrap_Window_LineDown(PyObject *, PyObject *args, PyObject *kwargs) {
31371 PyObject *resultobj;
31372 wxWindow *arg1 = (wxWindow *) 0 ;
31373 bool result;
31374 PyObject * obj0 = 0 ;
31375 char *kwnames[] = {
31376 (char *) "self", NULL
31377 };
31378
31379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_LineDown",kwnames,&obj0)) goto fail;
31380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31381 if (SWIG_arg_fail(1)) SWIG_fail;
31382 {
31383 PyThreadState* __tstate = wxPyBeginAllowThreads();
31384 result = (bool)(arg1)->LineDown();
31385
31386 wxPyEndAllowThreads(__tstate);
31387 if (PyErr_Occurred()) SWIG_fail;
31388 }
31389 {
31390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31391 }
31392 return resultobj;
31393 fail:
31394 return NULL;
31395 }
31396
31397
31398 static PyObject *_wrap_Window_PageUp(PyObject *, PyObject *args, PyObject *kwargs) {
31399 PyObject *resultobj;
31400 wxWindow *arg1 = (wxWindow *) 0 ;
31401 bool result;
31402 PyObject * obj0 = 0 ;
31403 char *kwnames[] = {
31404 (char *) "self", NULL
31405 };
31406
31407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageUp",kwnames,&obj0)) goto fail;
31408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31409 if (SWIG_arg_fail(1)) SWIG_fail;
31410 {
31411 PyThreadState* __tstate = wxPyBeginAllowThreads();
31412 result = (bool)(arg1)->PageUp();
31413
31414 wxPyEndAllowThreads(__tstate);
31415 if (PyErr_Occurred()) SWIG_fail;
31416 }
31417 {
31418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31419 }
31420 return resultobj;
31421 fail:
31422 return NULL;
31423 }
31424
31425
31426 static PyObject *_wrap_Window_PageDown(PyObject *, PyObject *args, PyObject *kwargs) {
31427 PyObject *resultobj;
31428 wxWindow *arg1 = (wxWindow *) 0 ;
31429 bool result;
31430 PyObject * obj0 = 0 ;
31431 char *kwnames[] = {
31432 (char *) "self", NULL
31433 };
31434
31435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PageDown",kwnames,&obj0)) goto fail;
31436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31437 if (SWIG_arg_fail(1)) SWIG_fail;
31438 {
31439 PyThreadState* __tstate = wxPyBeginAllowThreads();
31440 result = (bool)(arg1)->PageDown();
31441
31442 wxPyEndAllowThreads(__tstate);
31443 if (PyErr_Occurred()) SWIG_fail;
31444 }
31445 {
31446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31447 }
31448 return resultobj;
31449 fail:
31450 return NULL;
31451 }
31452
31453
31454 static PyObject *_wrap_Window_SetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31455 PyObject *resultobj;
31456 wxWindow *arg1 = (wxWindow *) 0 ;
31457 wxString *arg2 = 0 ;
31458 bool temp2 = false ;
31459 PyObject * obj0 = 0 ;
31460 PyObject * obj1 = 0 ;
31461 char *kwnames[] = {
31462 (char *) "self",(char *) "text", NULL
31463 };
31464
31465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) goto fail;
31466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31467 if (SWIG_arg_fail(1)) SWIG_fail;
31468 {
31469 arg2 = wxString_in_helper(obj1);
31470 if (arg2 == NULL) SWIG_fail;
31471 temp2 = true;
31472 }
31473 {
31474 PyThreadState* __tstate = wxPyBeginAllowThreads();
31475 (arg1)->SetHelpText((wxString const &)*arg2);
31476
31477 wxPyEndAllowThreads(__tstate);
31478 if (PyErr_Occurred()) SWIG_fail;
31479 }
31480 Py_INCREF(Py_None); resultobj = Py_None;
31481 {
31482 if (temp2)
31483 delete arg2;
31484 }
31485 return resultobj;
31486 fail:
31487 {
31488 if (temp2)
31489 delete arg2;
31490 }
31491 return NULL;
31492 }
31493
31494
31495 static PyObject *_wrap_Window_SetHelpTextForId(PyObject *, PyObject *args, PyObject *kwargs) {
31496 PyObject *resultobj;
31497 wxWindow *arg1 = (wxWindow *) 0 ;
31498 wxString *arg2 = 0 ;
31499 bool temp2 = false ;
31500 PyObject * obj0 = 0 ;
31501 PyObject * obj1 = 0 ;
31502 char *kwnames[] = {
31503 (char *) "self",(char *) "text", NULL
31504 };
31505
31506 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) goto fail;
31507 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31508 if (SWIG_arg_fail(1)) SWIG_fail;
31509 {
31510 arg2 = wxString_in_helper(obj1);
31511 if (arg2 == NULL) SWIG_fail;
31512 temp2 = true;
31513 }
31514 {
31515 PyThreadState* __tstate = wxPyBeginAllowThreads();
31516 (arg1)->SetHelpTextForId((wxString const &)*arg2);
31517
31518 wxPyEndAllowThreads(__tstate);
31519 if (PyErr_Occurred()) SWIG_fail;
31520 }
31521 Py_INCREF(Py_None); resultobj = Py_None;
31522 {
31523 if (temp2)
31524 delete arg2;
31525 }
31526 return resultobj;
31527 fail:
31528 {
31529 if (temp2)
31530 delete arg2;
31531 }
31532 return NULL;
31533 }
31534
31535
31536 static PyObject *_wrap_Window_GetHelpText(PyObject *, PyObject *args, PyObject *kwargs) {
31537 PyObject *resultobj;
31538 wxWindow *arg1 = (wxWindow *) 0 ;
31539 wxString result;
31540 PyObject * obj0 = 0 ;
31541 char *kwnames[] = {
31542 (char *) "self", NULL
31543 };
31544
31545 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetHelpText",kwnames,&obj0)) goto fail;
31546 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31547 if (SWIG_arg_fail(1)) SWIG_fail;
31548 {
31549 PyThreadState* __tstate = wxPyBeginAllowThreads();
31550 result = ((wxWindow const *)arg1)->GetHelpText();
31551
31552 wxPyEndAllowThreads(__tstate);
31553 if (PyErr_Occurred()) SWIG_fail;
31554 }
31555 {
31556 #if wxUSE_UNICODE
31557 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31558 #else
31559 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31560 #endif
31561 }
31562 return resultobj;
31563 fail:
31564 return NULL;
31565 }
31566
31567
31568 static PyObject *_wrap_Window_SetToolTipString(PyObject *, PyObject *args, PyObject *kwargs) {
31569 PyObject *resultobj;
31570 wxWindow *arg1 = (wxWindow *) 0 ;
31571 wxString *arg2 = 0 ;
31572 bool temp2 = false ;
31573 PyObject * obj0 = 0 ;
31574 PyObject * obj1 = 0 ;
31575 char *kwnames[] = {
31576 (char *) "self",(char *) "tip", NULL
31577 };
31578
31579 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) goto fail;
31580 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31581 if (SWIG_arg_fail(1)) SWIG_fail;
31582 {
31583 arg2 = wxString_in_helper(obj1);
31584 if (arg2 == NULL) SWIG_fail;
31585 temp2 = true;
31586 }
31587 {
31588 PyThreadState* __tstate = wxPyBeginAllowThreads();
31589 (arg1)->SetToolTip((wxString const &)*arg2);
31590
31591 wxPyEndAllowThreads(__tstate);
31592 if (PyErr_Occurred()) SWIG_fail;
31593 }
31594 Py_INCREF(Py_None); resultobj = Py_None;
31595 {
31596 if (temp2)
31597 delete arg2;
31598 }
31599 return resultobj;
31600 fail:
31601 {
31602 if (temp2)
31603 delete arg2;
31604 }
31605 return NULL;
31606 }
31607
31608
31609 static PyObject *_wrap_Window_SetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31610 PyObject *resultobj;
31611 wxWindow *arg1 = (wxWindow *) 0 ;
31612 wxToolTip *arg2 = (wxToolTip *) 0 ;
31613 PyObject * obj0 = 0 ;
31614 PyObject * obj1 = 0 ;
31615 char *kwnames[] = {
31616 (char *) "self",(char *) "tip", NULL
31617 };
31618
31619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) goto fail;
31620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31621 if (SWIG_arg_fail(1)) SWIG_fail;
31622 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxToolTip, SWIG_POINTER_EXCEPTION | 0);
31623 if (SWIG_arg_fail(2)) SWIG_fail;
31624 {
31625 PyThreadState* __tstate = wxPyBeginAllowThreads();
31626 (arg1)->SetToolTip(arg2);
31627
31628 wxPyEndAllowThreads(__tstate);
31629 if (PyErr_Occurred()) SWIG_fail;
31630 }
31631 Py_INCREF(Py_None); resultobj = Py_None;
31632 return resultobj;
31633 fail:
31634 return NULL;
31635 }
31636
31637
31638 static PyObject *_wrap_Window_GetToolTip(PyObject *, PyObject *args, PyObject *kwargs) {
31639 PyObject *resultobj;
31640 wxWindow *arg1 = (wxWindow *) 0 ;
31641 wxToolTip *result;
31642 PyObject * obj0 = 0 ;
31643 char *kwnames[] = {
31644 (char *) "self", NULL
31645 };
31646
31647 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetToolTip",kwnames,&obj0)) goto fail;
31648 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31649 if (SWIG_arg_fail(1)) SWIG_fail;
31650 {
31651 PyThreadState* __tstate = wxPyBeginAllowThreads();
31652 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
31653
31654 wxPyEndAllowThreads(__tstate);
31655 if (PyErr_Occurred()) SWIG_fail;
31656 }
31657 {
31658 resultobj = wxPyMake_wxObject(result, 0);
31659 }
31660 return resultobj;
31661 fail:
31662 return NULL;
31663 }
31664
31665
31666 static PyObject *_wrap_Window_SetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31667 PyObject *resultobj;
31668 wxWindow *arg1 = (wxWindow *) 0 ;
31669 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
31670 PyObject * obj0 = 0 ;
31671 PyObject * obj1 = 0 ;
31672 char *kwnames[] = {
31673 (char *) "self",(char *) "dropTarget", NULL
31674 };
31675
31676 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) goto fail;
31677 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31678 if (SWIG_arg_fail(1)) SWIG_fail;
31679 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_EXCEPTION | SWIG_POINTER_DISOWN);
31680 if (SWIG_arg_fail(2)) SWIG_fail;
31681 {
31682 PyThreadState* __tstate = wxPyBeginAllowThreads();
31683 (arg1)->SetDropTarget(arg2);
31684
31685 wxPyEndAllowThreads(__tstate);
31686 if (PyErr_Occurred()) SWIG_fail;
31687 }
31688 Py_INCREF(Py_None); resultobj = Py_None;
31689 return resultobj;
31690 fail:
31691 return NULL;
31692 }
31693
31694
31695 static PyObject *_wrap_Window_GetDropTarget(PyObject *, PyObject *args, PyObject *kwargs) {
31696 PyObject *resultobj;
31697 wxWindow *arg1 = (wxWindow *) 0 ;
31698 wxPyDropTarget *result;
31699 PyObject * obj0 = 0 ;
31700 char *kwnames[] = {
31701 (char *) "self", NULL
31702 };
31703
31704 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetDropTarget",kwnames,&obj0)) goto fail;
31705 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31706 if (SWIG_arg_fail(1)) SWIG_fail;
31707 {
31708 PyThreadState* __tstate = wxPyBeginAllowThreads();
31709 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
31710
31711 wxPyEndAllowThreads(__tstate);
31712 if (PyErr_Occurred()) SWIG_fail;
31713 }
31714 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyDropTarget, 0);
31715 return resultobj;
31716 fail:
31717 return NULL;
31718 }
31719
31720
31721 static PyObject *_wrap_Window_SetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31722 PyObject *resultobj;
31723 wxWindow *arg1 = (wxWindow *) 0 ;
31724 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
31725 PyObject * obj0 = 0 ;
31726 PyObject * obj1 = 0 ;
31727 char *kwnames[] = {
31728 (char *) "self",(char *) "constraints", NULL
31729 };
31730
31731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) goto fail;
31732 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31733 if (SWIG_arg_fail(1)) SWIG_fail;
31734 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
31735 if (SWIG_arg_fail(2)) SWIG_fail;
31736 {
31737 PyThreadState* __tstate = wxPyBeginAllowThreads();
31738 (arg1)->SetConstraints(arg2);
31739
31740 wxPyEndAllowThreads(__tstate);
31741 if (PyErr_Occurred()) SWIG_fail;
31742 }
31743 Py_INCREF(Py_None); resultobj = Py_None;
31744 return resultobj;
31745 fail:
31746 return NULL;
31747 }
31748
31749
31750 static PyObject *_wrap_Window_GetConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
31751 PyObject *resultobj;
31752 wxWindow *arg1 = (wxWindow *) 0 ;
31753 wxLayoutConstraints *result;
31754 PyObject * obj0 = 0 ;
31755 char *kwnames[] = {
31756 (char *) "self", NULL
31757 };
31758
31759 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetConstraints",kwnames,&obj0)) goto fail;
31760 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31761 if (SWIG_arg_fail(1)) SWIG_fail;
31762 {
31763 PyThreadState* __tstate = wxPyBeginAllowThreads();
31764 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
31765
31766 wxPyEndAllowThreads(__tstate);
31767 if (PyErr_Occurred()) SWIG_fail;
31768 }
31769 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 0);
31770 return resultobj;
31771 fail:
31772 return NULL;
31773 }
31774
31775
31776 static PyObject *_wrap_Window_SetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31777 PyObject *resultobj;
31778 wxWindow *arg1 = (wxWindow *) 0 ;
31779 bool arg2 ;
31780 PyObject * obj0 = 0 ;
31781 PyObject * obj1 = 0 ;
31782 char *kwnames[] = {
31783 (char *) "self",(char *) "autoLayout", NULL
31784 };
31785
31786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) goto fail;
31787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31788 if (SWIG_arg_fail(1)) SWIG_fail;
31789 {
31790 arg2 = (bool)(SWIG_As_bool(obj1));
31791 if (SWIG_arg_fail(2)) SWIG_fail;
31792 }
31793 {
31794 PyThreadState* __tstate = wxPyBeginAllowThreads();
31795 (arg1)->SetAutoLayout(arg2);
31796
31797 wxPyEndAllowThreads(__tstate);
31798 if (PyErr_Occurred()) SWIG_fail;
31799 }
31800 Py_INCREF(Py_None); resultobj = Py_None;
31801 return resultobj;
31802 fail:
31803 return NULL;
31804 }
31805
31806
31807 static PyObject *_wrap_Window_GetAutoLayout(PyObject *, PyObject *args, PyObject *kwargs) {
31808 PyObject *resultobj;
31809 wxWindow *arg1 = (wxWindow *) 0 ;
31810 bool result;
31811 PyObject * obj0 = 0 ;
31812 char *kwnames[] = {
31813 (char *) "self", NULL
31814 };
31815
31816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetAutoLayout",kwnames,&obj0)) goto fail;
31817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31818 if (SWIG_arg_fail(1)) SWIG_fail;
31819 {
31820 PyThreadState* __tstate = wxPyBeginAllowThreads();
31821 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
31822
31823 wxPyEndAllowThreads(__tstate);
31824 if (PyErr_Occurred()) SWIG_fail;
31825 }
31826 {
31827 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31828 }
31829 return resultobj;
31830 fail:
31831 return NULL;
31832 }
31833
31834
31835 static PyObject *_wrap_Window_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
31836 PyObject *resultobj;
31837 wxWindow *arg1 = (wxWindow *) 0 ;
31838 bool result;
31839 PyObject * obj0 = 0 ;
31840 char *kwnames[] = {
31841 (char *) "self", NULL
31842 };
31843
31844 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_Layout",kwnames,&obj0)) goto fail;
31845 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31846 if (SWIG_arg_fail(1)) SWIG_fail;
31847 {
31848 PyThreadState* __tstate = wxPyBeginAllowThreads();
31849 result = (bool)(arg1)->Layout();
31850
31851 wxPyEndAllowThreads(__tstate);
31852 if (PyErr_Occurred()) SWIG_fail;
31853 }
31854 {
31855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31856 }
31857 return resultobj;
31858 fail:
31859 return NULL;
31860 }
31861
31862
31863 static PyObject *_wrap_Window_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31864 PyObject *resultobj;
31865 wxWindow *arg1 = (wxWindow *) 0 ;
31866 wxSizer *arg2 = (wxSizer *) 0 ;
31867 bool arg3 = (bool) true ;
31868 PyObject * obj0 = 0 ;
31869 PyObject * obj1 = 0 ;
31870 PyObject * obj2 = 0 ;
31871 char *kwnames[] = {
31872 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31873 };
31874
31875 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) goto fail;
31876 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31877 if (SWIG_arg_fail(1)) SWIG_fail;
31878 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31879 if (SWIG_arg_fail(2)) SWIG_fail;
31880 if (obj2) {
31881 {
31882 arg3 = (bool)(SWIG_As_bool(obj2));
31883 if (SWIG_arg_fail(3)) SWIG_fail;
31884 }
31885 }
31886 {
31887 PyThreadState* __tstate = wxPyBeginAllowThreads();
31888 (arg1)->SetSizer(arg2,arg3);
31889
31890 wxPyEndAllowThreads(__tstate);
31891 if (PyErr_Occurred()) SWIG_fail;
31892 }
31893 Py_INCREF(Py_None); resultobj = Py_None;
31894 return resultobj;
31895 fail:
31896 return NULL;
31897 }
31898
31899
31900 static PyObject *_wrap_Window_SetSizerAndFit(PyObject *, PyObject *args, PyObject *kwargs) {
31901 PyObject *resultobj;
31902 wxWindow *arg1 = (wxWindow *) 0 ;
31903 wxSizer *arg2 = (wxSizer *) 0 ;
31904 bool arg3 = (bool) true ;
31905 PyObject * obj0 = 0 ;
31906 PyObject * obj1 = 0 ;
31907 PyObject * obj2 = 0 ;
31908 char *kwnames[] = {
31909 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
31910 };
31911
31912 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) goto fail;
31913 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31914 if (SWIG_arg_fail(1)) SWIG_fail;
31915 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31916 if (SWIG_arg_fail(2)) SWIG_fail;
31917 if (obj2) {
31918 {
31919 arg3 = (bool)(SWIG_As_bool(obj2));
31920 if (SWIG_arg_fail(3)) SWIG_fail;
31921 }
31922 }
31923 {
31924 PyThreadState* __tstate = wxPyBeginAllowThreads();
31925 (arg1)->SetSizerAndFit(arg2,arg3);
31926
31927 wxPyEndAllowThreads(__tstate);
31928 if (PyErr_Occurred()) SWIG_fail;
31929 }
31930 Py_INCREF(Py_None); resultobj = Py_None;
31931 return resultobj;
31932 fail:
31933 return NULL;
31934 }
31935
31936
31937 static PyObject *_wrap_Window_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31938 PyObject *resultobj;
31939 wxWindow *arg1 = (wxWindow *) 0 ;
31940 wxSizer *result;
31941 PyObject * obj0 = 0 ;
31942 char *kwnames[] = {
31943 (char *) "self", NULL
31944 };
31945
31946 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetSizer",kwnames,&obj0)) goto fail;
31947 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31948 if (SWIG_arg_fail(1)) SWIG_fail;
31949 {
31950 PyThreadState* __tstate = wxPyBeginAllowThreads();
31951 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
31952
31953 wxPyEndAllowThreads(__tstate);
31954 if (PyErr_Occurred()) SWIG_fail;
31955 }
31956 {
31957 resultobj = wxPyMake_wxSizer(result, 0);
31958 }
31959 return resultobj;
31960 fail:
31961 return NULL;
31962 }
31963
31964
31965 static PyObject *_wrap_Window_SetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31966 PyObject *resultobj;
31967 wxWindow *arg1 = (wxWindow *) 0 ;
31968 wxSizer *arg2 = (wxSizer *) 0 ;
31969 PyObject * obj0 = 0 ;
31970 PyObject * obj1 = 0 ;
31971 char *kwnames[] = {
31972 (char *) "self",(char *) "sizer", NULL
31973 };
31974
31975 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) goto fail;
31976 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
31977 if (SWIG_arg_fail(1)) SWIG_fail;
31978 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
31979 if (SWIG_arg_fail(2)) SWIG_fail;
31980 {
31981 PyThreadState* __tstate = wxPyBeginAllowThreads();
31982 (arg1)->SetContainingSizer(arg2);
31983
31984 wxPyEndAllowThreads(__tstate);
31985 if (PyErr_Occurred()) SWIG_fail;
31986 }
31987 Py_INCREF(Py_None); resultobj = Py_None;
31988 return resultobj;
31989 fail:
31990 return NULL;
31991 }
31992
31993
31994 static PyObject *_wrap_Window_GetContainingSizer(PyObject *, PyObject *args, PyObject *kwargs) {
31995 PyObject *resultobj;
31996 wxWindow *arg1 = (wxWindow *) 0 ;
31997 wxSizer *result;
31998 PyObject * obj0 = 0 ;
31999 char *kwnames[] = {
32000 (char *) "self", NULL
32001 };
32002
32003 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_GetContainingSizer",kwnames,&obj0)) goto fail;
32004 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32005 if (SWIG_arg_fail(1)) SWIG_fail;
32006 {
32007 PyThreadState* __tstate = wxPyBeginAllowThreads();
32008 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
32009
32010 wxPyEndAllowThreads(__tstate);
32011 if (PyErr_Occurred()) SWIG_fail;
32012 }
32013 {
32014 resultobj = wxPyMake_wxSizer(result, 0);
32015 }
32016 return resultobj;
32017 fail:
32018 return NULL;
32019 }
32020
32021
32022 static PyObject *_wrap_Window_InheritAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
32023 PyObject *resultobj;
32024 wxWindow *arg1 = (wxWindow *) 0 ;
32025 PyObject * obj0 = 0 ;
32026 char *kwnames[] = {
32027 (char *) "self", NULL
32028 };
32029
32030 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_InheritAttributes",kwnames,&obj0)) goto fail;
32031 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32032 if (SWIG_arg_fail(1)) SWIG_fail;
32033 {
32034 PyThreadState* __tstate = wxPyBeginAllowThreads();
32035 (arg1)->InheritAttributes();
32036
32037 wxPyEndAllowThreads(__tstate);
32038 if (PyErr_Occurred()) SWIG_fail;
32039 }
32040 Py_INCREF(Py_None); resultobj = Py_None;
32041 return resultobj;
32042 fail:
32043 return NULL;
32044 }
32045
32046
32047 static PyObject *_wrap_Window_ShouldInheritColours(PyObject *, PyObject *args, PyObject *kwargs) {
32048 PyObject *resultobj;
32049 wxWindow *arg1 = (wxWindow *) 0 ;
32050 bool result;
32051 PyObject * obj0 = 0 ;
32052 char *kwnames[] = {
32053 (char *) "self", NULL
32054 };
32055
32056 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_ShouldInheritColours",kwnames,&obj0)) goto fail;
32057 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32058 if (SWIG_arg_fail(1)) SWIG_fail;
32059 {
32060 PyThreadState* __tstate = wxPyBeginAllowThreads();
32061 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
32062
32063 wxPyEndAllowThreads(__tstate);
32064 if (PyErr_Occurred()) SWIG_fail;
32065 }
32066 {
32067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32068 }
32069 return resultobj;
32070 fail:
32071 return NULL;
32072 }
32073
32074
32075 static PyObject * Window_swigregister(PyObject *, PyObject *args) {
32076 PyObject *obj;
32077 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32078 SWIG_TypeClientData(SWIGTYPE_p_wxWindow, obj);
32079 Py_INCREF(obj);
32080 return Py_BuildValue((char *)"");
32081 }
32082 static PyObject *_wrap_FindWindowById(PyObject *, PyObject *args, PyObject *kwargs) {
32083 PyObject *resultobj;
32084 long arg1 ;
32085 wxWindow *arg2 = (wxWindow *) NULL ;
32086 wxWindow *result;
32087 PyObject * obj0 = 0 ;
32088 PyObject * obj1 = 0 ;
32089 char *kwnames[] = {
32090 (char *) "id",(char *) "parent", NULL
32091 };
32092
32093 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) goto fail;
32094 {
32095 arg1 = (long)(SWIG_As_long(obj0));
32096 if (SWIG_arg_fail(1)) SWIG_fail;
32097 }
32098 if (obj1) {
32099 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32100 if (SWIG_arg_fail(2)) SWIG_fail;
32101 }
32102 {
32103 if (!wxPyCheckForApp()) SWIG_fail;
32104 PyThreadState* __tstate = wxPyBeginAllowThreads();
32105 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
32106
32107 wxPyEndAllowThreads(__tstate);
32108 if (PyErr_Occurred()) SWIG_fail;
32109 }
32110 {
32111 resultobj = wxPyMake_wxObject(result, 0);
32112 }
32113 return resultobj;
32114 fail:
32115 return NULL;
32116 }
32117
32118
32119 static PyObject *_wrap_FindWindowByName(PyObject *, PyObject *args, PyObject *kwargs) {
32120 PyObject *resultobj;
32121 wxString *arg1 = 0 ;
32122 wxWindow *arg2 = (wxWindow *) NULL ;
32123 wxWindow *result;
32124 bool temp1 = false ;
32125 PyObject * obj0 = 0 ;
32126 PyObject * obj1 = 0 ;
32127 char *kwnames[] = {
32128 (char *) "name",(char *) "parent", NULL
32129 };
32130
32131 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) goto fail;
32132 {
32133 arg1 = wxString_in_helper(obj0);
32134 if (arg1 == NULL) SWIG_fail;
32135 temp1 = true;
32136 }
32137 if (obj1) {
32138 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32139 if (SWIG_arg_fail(2)) SWIG_fail;
32140 }
32141 {
32142 if (!wxPyCheckForApp()) SWIG_fail;
32143 PyThreadState* __tstate = wxPyBeginAllowThreads();
32144 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
32145
32146 wxPyEndAllowThreads(__tstate);
32147 if (PyErr_Occurred()) SWIG_fail;
32148 }
32149 {
32150 resultobj = wxPyMake_wxObject(result, 0);
32151 }
32152 {
32153 if (temp1)
32154 delete arg1;
32155 }
32156 return resultobj;
32157 fail:
32158 {
32159 if (temp1)
32160 delete arg1;
32161 }
32162 return NULL;
32163 }
32164
32165
32166 static PyObject *_wrap_FindWindowByLabel(PyObject *, PyObject *args, PyObject *kwargs) {
32167 PyObject *resultobj;
32168 wxString *arg1 = 0 ;
32169 wxWindow *arg2 = (wxWindow *) NULL ;
32170 wxWindow *result;
32171 bool temp1 = false ;
32172 PyObject * obj0 = 0 ;
32173 PyObject * obj1 = 0 ;
32174 char *kwnames[] = {
32175 (char *) "label",(char *) "parent", NULL
32176 };
32177
32178 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) goto fail;
32179 {
32180 arg1 = wxString_in_helper(obj0);
32181 if (arg1 == NULL) SWIG_fail;
32182 temp1 = true;
32183 }
32184 if (obj1) {
32185 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32186 if (SWIG_arg_fail(2)) SWIG_fail;
32187 }
32188 {
32189 if (!wxPyCheckForApp()) SWIG_fail;
32190 PyThreadState* __tstate = wxPyBeginAllowThreads();
32191 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
32192
32193 wxPyEndAllowThreads(__tstate);
32194 if (PyErr_Occurred()) SWIG_fail;
32195 }
32196 {
32197 resultobj = wxPyMake_wxObject(result, 0);
32198 }
32199 {
32200 if (temp1)
32201 delete arg1;
32202 }
32203 return resultobj;
32204 fail:
32205 {
32206 if (temp1)
32207 delete arg1;
32208 }
32209 return NULL;
32210 }
32211
32212
32213 static PyObject *_wrap_Window_FromHWND(PyObject *, PyObject *args, PyObject *kwargs) {
32214 PyObject *resultobj;
32215 wxWindow *arg1 = (wxWindow *) 0 ;
32216 unsigned long arg2 ;
32217 wxWindow *result;
32218 PyObject * obj0 = 0 ;
32219 PyObject * obj1 = 0 ;
32220 char *kwnames[] = {
32221 (char *) "parent",(char *) "_hWnd", NULL
32222 };
32223
32224 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) goto fail;
32225 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32226 if (SWIG_arg_fail(1)) SWIG_fail;
32227 {
32228 arg2 = (unsigned long)(SWIG_As_unsigned_SS_long(obj1));
32229 if (SWIG_arg_fail(2)) SWIG_fail;
32230 }
32231 {
32232 PyThreadState* __tstate = wxPyBeginAllowThreads();
32233 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
32234
32235 wxPyEndAllowThreads(__tstate);
32236 if (PyErr_Occurred()) SWIG_fail;
32237 }
32238 {
32239 resultobj = wxPyMake_wxObject(result, 0);
32240 }
32241 return resultobj;
32242 fail:
32243 return NULL;
32244 }
32245
32246
32247 static PyObject *_wrap_new_Validator(PyObject *, PyObject *args, PyObject *kwargs) {
32248 PyObject *resultobj;
32249 wxValidator *result;
32250 char *kwnames[] = {
32251 NULL
32252 };
32253
32254 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_Validator",kwnames)) goto fail;
32255 {
32256 PyThreadState* __tstate = wxPyBeginAllowThreads();
32257 result = (wxValidator *)new wxValidator();
32258
32259 wxPyEndAllowThreads(__tstate);
32260 if (PyErr_Occurred()) SWIG_fail;
32261 }
32262 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxValidator, 1);
32263 return resultobj;
32264 fail:
32265 return NULL;
32266 }
32267
32268
32269 static PyObject *_wrap_Validator_Clone(PyObject *, PyObject *args, PyObject *kwargs) {
32270 PyObject *resultobj;
32271 wxValidator *arg1 = (wxValidator *) 0 ;
32272 wxValidator *result;
32273 PyObject * obj0 = 0 ;
32274 char *kwnames[] = {
32275 (char *) "self", NULL
32276 };
32277
32278 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_Clone",kwnames,&obj0)) goto fail;
32279 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32280 if (SWIG_arg_fail(1)) SWIG_fail;
32281 {
32282 PyThreadState* __tstate = wxPyBeginAllowThreads();
32283 result = (wxValidator *)(arg1)->Clone();
32284
32285 wxPyEndAllowThreads(__tstate);
32286 if (PyErr_Occurred()) SWIG_fail;
32287 }
32288 {
32289 resultobj = wxPyMake_wxObject(result, 0);
32290 }
32291 return resultobj;
32292 fail:
32293 return NULL;
32294 }
32295
32296
32297 static PyObject *_wrap_Validator_Validate(PyObject *, PyObject *args, PyObject *kwargs) {
32298 PyObject *resultobj;
32299 wxValidator *arg1 = (wxValidator *) 0 ;
32300 wxWindow *arg2 = (wxWindow *) 0 ;
32301 bool result;
32302 PyObject * obj0 = 0 ;
32303 PyObject * obj1 = 0 ;
32304 char *kwnames[] = {
32305 (char *) "self",(char *) "parent", NULL
32306 };
32307
32308 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) goto fail;
32309 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32310 if (SWIG_arg_fail(1)) SWIG_fail;
32311 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32312 if (SWIG_arg_fail(2)) SWIG_fail;
32313 {
32314 PyThreadState* __tstate = wxPyBeginAllowThreads();
32315 result = (bool)(arg1)->Validate(arg2);
32316
32317 wxPyEndAllowThreads(__tstate);
32318 if (PyErr_Occurred()) SWIG_fail;
32319 }
32320 {
32321 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32322 }
32323 return resultobj;
32324 fail:
32325 return NULL;
32326 }
32327
32328
32329 static PyObject *_wrap_Validator_TransferToWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32330 PyObject *resultobj;
32331 wxValidator *arg1 = (wxValidator *) 0 ;
32332 bool result;
32333 PyObject * obj0 = 0 ;
32334 char *kwnames[] = {
32335 (char *) "self", NULL
32336 };
32337
32338 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferToWindow",kwnames,&obj0)) goto fail;
32339 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32340 if (SWIG_arg_fail(1)) SWIG_fail;
32341 {
32342 PyThreadState* __tstate = wxPyBeginAllowThreads();
32343 result = (bool)(arg1)->TransferToWindow();
32344
32345 wxPyEndAllowThreads(__tstate);
32346 if (PyErr_Occurred()) SWIG_fail;
32347 }
32348 {
32349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32350 }
32351 return resultobj;
32352 fail:
32353 return NULL;
32354 }
32355
32356
32357 static PyObject *_wrap_Validator_TransferFromWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32358 PyObject *resultobj;
32359 wxValidator *arg1 = (wxValidator *) 0 ;
32360 bool result;
32361 PyObject * obj0 = 0 ;
32362 char *kwnames[] = {
32363 (char *) "self", NULL
32364 };
32365
32366 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_TransferFromWindow",kwnames,&obj0)) goto fail;
32367 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32368 if (SWIG_arg_fail(1)) SWIG_fail;
32369 {
32370 PyThreadState* __tstate = wxPyBeginAllowThreads();
32371 result = (bool)(arg1)->TransferFromWindow();
32372
32373 wxPyEndAllowThreads(__tstate);
32374 if (PyErr_Occurred()) SWIG_fail;
32375 }
32376 {
32377 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32378 }
32379 return resultobj;
32380 fail:
32381 return NULL;
32382 }
32383
32384
32385 static PyObject *_wrap_Validator_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32386 PyObject *resultobj;
32387 wxValidator *arg1 = (wxValidator *) 0 ;
32388 wxWindow *result;
32389 PyObject * obj0 = 0 ;
32390 char *kwnames[] = {
32391 (char *) "self", NULL
32392 };
32393
32394 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Validator_GetWindow",kwnames,&obj0)) goto fail;
32395 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32396 if (SWIG_arg_fail(1)) SWIG_fail;
32397 {
32398 PyThreadState* __tstate = wxPyBeginAllowThreads();
32399 result = (wxWindow *)(arg1)->GetWindow();
32400
32401 wxPyEndAllowThreads(__tstate);
32402 if (PyErr_Occurred()) SWIG_fail;
32403 }
32404 {
32405 resultobj = wxPyMake_wxObject(result, 0);
32406 }
32407 return resultobj;
32408 fail:
32409 return NULL;
32410 }
32411
32412
32413 static PyObject *_wrap_Validator_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
32414 PyObject *resultobj;
32415 wxValidator *arg1 = (wxValidator *) 0 ;
32416 wxWindow *arg2 = (wxWindow *) 0 ;
32417 PyObject * obj0 = 0 ;
32418 PyObject * obj1 = 0 ;
32419 char *kwnames[] = {
32420 (char *) "self",(char *) "window", NULL
32421 };
32422
32423 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) goto fail;
32424 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
32425 if (SWIG_arg_fail(1)) SWIG_fail;
32426 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
32427 if (SWIG_arg_fail(2)) SWIG_fail;
32428 {
32429 PyThreadState* __tstate = wxPyBeginAllowThreads();
32430 (arg1)->SetWindow(arg2);
32431
32432 wxPyEndAllowThreads(__tstate);
32433 if (PyErr_Occurred()) SWIG_fail;
32434 }
32435 Py_INCREF(Py_None); resultobj = Py_None;
32436 return resultobj;
32437 fail:
32438 return NULL;
32439 }
32440
32441
32442 static PyObject *_wrap_Validator_IsSilent(PyObject *, PyObject *args, PyObject *kwargs) {
32443 PyObject *resultobj;
32444 bool result;
32445 char *kwnames[] = {
32446 NULL
32447 };
32448
32449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":Validator_IsSilent",kwnames)) goto fail;
32450 {
32451 PyThreadState* __tstate = wxPyBeginAllowThreads();
32452 result = (bool)wxValidator::IsSilent();
32453
32454 wxPyEndAllowThreads(__tstate);
32455 if (PyErr_Occurred()) SWIG_fail;
32456 }
32457 {
32458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32459 }
32460 return resultobj;
32461 fail:
32462 return NULL;
32463 }
32464
32465
32466 static PyObject *_wrap_Validator_SetBellOnError(PyObject *, PyObject *args, PyObject *kwargs) {
32467 PyObject *resultobj;
32468 int arg1 = (int) true ;
32469 PyObject * obj0 = 0 ;
32470 char *kwnames[] = {
32471 (char *) "doIt", NULL
32472 };
32473
32474 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) goto fail;
32475 if (obj0) {
32476 {
32477 arg1 = (int)(SWIG_As_int(obj0));
32478 if (SWIG_arg_fail(1)) SWIG_fail;
32479 }
32480 }
32481 {
32482 PyThreadState* __tstate = wxPyBeginAllowThreads();
32483 wxValidator::SetBellOnError(arg1);
32484
32485 wxPyEndAllowThreads(__tstate);
32486 if (PyErr_Occurred()) SWIG_fail;
32487 }
32488 Py_INCREF(Py_None); resultobj = Py_None;
32489 return resultobj;
32490 fail:
32491 return NULL;
32492 }
32493
32494
32495 static PyObject * Validator_swigregister(PyObject *, PyObject *args) {
32496 PyObject *obj;
32497 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32498 SWIG_TypeClientData(SWIGTYPE_p_wxValidator, obj);
32499 Py_INCREF(obj);
32500 return Py_BuildValue((char *)"");
32501 }
32502 static PyObject *_wrap_new_PyValidator(PyObject *, PyObject *args, PyObject *kwargs) {
32503 PyObject *resultobj;
32504 wxPyValidator *result;
32505 char *kwnames[] = {
32506 NULL
32507 };
32508
32509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PyValidator",kwnames)) goto fail;
32510 {
32511 PyThreadState* __tstate = wxPyBeginAllowThreads();
32512 result = (wxPyValidator *)new wxPyValidator();
32513
32514 wxPyEndAllowThreads(__tstate);
32515 if (PyErr_Occurred()) SWIG_fail;
32516 }
32517 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPyValidator, 1);
32518 return resultobj;
32519 fail:
32520 return NULL;
32521 }
32522
32523
32524 static PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
32525 PyObject *resultobj;
32526 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
32527 PyObject *arg2 = (PyObject *) 0 ;
32528 PyObject *arg3 = (PyObject *) 0 ;
32529 int arg4 = (int) true ;
32530 PyObject * obj0 = 0 ;
32531 PyObject * obj1 = 0 ;
32532 PyObject * obj2 = 0 ;
32533 PyObject * obj3 = 0 ;
32534 char *kwnames[] = {
32535 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
32536 };
32537
32538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPyValidator, SWIG_POINTER_EXCEPTION | 0);
32540 if (SWIG_arg_fail(1)) SWIG_fail;
32541 arg2 = obj1;
32542 arg3 = obj2;
32543 if (obj3) {
32544 {
32545 arg4 = (int)(SWIG_As_int(obj3));
32546 if (SWIG_arg_fail(4)) SWIG_fail;
32547 }
32548 }
32549 {
32550 PyThreadState* __tstate = wxPyBeginAllowThreads();
32551 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
32552
32553 wxPyEndAllowThreads(__tstate);
32554 if (PyErr_Occurred()) SWIG_fail;
32555 }
32556 Py_INCREF(Py_None); resultobj = Py_None;
32557 return resultobj;
32558 fail:
32559 return NULL;
32560 }
32561
32562
32563 static PyObject * PyValidator_swigregister(PyObject *, PyObject *args) {
32564 PyObject *obj;
32565 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
32566 SWIG_TypeClientData(SWIGTYPE_p_wxPyValidator, obj);
32567 Py_INCREF(obj);
32568 return Py_BuildValue((char *)"");
32569 }
32570 static int _wrap_DefaultValidator_set(PyObject *) {
32571 PyErr_SetString(PyExc_TypeError,"Variable DefaultValidator is read-only.");
32572 return 1;
32573 }
32574
32575
32576 static PyObject *_wrap_DefaultValidator_get(void) {
32577 PyObject *pyobj;
32578
32579 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0);
32580 return pyobj;
32581 }
32582
32583
32584 static PyObject *_wrap_new_Menu(PyObject *, PyObject *args, PyObject *kwargs) {
32585 PyObject *resultobj;
32586 wxString const &arg1_defvalue = wxPyEmptyString ;
32587 wxString *arg1 = (wxString *) &arg1_defvalue ;
32588 long arg2 = (long) 0 ;
32589 wxMenu *result;
32590 bool temp1 = false ;
32591 PyObject * obj0 = 0 ;
32592 PyObject * obj1 = 0 ;
32593 char *kwnames[] = {
32594 (char *) "title",(char *) "style", NULL
32595 };
32596
32597 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) goto fail;
32598 if (obj0) {
32599 {
32600 arg1 = wxString_in_helper(obj0);
32601 if (arg1 == NULL) SWIG_fail;
32602 temp1 = true;
32603 }
32604 }
32605 if (obj1) {
32606 {
32607 arg2 = (long)(SWIG_As_long(obj1));
32608 if (SWIG_arg_fail(2)) SWIG_fail;
32609 }
32610 }
32611 {
32612 if (!wxPyCheckForApp()) SWIG_fail;
32613 PyThreadState* __tstate = wxPyBeginAllowThreads();
32614 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
32615
32616 wxPyEndAllowThreads(__tstate);
32617 if (PyErr_Occurred()) SWIG_fail;
32618 }
32619 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenu, 1);
32620 {
32621 if (temp1)
32622 delete arg1;
32623 }
32624 return resultobj;
32625 fail:
32626 {
32627 if (temp1)
32628 delete arg1;
32629 }
32630 return NULL;
32631 }
32632
32633
32634 static PyObject *_wrap_Menu_Append(PyObject *, PyObject *args, PyObject *kwargs) {
32635 PyObject *resultobj;
32636 wxMenu *arg1 = (wxMenu *) 0 ;
32637 int arg2 ;
32638 wxString *arg3 = 0 ;
32639 wxString const &arg4_defvalue = wxPyEmptyString ;
32640 wxString *arg4 = (wxString *) &arg4_defvalue ;
32641 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
32642 wxMenuItem *result;
32643 bool temp3 = false ;
32644 bool temp4 = false ;
32645 PyObject * obj0 = 0 ;
32646 PyObject * obj1 = 0 ;
32647 PyObject * obj2 = 0 ;
32648 PyObject * obj3 = 0 ;
32649 PyObject * obj4 = 0 ;
32650 char *kwnames[] = {
32651 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
32652 };
32653
32654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32656 if (SWIG_arg_fail(1)) SWIG_fail;
32657 {
32658 arg2 = (int)(SWIG_As_int(obj1));
32659 if (SWIG_arg_fail(2)) SWIG_fail;
32660 }
32661 {
32662 arg3 = wxString_in_helper(obj2);
32663 if (arg3 == NULL) SWIG_fail;
32664 temp3 = true;
32665 }
32666 if (obj3) {
32667 {
32668 arg4 = wxString_in_helper(obj3);
32669 if (arg4 == NULL) SWIG_fail;
32670 temp4 = true;
32671 }
32672 }
32673 if (obj4) {
32674 {
32675 arg5 = (wxItemKind)(SWIG_As_int(obj4));
32676 if (SWIG_arg_fail(5)) SWIG_fail;
32677 }
32678 }
32679 {
32680 PyThreadState* __tstate = wxPyBeginAllowThreads();
32681 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
32682
32683 wxPyEndAllowThreads(__tstate);
32684 if (PyErr_Occurred()) SWIG_fail;
32685 }
32686 {
32687 resultobj = wxPyMake_wxObject(result, 0);
32688 }
32689 {
32690 if (temp3)
32691 delete arg3;
32692 }
32693 {
32694 if (temp4)
32695 delete arg4;
32696 }
32697 return resultobj;
32698 fail:
32699 {
32700 if (temp3)
32701 delete arg3;
32702 }
32703 {
32704 if (temp4)
32705 delete arg4;
32706 }
32707 return NULL;
32708 }
32709
32710
32711 static PyObject *_wrap_Menu_AppendSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
32712 PyObject *resultobj;
32713 wxMenu *arg1 = (wxMenu *) 0 ;
32714 wxMenuItem *result;
32715 PyObject * obj0 = 0 ;
32716 char *kwnames[] = {
32717 (char *) "self", NULL
32718 };
32719
32720 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_AppendSeparator",kwnames,&obj0)) goto fail;
32721 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32722 if (SWIG_arg_fail(1)) SWIG_fail;
32723 {
32724 PyThreadState* __tstate = wxPyBeginAllowThreads();
32725 result = (wxMenuItem *)(arg1)->AppendSeparator();
32726
32727 wxPyEndAllowThreads(__tstate);
32728 if (PyErr_Occurred()) SWIG_fail;
32729 }
32730 {
32731 resultobj = wxPyMake_wxObject(result, 0);
32732 }
32733 return resultobj;
32734 fail:
32735 return NULL;
32736 }
32737
32738
32739 static PyObject *_wrap_Menu_AppendCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
32740 PyObject *resultobj;
32741 wxMenu *arg1 = (wxMenu *) 0 ;
32742 int arg2 ;
32743 wxString *arg3 = 0 ;
32744 wxString const &arg4_defvalue = wxPyEmptyString ;
32745 wxString *arg4 = (wxString *) &arg4_defvalue ;
32746 wxMenuItem *result;
32747 bool temp3 = false ;
32748 bool temp4 = false ;
32749 PyObject * obj0 = 0 ;
32750 PyObject * obj1 = 0 ;
32751 PyObject * obj2 = 0 ;
32752 PyObject * obj3 = 0 ;
32753 char *kwnames[] = {
32754 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32755 };
32756
32757 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32758 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32759 if (SWIG_arg_fail(1)) SWIG_fail;
32760 {
32761 arg2 = (int)(SWIG_As_int(obj1));
32762 if (SWIG_arg_fail(2)) SWIG_fail;
32763 }
32764 {
32765 arg3 = wxString_in_helper(obj2);
32766 if (arg3 == NULL) SWIG_fail;
32767 temp3 = true;
32768 }
32769 if (obj3) {
32770 {
32771 arg4 = wxString_in_helper(obj3);
32772 if (arg4 == NULL) SWIG_fail;
32773 temp4 = true;
32774 }
32775 }
32776 {
32777 PyThreadState* __tstate = wxPyBeginAllowThreads();
32778 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32779
32780 wxPyEndAllowThreads(__tstate);
32781 if (PyErr_Occurred()) SWIG_fail;
32782 }
32783 {
32784 resultobj = wxPyMake_wxObject(result, 0);
32785 }
32786 {
32787 if (temp3)
32788 delete arg3;
32789 }
32790 {
32791 if (temp4)
32792 delete arg4;
32793 }
32794 return resultobj;
32795 fail:
32796 {
32797 if (temp3)
32798 delete arg3;
32799 }
32800 {
32801 if (temp4)
32802 delete arg4;
32803 }
32804 return NULL;
32805 }
32806
32807
32808 static PyObject *_wrap_Menu_AppendRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
32809 PyObject *resultobj;
32810 wxMenu *arg1 = (wxMenu *) 0 ;
32811 int arg2 ;
32812 wxString *arg3 = 0 ;
32813 wxString const &arg4_defvalue = wxPyEmptyString ;
32814 wxString *arg4 = (wxString *) &arg4_defvalue ;
32815 wxMenuItem *result;
32816 bool temp3 = false ;
32817 bool temp4 = false ;
32818 PyObject * obj0 = 0 ;
32819 PyObject * obj1 = 0 ;
32820 PyObject * obj2 = 0 ;
32821 PyObject * obj3 = 0 ;
32822 char *kwnames[] = {
32823 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
32824 };
32825
32826 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
32827 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32828 if (SWIG_arg_fail(1)) SWIG_fail;
32829 {
32830 arg2 = (int)(SWIG_As_int(obj1));
32831 if (SWIG_arg_fail(2)) SWIG_fail;
32832 }
32833 {
32834 arg3 = wxString_in_helper(obj2);
32835 if (arg3 == NULL) SWIG_fail;
32836 temp3 = true;
32837 }
32838 if (obj3) {
32839 {
32840 arg4 = wxString_in_helper(obj3);
32841 if (arg4 == NULL) SWIG_fail;
32842 temp4 = true;
32843 }
32844 }
32845 {
32846 PyThreadState* __tstate = wxPyBeginAllowThreads();
32847 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
32848
32849 wxPyEndAllowThreads(__tstate);
32850 if (PyErr_Occurred()) SWIG_fail;
32851 }
32852 {
32853 resultobj = wxPyMake_wxObject(result, 0);
32854 }
32855 {
32856 if (temp3)
32857 delete arg3;
32858 }
32859 {
32860 if (temp4)
32861 delete arg4;
32862 }
32863 return resultobj;
32864 fail:
32865 {
32866 if (temp3)
32867 delete arg3;
32868 }
32869 {
32870 if (temp4)
32871 delete arg4;
32872 }
32873 return NULL;
32874 }
32875
32876
32877 static PyObject *_wrap_Menu_AppendMenu(PyObject *, PyObject *args, PyObject *kwargs) {
32878 PyObject *resultobj;
32879 wxMenu *arg1 = (wxMenu *) 0 ;
32880 int arg2 ;
32881 wxString *arg3 = 0 ;
32882 wxMenu *arg4 = (wxMenu *) 0 ;
32883 wxString const &arg5_defvalue = wxPyEmptyString ;
32884 wxString *arg5 = (wxString *) &arg5_defvalue ;
32885 wxMenuItem *result;
32886 bool temp3 = false ;
32887 bool temp5 = false ;
32888 PyObject * obj0 = 0 ;
32889 PyObject * obj1 = 0 ;
32890 PyObject * obj2 = 0 ;
32891 PyObject * obj3 = 0 ;
32892 PyObject * obj4 = 0 ;
32893 char *kwnames[] = {
32894 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
32895 };
32896
32897 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
32898 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32899 if (SWIG_arg_fail(1)) SWIG_fail;
32900 {
32901 arg2 = (int)(SWIG_As_int(obj1));
32902 if (SWIG_arg_fail(2)) SWIG_fail;
32903 }
32904 {
32905 arg3 = wxString_in_helper(obj2);
32906 if (arg3 == NULL) SWIG_fail;
32907 temp3 = true;
32908 }
32909 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32910 if (SWIG_arg_fail(4)) SWIG_fail;
32911 if (obj4) {
32912 {
32913 arg5 = wxString_in_helper(obj4);
32914 if (arg5 == NULL) SWIG_fail;
32915 temp5 = true;
32916 }
32917 }
32918 {
32919 PyThreadState* __tstate = wxPyBeginAllowThreads();
32920 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
32921
32922 wxPyEndAllowThreads(__tstate);
32923 if (PyErr_Occurred()) SWIG_fail;
32924 }
32925 {
32926 resultobj = wxPyMake_wxObject(result, 0);
32927 }
32928 {
32929 if (temp3)
32930 delete arg3;
32931 }
32932 {
32933 if (temp5)
32934 delete arg5;
32935 }
32936 return resultobj;
32937 fail:
32938 {
32939 if (temp3)
32940 delete arg3;
32941 }
32942 {
32943 if (temp5)
32944 delete arg5;
32945 }
32946 return NULL;
32947 }
32948
32949
32950 static PyObject *_wrap_Menu_AppendItem(PyObject *, PyObject *args, PyObject *kwargs) {
32951 PyObject *resultobj;
32952 wxMenu *arg1 = (wxMenu *) 0 ;
32953 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
32954 wxMenuItem *result;
32955 PyObject * obj0 = 0 ;
32956 PyObject * obj1 = 0 ;
32957 char *kwnames[] = {
32958 (char *) "self",(char *) "item", NULL
32959 };
32960
32961 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) goto fail;
32962 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32963 if (SWIG_arg_fail(1)) SWIG_fail;
32964 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
32965 if (SWIG_arg_fail(2)) SWIG_fail;
32966 {
32967 PyThreadState* __tstate = wxPyBeginAllowThreads();
32968 result = (wxMenuItem *)(arg1)->Append(arg2);
32969
32970 wxPyEndAllowThreads(__tstate);
32971 if (PyErr_Occurred()) SWIG_fail;
32972 }
32973 {
32974 resultobj = wxPyMake_wxObject(result, 0);
32975 }
32976 return resultobj;
32977 fail:
32978 return NULL;
32979 }
32980
32981
32982 static PyObject *_wrap_Menu_Break(PyObject *, PyObject *args, PyObject *kwargs) {
32983 PyObject *resultobj;
32984 wxMenu *arg1 = (wxMenu *) 0 ;
32985 PyObject * obj0 = 0 ;
32986 char *kwnames[] = {
32987 (char *) "self", NULL
32988 };
32989
32990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Break",kwnames,&obj0)) goto fail;
32991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
32992 if (SWIG_arg_fail(1)) SWIG_fail;
32993 {
32994 PyThreadState* __tstate = wxPyBeginAllowThreads();
32995 (arg1)->Break();
32996
32997 wxPyEndAllowThreads(__tstate);
32998 if (PyErr_Occurred()) SWIG_fail;
32999 }
33000 Py_INCREF(Py_None); resultobj = Py_None;
33001 return resultobj;
33002 fail:
33003 return NULL;
33004 }
33005
33006
33007 static PyObject *_wrap_Menu_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
33008 PyObject *resultobj;
33009 wxMenu *arg1 = (wxMenu *) 0 ;
33010 size_t arg2 ;
33011 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
33012 wxMenuItem *result;
33013 PyObject * obj0 = 0 ;
33014 PyObject * obj1 = 0 ;
33015 PyObject * obj2 = 0 ;
33016 char *kwnames[] = {
33017 (char *) "self",(char *) "pos",(char *) "item", NULL
33018 };
33019
33020 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
33021 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33022 if (SWIG_arg_fail(1)) SWIG_fail;
33023 {
33024 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33025 if (SWIG_arg_fail(2)) SWIG_fail;
33026 }
33027 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33028 if (SWIG_arg_fail(3)) SWIG_fail;
33029 {
33030 PyThreadState* __tstate = wxPyBeginAllowThreads();
33031 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
33032
33033 wxPyEndAllowThreads(__tstate);
33034 if (PyErr_Occurred()) SWIG_fail;
33035 }
33036 {
33037 resultobj = wxPyMake_wxObject(result, 0);
33038 }
33039 return resultobj;
33040 fail:
33041 return NULL;
33042 }
33043
33044
33045 static PyObject *_wrap_Menu_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
33046 PyObject *resultobj;
33047 wxMenu *arg1 = (wxMenu *) 0 ;
33048 size_t arg2 ;
33049 int arg3 ;
33050 wxString *arg4 = 0 ;
33051 wxString const &arg5_defvalue = wxPyEmptyString ;
33052 wxString *arg5 = (wxString *) &arg5_defvalue ;
33053 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
33054 wxMenuItem *result;
33055 bool temp4 = false ;
33056 bool temp5 = false ;
33057 PyObject * obj0 = 0 ;
33058 PyObject * obj1 = 0 ;
33059 PyObject * obj2 = 0 ;
33060 PyObject * obj3 = 0 ;
33061 PyObject * obj4 = 0 ;
33062 PyObject * obj5 = 0 ;
33063 char *kwnames[] = {
33064 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33065 };
33066
33067 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33068 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33069 if (SWIG_arg_fail(1)) SWIG_fail;
33070 {
33071 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33072 if (SWIG_arg_fail(2)) SWIG_fail;
33073 }
33074 {
33075 arg3 = (int)(SWIG_As_int(obj2));
33076 if (SWIG_arg_fail(3)) SWIG_fail;
33077 }
33078 {
33079 arg4 = wxString_in_helper(obj3);
33080 if (arg4 == NULL) SWIG_fail;
33081 temp4 = true;
33082 }
33083 if (obj4) {
33084 {
33085 arg5 = wxString_in_helper(obj4);
33086 if (arg5 == NULL) SWIG_fail;
33087 temp5 = true;
33088 }
33089 }
33090 if (obj5) {
33091 {
33092 arg6 = (wxItemKind)(SWIG_As_int(obj5));
33093 if (SWIG_arg_fail(6)) SWIG_fail;
33094 }
33095 }
33096 {
33097 PyThreadState* __tstate = wxPyBeginAllowThreads();
33098 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,(wxItemKind )arg6);
33099
33100 wxPyEndAllowThreads(__tstate);
33101 if (PyErr_Occurred()) SWIG_fail;
33102 }
33103 {
33104 resultobj = wxPyMake_wxObject(result, 0);
33105 }
33106 {
33107 if (temp4)
33108 delete arg4;
33109 }
33110 {
33111 if (temp5)
33112 delete arg5;
33113 }
33114 return resultobj;
33115 fail:
33116 {
33117 if (temp4)
33118 delete arg4;
33119 }
33120 {
33121 if (temp5)
33122 delete arg5;
33123 }
33124 return NULL;
33125 }
33126
33127
33128 static PyObject *_wrap_Menu_InsertSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33129 PyObject *resultobj;
33130 wxMenu *arg1 = (wxMenu *) 0 ;
33131 size_t arg2 ;
33132 wxMenuItem *result;
33133 PyObject * obj0 = 0 ;
33134 PyObject * obj1 = 0 ;
33135 char *kwnames[] = {
33136 (char *) "self",(char *) "pos", NULL
33137 };
33138
33139 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) goto fail;
33140 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33141 if (SWIG_arg_fail(1)) SWIG_fail;
33142 {
33143 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33144 if (SWIG_arg_fail(2)) SWIG_fail;
33145 }
33146 {
33147 PyThreadState* __tstate = wxPyBeginAllowThreads();
33148 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
33149
33150 wxPyEndAllowThreads(__tstate);
33151 if (PyErr_Occurred()) SWIG_fail;
33152 }
33153 {
33154 resultobj = wxPyMake_wxObject(result, 0);
33155 }
33156 return resultobj;
33157 fail:
33158 return NULL;
33159 }
33160
33161
33162 static PyObject *_wrap_Menu_InsertCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33163 PyObject *resultobj;
33164 wxMenu *arg1 = (wxMenu *) 0 ;
33165 size_t arg2 ;
33166 int arg3 ;
33167 wxString *arg4 = 0 ;
33168 wxString const &arg5_defvalue = wxPyEmptyString ;
33169 wxString *arg5 = (wxString *) &arg5_defvalue ;
33170 wxMenuItem *result;
33171 bool temp4 = false ;
33172 bool temp5 = false ;
33173 PyObject * obj0 = 0 ;
33174 PyObject * obj1 = 0 ;
33175 PyObject * obj2 = 0 ;
33176 PyObject * obj3 = 0 ;
33177 PyObject * obj4 = 0 ;
33178 char *kwnames[] = {
33179 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33180 };
33181
33182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33184 if (SWIG_arg_fail(1)) SWIG_fail;
33185 {
33186 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33187 if (SWIG_arg_fail(2)) SWIG_fail;
33188 }
33189 {
33190 arg3 = (int)(SWIG_As_int(obj2));
33191 if (SWIG_arg_fail(3)) SWIG_fail;
33192 }
33193 {
33194 arg4 = wxString_in_helper(obj3);
33195 if (arg4 == NULL) SWIG_fail;
33196 temp4 = true;
33197 }
33198 if (obj4) {
33199 {
33200 arg5 = wxString_in_helper(obj4);
33201 if (arg5 == NULL) SWIG_fail;
33202 temp5 = true;
33203 }
33204 }
33205 {
33206 PyThreadState* __tstate = wxPyBeginAllowThreads();
33207 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33208
33209 wxPyEndAllowThreads(__tstate);
33210 if (PyErr_Occurred()) SWIG_fail;
33211 }
33212 {
33213 resultobj = wxPyMake_wxObject(result, 0);
33214 }
33215 {
33216 if (temp4)
33217 delete arg4;
33218 }
33219 {
33220 if (temp5)
33221 delete arg5;
33222 }
33223 return resultobj;
33224 fail:
33225 {
33226 if (temp4)
33227 delete arg4;
33228 }
33229 {
33230 if (temp5)
33231 delete arg5;
33232 }
33233 return NULL;
33234 }
33235
33236
33237 static PyObject *_wrap_Menu_InsertRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33238 PyObject *resultobj;
33239 wxMenu *arg1 = (wxMenu *) 0 ;
33240 size_t arg2 ;
33241 int arg3 ;
33242 wxString *arg4 = 0 ;
33243 wxString const &arg5_defvalue = wxPyEmptyString ;
33244 wxString *arg5 = (wxString *) &arg5_defvalue ;
33245 wxMenuItem *result;
33246 bool temp4 = false ;
33247 bool temp5 = false ;
33248 PyObject * obj0 = 0 ;
33249 PyObject * obj1 = 0 ;
33250 PyObject * obj2 = 0 ;
33251 PyObject * obj3 = 0 ;
33252 PyObject * obj4 = 0 ;
33253 char *kwnames[] = {
33254 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
33255 };
33256
33257 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33258 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33259 if (SWIG_arg_fail(1)) SWIG_fail;
33260 {
33261 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33262 if (SWIG_arg_fail(2)) SWIG_fail;
33263 }
33264 {
33265 arg3 = (int)(SWIG_As_int(obj2));
33266 if (SWIG_arg_fail(3)) SWIG_fail;
33267 }
33268 {
33269 arg4 = wxString_in_helper(obj3);
33270 if (arg4 == NULL) SWIG_fail;
33271 temp4 = true;
33272 }
33273 if (obj4) {
33274 {
33275 arg5 = wxString_in_helper(obj4);
33276 if (arg5 == NULL) SWIG_fail;
33277 temp5 = true;
33278 }
33279 }
33280 {
33281 PyThreadState* __tstate = wxPyBeginAllowThreads();
33282 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
33283
33284 wxPyEndAllowThreads(__tstate);
33285 if (PyErr_Occurred()) SWIG_fail;
33286 }
33287 {
33288 resultobj = wxPyMake_wxObject(result, 0);
33289 }
33290 {
33291 if (temp4)
33292 delete arg4;
33293 }
33294 {
33295 if (temp5)
33296 delete arg5;
33297 }
33298 return resultobj;
33299 fail:
33300 {
33301 if (temp4)
33302 delete arg4;
33303 }
33304 {
33305 if (temp5)
33306 delete arg5;
33307 }
33308 return NULL;
33309 }
33310
33311
33312 static PyObject *_wrap_Menu_InsertMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33313 PyObject *resultobj;
33314 wxMenu *arg1 = (wxMenu *) 0 ;
33315 size_t arg2 ;
33316 int arg3 ;
33317 wxString *arg4 = 0 ;
33318 wxMenu *arg5 = (wxMenu *) 0 ;
33319 wxString const &arg6_defvalue = wxPyEmptyString ;
33320 wxString *arg6 = (wxString *) &arg6_defvalue ;
33321 wxMenuItem *result;
33322 bool temp4 = false ;
33323 bool temp6 = false ;
33324 PyObject * obj0 = 0 ;
33325 PyObject * obj1 = 0 ;
33326 PyObject * obj2 = 0 ;
33327 PyObject * obj3 = 0 ;
33328 PyObject * obj4 = 0 ;
33329 PyObject * obj5 = 0 ;
33330 char *kwnames[] = {
33331 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33332 };
33333
33334 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
33335 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33336 if (SWIG_arg_fail(1)) SWIG_fail;
33337 {
33338 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
33339 if (SWIG_arg_fail(2)) SWIG_fail;
33340 }
33341 {
33342 arg3 = (int)(SWIG_As_int(obj2));
33343 if (SWIG_arg_fail(3)) SWIG_fail;
33344 }
33345 {
33346 arg4 = wxString_in_helper(obj3);
33347 if (arg4 == NULL) SWIG_fail;
33348 temp4 = true;
33349 }
33350 SWIG_Python_ConvertPtr(obj4, (void **)&arg5, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33351 if (SWIG_arg_fail(5)) SWIG_fail;
33352 if (obj5) {
33353 {
33354 arg6 = wxString_in_helper(obj5);
33355 if (arg6 == NULL) SWIG_fail;
33356 temp6 = true;
33357 }
33358 }
33359 {
33360 PyThreadState* __tstate = wxPyBeginAllowThreads();
33361 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
33362
33363 wxPyEndAllowThreads(__tstate);
33364 if (PyErr_Occurred()) SWIG_fail;
33365 }
33366 {
33367 resultobj = wxPyMake_wxObject(result, 0);
33368 }
33369 {
33370 if (temp4)
33371 delete arg4;
33372 }
33373 {
33374 if (temp6)
33375 delete arg6;
33376 }
33377 return resultobj;
33378 fail:
33379 {
33380 if (temp4)
33381 delete arg4;
33382 }
33383 {
33384 if (temp6)
33385 delete arg6;
33386 }
33387 return NULL;
33388 }
33389
33390
33391 static PyObject *_wrap_Menu_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
33392 PyObject *resultobj;
33393 wxMenu *arg1 = (wxMenu *) 0 ;
33394 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33395 wxMenuItem *result;
33396 PyObject * obj0 = 0 ;
33397 PyObject * obj1 = 0 ;
33398 char *kwnames[] = {
33399 (char *) "self",(char *) "item", NULL
33400 };
33401
33402 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) goto fail;
33403 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33404 if (SWIG_arg_fail(1)) SWIG_fail;
33405 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33406 if (SWIG_arg_fail(2)) SWIG_fail;
33407 {
33408 PyThreadState* __tstate = wxPyBeginAllowThreads();
33409 result = (wxMenuItem *)(arg1)->Prepend(arg2);
33410
33411 wxPyEndAllowThreads(__tstate);
33412 if (PyErr_Occurred()) SWIG_fail;
33413 }
33414 {
33415 resultobj = wxPyMake_wxObject(result, 0);
33416 }
33417 return resultobj;
33418 fail:
33419 return NULL;
33420 }
33421
33422
33423 static PyObject *_wrap_Menu_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
33424 PyObject *resultobj;
33425 wxMenu *arg1 = (wxMenu *) 0 ;
33426 int arg2 ;
33427 wxString *arg3 = 0 ;
33428 wxString const &arg4_defvalue = wxPyEmptyString ;
33429 wxString *arg4 = (wxString *) &arg4_defvalue ;
33430 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
33431 wxMenuItem *result;
33432 bool temp3 = false ;
33433 bool temp4 = false ;
33434 PyObject * obj0 = 0 ;
33435 PyObject * obj1 = 0 ;
33436 PyObject * obj2 = 0 ;
33437 PyObject * obj3 = 0 ;
33438 PyObject * obj4 = 0 ;
33439 char *kwnames[] = {
33440 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
33441 };
33442
33443 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33444 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33445 if (SWIG_arg_fail(1)) SWIG_fail;
33446 {
33447 arg2 = (int)(SWIG_As_int(obj1));
33448 if (SWIG_arg_fail(2)) SWIG_fail;
33449 }
33450 {
33451 arg3 = wxString_in_helper(obj2);
33452 if (arg3 == NULL) SWIG_fail;
33453 temp3 = true;
33454 }
33455 if (obj3) {
33456 {
33457 arg4 = wxString_in_helper(obj3);
33458 if (arg4 == NULL) SWIG_fail;
33459 temp4 = true;
33460 }
33461 }
33462 if (obj4) {
33463 {
33464 arg5 = (wxItemKind)(SWIG_As_int(obj4));
33465 if (SWIG_arg_fail(5)) SWIG_fail;
33466 }
33467 }
33468 {
33469 PyThreadState* __tstate = wxPyBeginAllowThreads();
33470 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5);
33471
33472 wxPyEndAllowThreads(__tstate);
33473 if (PyErr_Occurred()) SWIG_fail;
33474 }
33475 {
33476 resultobj = wxPyMake_wxObject(result, 0);
33477 }
33478 {
33479 if (temp3)
33480 delete arg3;
33481 }
33482 {
33483 if (temp4)
33484 delete arg4;
33485 }
33486 return resultobj;
33487 fail:
33488 {
33489 if (temp3)
33490 delete arg3;
33491 }
33492 {
33493 if (temp4)
33494 delete arg4;
33495 }
33496 return NULL;
33497 }
33498
33499
33500 static PyObject *_wrap_Menu_PrependSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
33501 PyObject *resultobj;
33502 wxMenu *arg1 = (wxMenu *) 0 ;
33503 wxMenuItem *result;
33504 PyObject * obj0 = 0 ;
33505 char *kwnames[] = {
33506 (char *) "self", NULL
33507 };
33508
33509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_PrependSeparator",kwnames,&obj0)) goto fail;
33510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33511 if (SWIG_arg_fail(1)) SWIG_fail;
33512 {
33513 PyThreadState* __tstate = wxPyBeginAllowThreads();
33514 result = (wxMenuItem *)(arg1)->PrependSeparator();
33515
33516 wxPyEndAllowThreads(__tstate);
33517 if (PyErr_Occurred()) SWIG_fail;
33518 }
33519 {
33520 resultobj = wxPyMake_wxObject(result, 0);
33521 }
33522 return resultobj;
33523 fail:
33524 return NULL;
33525 }
33526
33527
33528 static PyObject *_wrap_Menu_PrependCheckItem(PyObject *, PyObject *args, PyObject *kwargs) {
33529 PyObject *resultobj;
33530 wxMenu *arg1 = (wxMenu *) 0 ;
33531 int arg2 ;
33532 wxString *arg3 = 0 ;
33533 wxString const &arg4_defvalue = wxPyEmptyString ;
33534 wxString *arg4 = (wxString *) &arg4_defvalue ;
33535 wxMenuItem *result;
33536 bool temp3 = false ;
33537 bool temp4 = false ;
33538 PyObject * obj0 = 0 ;
33539 PyObject * obj1 = 0 ;
33540 PyObject * obj2 = 0 ;
33541 PyObject * obj3 = 0 ;
33542 char *kwnames[] = {
33543 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33544 };
33545
33546 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33547 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33548 if (SWIG_arg_fail(1)) SWIG_fail;
33549 {
33550 arg2 = (int)(SWIG_As_int(obj1));
33551 if (SWIG_arg_fail(2)) SWIG_fail;
33552 }
33553 {
33554 arg3 = wxString_in_helper(obj2);
33555 if (arg3 == NULL) SWIG_fail;
33556 temp3 = true;
33557 }
33558 if (obj3) {
33559 {
33560 arg4 = wxString_in_helper(obj3);
33561 if (arg4 == NULL) SWIG_fail;
33562 temp4 = true;
33563 }
33564 }
33565 {
33566 PyThreadState* __tstate = wxPyBeginAllowThreads();
33567 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33568
33569 wxPyEndAllowThreads(__tstate);
33570 if (PyErr_Occurred()) SWIG_fail;
33571 }
33572 {
33573 resultobj = wxPyMake_wxObject(result, 0);
33574 }
33575 {
33576 if (temp3)
33577 delete arg3;
33578 }
33579 {
33580 if (temp4)
33581 delete arg4;
33582 }
33583 return resultobj;
33584 fail:
33585 {
33586 if (temp3)
33587 delete arg3;
33588 }
33589 {
33590 if (temp4)
33591 delete arg4;
33592 }
33593 return NULL;
33594 }
33595
33596
33597 static PyObject *_wrap_Menu_PrependRadioItem(PyObject *, PyObject *args, PyObject *kwargs) {
33598 PyObject *resultobj;
33599 wxMenu *arg1 = (wxMenu *) 0 ;
33600 int arg2 ;
33601 wxString *arg3 = 0 ;
33602 wxString const &arg4_defvalue = wxPyEmptyString ;
33603 wxString *arg4 = (wxString *) &arg4_defvalue ;
33604 wxMenuItem *result;
33605 bool temp3 = false ;
33606 bool temp4 = false ;
33607 PyObject * obj0 = 0 ;
33608 PyObject * obj1 = 0 ;
33609 PyObject * obj2 = 0 ;
33610 PyObject * obj3 = 0 ;
33611 char *kwnames[] = {
33612 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
33613 };
33614
33615 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
33616 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33617 if (SWIG_arg_fail(1)) SWIG_fail;
33618 {
33619 arg2 = (int)(SWIG_As_int(obj1));
33620 if (SWIG_arg_fail(2)) SWIG_fail;
33621 }
33622 {
33623 arg3 = wxString_in_helper(obj2);
33624 if (arg3 == NULL) SWIG_fail;
33625 temp3 = true;
33626 }
33627 if (obj3) {
33628 {
33629 arg4 = wxString_in_helper(obj3);
33630 if (arg4 == NULL) SWIG_fail;
33631 temp4 = true;
33632 }
33633 }
33634 {
33635 PyThreadState* __tstate = wxPyBeginAllowThreads();
33636 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
33637
33638 wxPyEndAllowThreads(__tstate);
33639 if (PyErr_Occurred()) SWIG_fail;
33640 }
33641 {
33642 resultobj = wxPyMake_wxObject(result, 0);
33643 }
33644 {
33645 if (temp3)
33646 delete arg3;
33647 }
33648 {
33649 if (temp4)
33650 delete arg4;
33651 }
33652 return resultobj;
33653 fail:
33654 {
33655 if (temp3)
33656 delete arg3;
33657 }
33658 {
33659 if (temp4)
33660 delete arg4;
33661 }
33662 return NULL;
33663 }
33664
33665
33666 static PyObject *_wrap_Menu_PrependMenu(PyObject *, PyObject *args, PyObject *kwargs) {
33667 PyObject *resultobj;
33668 wxMenu *arg1 = (wxMenu *) 0 ;
33669 int arg2 ;
33670 wxString *arg3 = 0 ;
33671 wxMenu *arg4 = (wxMenu *) 0 ;
33672 wxString const &arg5_defvalue = wxPyEmptyString ;
33673 wxString *arg5 = (wxString *) &arg5_defvalue ;
33674 wxMenuItem *result;
33675 bool temp3 = false ;
33676 bool temp5 = false ;
33677 PyObject * obj0 = 0 ;
33678 PyObject * obj1 = 0 ;
33679 PyObject * obj2 = 0 ;
33680 PyObject * obj3 = 0 ;
33681 PyObject * obj4 = 0 ;
33682 char *kwnames[] = {
33683 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
33684 };
33685
33686 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
33687 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33688 if (SWIG_arg_fail(1)) SWIG_fail;
33689 {
33690 arg2 = (int)(SWIG_As_int(obj1));
33691 if (SWIG_arg_fail(2)) SWIG_fail;
33692 }
33693 {
33694 arg3 = wxString_in_helper(obj2);
33695 if (arg3 == NULL) SWIG_fail;
33696 temp3 = true;
33697 }
33698 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33699 if (SWIG_arg_fail(4)) SWIG_fail;
33700 if (obj4) {
33701 {
33702 arg5 = wxString_in_helper(obj4);
33703 if (arg5 == NULL) SWIG_fail;
33704 temp5 = true;
33705 }
33706 }
33707 {
33708 PyThreadState* __tstate = wxPyBeginAllowThreads();
33709 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
33710
33711 wxPyEndAllowThreads(__tstate);
33712 if (PyErr_Occurred()) SWIG_fail;
33713 }
33714 {
33715 resultobj = wxPyMake_wxObject(result, 0);
33716 }
33717 {
33718 if (temp3)
33719 delete arg3;
33720 }
33721 {
33722 if (temp5)
33723 delete arg5;
33724 }
33725 return resultobj;
33726 fail:
33727 {
33728 if (temp3)
33729 delete arg3;
33730 }
33731 {
33732 if (temp5)
33733 delete arg5;
33734 }
33735 return NULL;
33736 }
33737
33738
33739 static PyObject *_wrap_Menu_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
33740 PyObject *resultobj;
33741 wxMenu *arg1 = (wxMenu *) 0 ;
33742 int arg2 ;
33743 wxMenuItem *result;
33744 PyObject * obj0 = 0 ;
33745 PyObject * obj1 = 0 ;
33746 char *kwnames[] = {
33747 (char *) "self",(char *) "id", NULL
33748 };
33749
33750 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) goto fail;
33751 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33752 if (SWIG_arg_fail(1)) SWIG_fail;
33753 {
33754 arg2 = (int)(SWIG_As_int(obj1));
33755 if (SWIG_arg_fail(2)) SWIG_fail;
33756 }
33757 {
33758 PyThreadState* __tstate = wxPyBeginAllowThreads();
33759 result = (wxMenuItem *)(arg1)->Remove(arg2);
33760
33761 wxPyEndAllowThreads(__tstate);
33762 if (PyErr_Occurred()) SWIG_fail;
33763 }
33764 {
33765 resultobj = wxPyMake_wxObject(result, 0);
33766 }
33767 return resultobj;
33768 fail:
33769 return NULL;
33770 }
33771
33772
33773 static PyObject *_wrap_Menu_RemoveItem(PyObject *, PyObject *args, PyObject *kwargs) {
33774 PyObject *resultobj;
33775 wxMenu *arg1 = (wxMenu *) 0 ;
33776 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33777 wxMenuItem *result;
33778 PyObject * obj0 = 0 ;
33779 PyObject * obj1 = 0 ;
33780 char *kwnames[] = {
33781 (char *) "self",(char *) "item", NULL
33782 };
33783
33784 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) goto fail;
33785 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33786 if (SWIG_arg_fail(1)) SWIG_fail;
33787 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33788 if (SWIG_arg_fail(2)) SWIG_fail;
33789 {
33790 PyThreadState* __tstate = wxPyBeginAllowThreads();
33791 result = (wxMenuItem *)(arg1)->Remove(arg2);
33792
33793 wxPyEndAllowThreads(__tstate);
33794 if (PyErr_Occurred()) SWIG_fail;
33795 }
33796 {
33797 resultobj = wxPyMake_wxObject(result, 0);
33798 }
33799 return resultobj;
33800 fail:
33801 return NULL;
33802 }
33803
33804
33805 static PyObject *_wrap_Menu_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
33806 PyObject *resultobj;
33807 wxMenu *arg1 = (wxMenu *) 0 ;
33808 int arg2 ;
33809 bool result;
33810 PyObject * obj0 = 0 ;
33811 PyObject * obj1 = 0 ;
33812 char *kwnames[] = {
33813 (char *) "self",(char *) "id", NULL
33814 };
33815
33816 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) goto fail;
33817 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33818 if (SWIG_arg_fail(1)) SWIG_fail;
33819 {
33820 arg2 = (int)(SWIG_As_int(obj1));
33821 if (SWIG_arg_fail(2)) SWIG_fail;
33822 }
33823 {
33824 PyThreadState* __tstate = wxPyBeginAllowThreads();
33825 result = (bool)(arg1)->Delete(arg2);
33826
33827 wxPyEndAllowThreads(__tstate);
33828 if (PyErr_Occurred()) SWIG_fail;
33829 }
33830 {
33831 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33832 }
33833 return resultobj;
33834 fail:
33835 return NULL;
33836 }
33837
33838
33839 static PyObject *_wrap_Menu_DeleteItem(PyObject *, PyObject *args, PyObject *kwargs) {
33840 PyObject *resultobj;
33841 wxMenu *arg1 = (wxMenu *) 0 ;
33842 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33843 bool result;
33844 PyObject * obj0 = 0 ;
33845 PyObject * obj1 = 0 ;
33846 char *kwnames[] = {
33847 (char *) "self",(char *) "item", NULL
33848 };
33849
33850 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) goto fail;
33851 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33852 if (SWIG_arg_fail(1)) SWIG_fail;
33853 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33854 if (SWIG_arg_fail(2)) SWIG_fail;
33855 {
33856 PyThreadState* __tstate = wxPyBeginAllowThreads();
33857 result = (bool)(arg1)->Delete(arg2);
33858
33859 wxPyEndAllowThreads(__tstate);
33860 if (PyErr_Occurred()) SWIG_fail;
33861 }
33862 {
33863 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33864 }
33865 return resultobj;
33866 fail:
33867 return NULL;
33868 }
33869
33870
33871 static PyObject *_wrap_Menu_Destroy(PyObject *, PyObject *args, PyObject *kwargs) {
33872 PyObject *resultobj;
33873 wxMenu *arg1 = (wxMenu *) 0 ;
33874 PyObject * obj0 = 0 ;
33875 char *kwnames[] = {
33876 (char *) "self", NULL
33877 };
33878
33879 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Destroy",kwnames,&obj0)) goto fail;
33880 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33881 if (SWIG_arg_fail(1)) SWIG_fail;
33882 {
33883 PyThreadState* __tstate = wxPyBeginAllowThreads();
33884 wxMenu_Destroy(arg1);
33885
33886 wxPyEndAllowThreads(__tstate);
33887 if (PyErr_Occurred()) SWIG_fail;
33888 }
33889 Py_INCREF(Py_None); resultobj = Py_None;
33890 return resultobj;
33891 fail:
33892 return NULL;
33893 }
33894
33895
33896 static PyObject *_wrap_Menu_DestroyId(PyObject *, PyObject *args, PyObject *kwargs) {
33897 PyObject *resultobj;
33898 wxMenu *arg1 = (wxMenu *) 0 ;
33899 int arg2 ;
33900 bool result;
33901 PyObject * obj0 = 0 ;
33902 PyObject * obj1 = 0 ;
33903 char *kwnames[] = {
33904 (char *) "self",(char *) "id", NULL
33905 };
33906
33907 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) goto fail;
33908 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33909 if (SWIG_arg_fail(1)) SWIG_fail;
33910 {
33911 arg2 = (int)(SWIG_As_int(obj1));
33912 if (SWIG_arg_fail(2)) SWIG_fail;
33913 }
33914 {
33915 PyThreadState* __tstate = wxPyBeginAllowThreads();
33916 result = (bool)(arg1)->Destroy(arg2);
33917
33918 wxPyEndAllowThreads(__tstate);
33919 if (PyErr_Occurred()) SWIG_fail;
33920 }
33921 {
33922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33923 }
33924 return resultobj;
33925 fail:
33926 return NULL;
33927 }
33928
33929
33930 static PyObject *_wrap_Menu_DestroyItem(PyObject *, PyObject *args, PyObject *kwargs) {
33931 PyObject *resultobj;
33932 wxMenu *arg1 = (wxMenu *) 0 ;
33933 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
33934 bool result;
33935 PyObject * obj0 = 0 ;
33936 PyObject * obj1 = 0 ;
33937 char *kwnames[] = {
33938 (char *) "self",(char *) "item", NULL
33939 };
33940
33941 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) goto fail;
33942 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33943 if (SWIG_arg_fail(1)) SWIG_fail;
33944 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
33945 if (SWIG_arg_fail(2)) SWIG_fail;
33946 {
33947 PyThreadState* __tstate = wxPyBeginAllowThreads();
33948 result = (bool)(arg1)->Destroy(arg2);
33949
33950 wxPyEndAllowThreads(__tstate);
33951 if (PyErr_Occurred()) SWIG_fail;
33952 }
33953 {
33954 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33955 }
33956 return resultobj;
33957 fail:
33958 return NULL;
33959 }
33960
33961
33962 static PyObject *_wrap_Menu_GetMenuItemCount(PyObject *, PyObject *args, PyObject *kwargs) {
33963 PyObject *resultobj;
33964 wxMenu *arg1 = (wxMenu *) 0 ;
33965 size_t result;
33966 PyObject * obj0 = 0 ;
33967 char *kwnames[] = {
33968 (char *) "self", NULL
33969 };
33970
33971 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItemCount",kwnames,&obj0)) goto fail;
33972 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
33973 if (SWIG_arg_fail(1)) SWIG_fail;
33974 {
33975 PyThreadState* __tstate = wxPyBeginAllowThreads();
33976 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
33977
33978 wxPyEndAllowThreads(__tstate);
33979 if (PyErr_Occurred()) SWIG_fail;
33980 }
33981 {
33982 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
33983 }
33984 return resultobj;
33985 fail:
33986 return NULL;
33987 }
33988
33989
33990 static PyObject *_wrap_Menu_GetMenuItems(PyObject *, PyObject *args, PyObject *kwargs) {
33991 PyObject *resultobj;
33992 wxMenu *arg1 = (wxMenu *) 0 ;
33993 PyObject *result;
33994 PyObject * obj0 = 0 ;
33995 char *kwnames[] = {
33996 (char *) "self", NULL
33997 };
33998
33999 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuItems",kwnames,&obj0)) goto fail;
34000 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34001 if (SWIG_arg_fail(1)) SWIG_fail;
34002 {
34003 PyThreadState* __tstate = wxPyBeginAllowThreads();
34004 result = (PyObject *)wxMenu_GetMenuItems(arg1);
34005
34006 wxPyEndAllowThreads(__tstate);
34007 if (PyErr_Occurred()) SWIG_fail;
34008 }
34009 resultobj = result;
34010 return resultobj;
34011 fail:
34012 return NULL;
34013 }
34014
34015
34016 static PyObject *_wrap_Menu_FindItem(PyObject *, PyObject *args, PyObject *kwargs) {
34017 PyObject *resultobj;
34018 wxMenu *arg1 = (wxMenu *) 0 ;
34019 wxString *arg2 = 0 ;
34020 int result;
34021 bool temp2 = false ;
34022 PyObject * obj0 = 0 ;
34023 PyObject * obj1 = 0 ;
34024 char *kwnames[] = {
34025 (char *) "self",(char *) "item", NULL
34026 };
34027
34028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) goto fail;
34029 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34030 if (SWIG_arg_fail(1)) SWIG_fail;
34031 {
34032 arg2 = wxString_in_helper(obj1);
34033 if (arg2 == NULL) SWIG_fail;
34034 temp2 = true;
34035 }
34036 {
34037 PyThreadState* __tstate = wxPyBeginAllowThreads();
34038 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
34039
34040 wxPyEndAllowThreads(__tstate);
34041 if (PyErr_Occurred()) SWIG_fail;
34042 }
34043 {
34044 resultobj = SWIG_From_int((int)(result));
34045 }
34046 {
34047 if (temp2)
34048 delete arg2;
34049 }
34050 return resultobj;
34051 fail:
34052 {
34053 if (temp2)
34054 delete arg2;
34055 }
34056 return NULL;
34057 }
34058
34059
34060 static PyObject *_wrap_Menu_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
34061 PyObject *resultobj;
34062 wxMenu *arg1 = (wxMenu *) 0 ;
34063 int arg2 ;
34064 wxMenuItem *result;
34065 PyObject * obj0 = 0 ;
34066 PyObject * obj1 = 0 ;
34067 char *kwnames[] = {
34068 (char *) "self",(char *) "id", NULL
34069 };
34070
34071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) goto fail;
34072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34073 if (SWIG_arg_fail(1)) SWIG_fail;
34074 {
34075 arg2 = (int)(SWIG_As_int(obj1));
34076 if (SWIG_arg_fail(2)) SWIG_fail;
34077 }
34078 {
34079 PyThreadState* __tstate = wxPyBeginAllowThreads();
34080 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
34081
34082 wxPyEndAllowThreads(__tstate);
34083 if (PyErr_Occurred()) SWIG_fail;
34084 }
34085 {
34086 resultobj = wxPyMake_wxObject(result, 0);
34087 }
34088 return resultobj;
34089 fail:
34090 return NULL;
34091 }
34092
34093
34094 static PyObject *_wrap_Menu_FindItemByPosition(PyObject *, PyObject *args, PyObject *kwargs) {
34095 PyObject *resultobj;
34096 wxMenu *arg1 = (wxMenu *) 0 ;
34097 size_t arg2 ;
34098 wxMenuItem *result;
34099 PyObject * obj0 = 0 ;
34100 PyObject * obj1 = 0 ;
34101 char *kwnames[] = {
34102 (char *) "self",(char *) "position", NULL
34103 };
34104
34105 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) goto fail;
34106 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34107 if (SWIG_arg_fail(1)) SWIG_fail;
34108 {
34109 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34110 if (SWIG_arg_fail(2)) SWIG_fail;
34111 }
34112 {
34113 PyThreadState* __tstate = wxPyBeginAllowThreads();
34114 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
34115
34116 wxPyEndAllowThreads(__tstate);
34117 if (PyErr_Occurred()) SWIG_fail;
34118 }
34119 {
34120 resultobj = wxPyMake_wxObject(result, 0);
34121 }
34122 return resultobj;
34123 fail:
34124 return NULL;
34125 }
34126
34127
34128 static PyObject *_wrap_Menu_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
34129 PyObject *resultobj;
34130 wxMenu *arg1 = (wxMenu *) 0 ;
34131 int arg2 ;
34132 bool arg3 ;
34133 PyObject * obj0 = 0 ;
34134 PyObject * obj1 = 0 ;
34135 PyObject * obj2 = 0 ;
34136 char *kwnames[] = {
34137 (char *) "self",(char *) "id",(char *) "enable", NULL
34138 };
34139
34140 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
34141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34142 if (SWIG_arg_fail(1)) SWIG_fail;
34143 {
34144 arg2 = (int)(SWIG_As_int(obj1));
34145 if (SWIG_arg_fail(2)) SWIG_fail;
34146 }
34147 {
34148 arg3 = (bool)(SWIG_As_bool(obj2));
34149 if (SWIG_arg_fail(3)) SWIG_fail;
34150 }
34151 {
34152 PyThreadState* __tstate = wxPyBeginAllowThreads();
34153 (arg1)->Enable(arg2,arg3);
34154
34155 wxPyEndAllowThreads(__tstate);
34156 if (PyErr_Occurred()) SWIG_fail;
34157 }
34158 Py_INCREF(Py_None); resultobj = Py_None;
34159 return resultobj;
34160 fail:
34161 return NULL;
34162 }
34163
34164
34165 static PyObject *_wrap_Menu_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
34166 PyObject *resultobj;
34167 wxMenu *arg1 = (wxMenu *) 0 ;
34168 int arg2 ;
34169 bool result;
34170 PyObject * obj0 = 0 ;
34171 PyObject * obj1 = 0 ;
34172 char *kwnames[] = {
34173 (char *) "self",(char *) "id", NULL
34174 };
34175
34176 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
34177 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34178 if (SWIG_arg_fail(1)) SWIG_fail;
34179 {
34180 arg2 = (int)(SWIG_As_int(obj1));
34181 if (SWIG_arg_fail(2)) SWIG_fail;
34182 }
34183 {
34184 PyThreadState* __tstate = wxPyBeginAllowThreads();
34185 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
34186
34187 wxPyEndAllowThreads(__tstate);
34188 if (PyErr_Occurred()) SWIG_fail;
34189 }
34190 {
34191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34192 }
34193 return resultobj;
34194 fail:
34195 return NULL;
34196 }
34197
34198
34199 static PyObject *_wrap_Menu_Check(PyObject *, PyObject *args, PyObject *kwargs) {
34200 PyObject *resultobj;
34201 wxMenu *arg1 = (wxMenu *) 0 ;
34202 int arg2 ;
34203 bool arg3 ;
34204 PyObject * obj0 = 0 ;
34205 PyObject * obj1 = 0 ;
34206 PyObject * obj2 = 0 ;
34207 char *kwnames[] = {
34208 (char *) "self",(char *) "id",(char *) "check", NULL
34209 };
34210
34211 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
34212 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34213 if (SWIG_arg_fail(1)) SWIG_fail;
34214 {
34215 arg2 = (int)(SWIG_As_int(obj1));
34216 if (SWIG_arg_fail(2)) SWIG_fail;
34217 }
34218 {
34219 arg3 = (bool)(SWIG_As_bool(obj2));
34220 if (SWIG_arg_fail(3)) SWIG_fail;
34221 }
34222 {
34223 PyThreadState* __tstate = wxPyBeginAllowThreads();
34224 (arg1)->Check(arg2,arg3);
34225
34226 wxPyEndAllowThreads(__tstate);
34227 if (PyErr_Occurred()) SWIG_fail;
34228 }
34229 Py_INCREF(Py_None); resultobj = Py_None;
34230 return resultobj;
34231 fail:
34232 return NULL;
34233 }
34234
34235
34236 static PyObject *_wrap_Menu_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
34237 PyObject *resultobj;
34238 wxMenu *arg1 = (wxMenu *) 0 ;
34239 int arg2 ;
34240 bool result;
34241 PyObject * obj0 = 0 ;
34242 PyObject * obj1 = 0 ;
34243 char *kwnames[] = {
34244 (char *) "self",(char *) "id", NULL
34245 };
34246
34247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) goto fail;
34248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34249 if (SWIG_arg_fail(1)) SWIG_fail;
34250 {
34251 arg2 = (int)(SWIG_As_int(obj1));
34252 if (SWIG_arg_fail(2)) SWIG_fail;
34253 }
34254 {
34255 PyThreadState* __tstate = wxPyBeginAllowThreads();
34256 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
34257
34258 wxPyEndAllowThreads(__tstate);
34259 if (PyErr_Occurred()) SWIG_fail;
34260 }
34261 {
34262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34263 }
34264 return resultobj;
34265 fail:
34266 return NULL;
34267 }
34268
34269
34270 static PyObject *_wrap_Menu_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34271 PyObject *resultobj;
34272 wxMenu *arg1 = (wxMenu *) 0 ;
34273 int arg2 ;
34274 wxString *arg3 = 0 ;
34275 bool temp3 = false ;
34276 PyObject * obj0 = 0 ;
34277 PyObject * obj1 = 0 ;
34278 PyObject * obj2 = 0 ;
34279 char *kwnames[] = {
34280 (char *) "self",(char *) "id",(char *) "label", NULL
34281 };
34282
34283 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
34284 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34285 if (SWIG_arg_fail(1)) SWIG_fail;
34286 {
34287 arg2 = (int)(SWIG_As_int(obj1));
34288 if (SWIG_arg_fail(2)) SWIG_fail;
34289 }
34290 {
34291 arg3 = wxString_in_helper(obj2);
34292 if (arg3 == NULL) SWIG_fail;
34293 temp3 = true;
34294 }
34295 {
34296 PyThreadState* __tstate = wxPyBeginAllowThreads();
34297 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
34298
34299 wxPyEndAllowThreads(__tstate);
34300 if (PyErr_Occurred()) SWIG_fail;
34301 }
34302 Py_INCREF(Py_None); resultobj = Py_None;
34303 {
34304 if (temp3)
34305 delete arg3;
34306 }
34307 return resultobj;
34308 fail:
34309 {
34310 if (temp3)
34311 delete arg3;
34312 }
34313 return NULL;
34314 }
34315
34316
34317 static PyObject *_wrap_Menu_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
34318 PyObject *resultobj;
34319 wxMenu *arg1 = (wxMenu *) 0 ;
34320 int arg2 ;
34321 wxString result;
34322 PyObject * obj0 = 0 ;
34323 PyObject * obj1 = 0 ;
34324 char *kwnames[] = {
34325 (char *) "self",(char *) "id", NULL
34326 };
34327
34328 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) goto fail;
34329 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34330 if (SWIG_arg_fail(1)) SWIG_fail;
34331 {
34332 arg2 = (int)(SWIG_As_int(obj1));
34333 if (SWIG_arg_fail(2)) SWIG_fail;
34334 }
34335 {
34336 PyThreadState* __tstate = wxPyBeginAllowThreads();
34337 result = ((wxMenu const *)arg1)->GetLabel(arg2);
34338
34339 wxPyEndAllowThreads(__tstate);
34340 if (PyErr_Occurred()) SWIG_fail;
34341 }
34342 {
34343 #if wxUSE_UNICODE
34344 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34345 #else
34346 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34347 #endif
34348 }
34349 return resultobj;
34350 fail:
34351 return NULL;
34352 }
34353
34354
34355 static PyObject *_wrap_Menu_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34356 PyObject *resultobj;
34357 wxMenu *arg1 = (wxMenu *) 0 ;
34358 int arg2 ;
34359 wxString *arg3 = 0 ;
34360 bool temp3 = false ;
34361 PyObject * obj0 = 0 ;
34362 PyObject * obj1 = 0 ;
34363 PyObject * obj2 = 0 ;
34364 char *kwnames[] = {
34365 (char *) "self",(char *) "id",(char *) "helpString", NULL
34366 };
34367
34368 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
34369 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34370 if (SWIG_arg_fail(1)) SWIG_fail;
34371 {
34372 arg2 = (int)(SWIG_As_int(obj1));
34373 if (SWIG_arg_fail(2)) SWIG_fail;
34374 }
34375 {
34376 arg3 = wxString_in_helper(obj2);
34377 if (arg3 == NULL) SWIG_fail;
34378 temp3 = true;
34379 }
34380 {
34381 PyThreadState* __tstate = wxPyBeginAllowThreads();
34382 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
34383
34384 wxPyEndAllowThreads(__tstate);
34385 if (PyErr_Occurred()) SWIG_fail;
34386 }
34387 Py_INCREF(Py_None); resultobj = Py_None;
34388 {
34389 if (temp3)
34390 delete arg3;
34391 }
34392 return resultobj;
34393 fail:
34394 {
34395 if (temp3)
34396 delete arg3;
34397 }
34398 return NULL;
34399 }
34400
34401
34402 static PyObject *_wrap_Menu_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
34403 PyObject *resultobj;
34404 wxMenu *arg1 = (wxMenu *) 0 ;
34405 int arg2 ;
34406 wxString result;
34407 PyObject * obj0 = 0 ;
34408 PyObject * obj1 = 0 ;
34409 char *kwnames[] = {
34410 (char *) "self",(char *) "id", NULL
34411 };
34412
34413 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
34414 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34415 if (SWIG_arg_fail(1)) SWIG_fail;
34416 {
34417 arg2 = (int)(SWIG_As_int(obj1));
34418 if (SWIG_arg_fail(2)) SWIG_fail;
34419 }
34420 {
34421 PyThreadState* __tstate = wxPyBeginAllowThreads();
34422 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
34423
34424 wxPyEndAllowThreads(__tstate);
34425 if (PyErr_Occurred()) SWIG_fail;
34426 }
34427 {
34428 #if wxUSE_UNICODE
34429 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34430 #else
34431 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34432 #endif
34433 }
34434 return resultobj;
34435 fail:
34436 return NULL;
34437 }
34438
34439
34440 static PyObject *_wrap_Menu_SetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34441 PyObject *resultobj;
34442 wxMenu *arg1 = (wxMenu *) 0 ;
34443 wxString *arg2 = 0 ;
34444 bool temp2 = false ;
34445 PyObject * obj0 = 0 ;
34446 PyObject * obj1 = 0 ;
34447 char *kwnames[] = {
34448 (char *) "self",(char *) "title", NULL
34449 };
34450
34451 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) goto fail;
34452 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34453 if (SWIG_arg_fail(1)) SWIG_fail;
34454 {
34455 arg2 = wxString_in_helper(obj1);
34456 if (arg2 == NULL) SWIG_fail;
34457 temp2 = true;
34458 }
34459 {
34460 PyThreadState* __tstate = wxPyBeginAllowThreads();
34461 (arg1)->SetTitle((wxString const &)*arg2);
34462
34463 wxPyEndAllowThreads(__tstate);
34464 if (PyErr_Occurred()) SWIG_fail;
34465 }
34466 Py_INCREF(Py_None); resultobj = Py_None;
34467 {
34468 if (temp2)
34469 delete arg2;
34470 }
34471 return resultobj;
34472 fail:
34473 {
34474 if (temp2)
34475 delete arg2;
34476 }
34477 return NULL;
34478 }
34479
34480
34481 static PyObject *_wrap_Menu_GetTitle(PyObject *, PyObject *args, PyObject *kwargs) {
34482 PyObject *resultobj;
34483 wxMenu *arg1 = (wxMenu *) 0 ;
34484 wxString result;
34485 PyObject * obj0 = 0 ;
34486 char *kwnames[] = {
34487 (char *) "self", NULL
34488 };
34489
34490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetTitle",kwnames,&obj0)) goto fail;
34491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34492 if (SWIG_arg_fail(1)) SWIG_fail;
34493 {
34494 PyThreadState* __tstate = wxPyBeginAllowThreads();
34495 result = ((wxMenu const *)arg1)->GetTitle();
34496
34497 wxPyEndAllowThreads(__tstate);
34498 if (PyErr_Occurred()) SWIG_fail;
34499 }
34500 {
34501 #if wxUSE_UNICODE
34502 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
34503 #else
34504 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
34505 #endif
34506 }
34507 return resultobj;
34508 fail:
34509 return NULL;
34510 }
34511
34512
34513 static PyObject *_wrap_Menu_SetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34514 PyObject *resultobj;
34515 wxMenu *arg1 = (wxMenu *) 0 ;
34516 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
34517 PyObject * obj0 = 0 ;
34518 PyObject * obj1 = 0 ;
34519 char *kwnames[] = {
34520 (char *) "self",(char *) "handler", NULL
34521 };
34522
34523 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) goto fail;
34524 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34525 if (SWIG_arg_fail(1)) SWIG_fail;
34526 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34527 if (SWIG_arg_fail(2)) SWIG_fail;
34528 {
34529 PyThreadState* __tstate = wxPyBeginAllowThreads();
34530 (arg1)->SetEventHandler(arg2);
34531
34532 wxPyEndAllowThreads(__tstate);
34533 if (PyErr_Occurred()) SWIG_fail;
34534 }
34535 Py_INCREF(Py_None); resultobj = Py_None;
34536 return resultobj;
34537 fail:
34538 return NULL;
34539 }
34540
34541
34542 static PyObject *_wrap_Menu_GetEventHandler(PyObject *, PyObject *args, PyObject *kwargs) {
34543 PyObject *resultobj;
34544 wxMenu *arg1 = (wxMenu *) 0 ;
34545 wxEvtHandler *result;
34546 PyObject * obj0 = 0 ;
34547 char *kwnames[] = {
34548 (char *) "self", NULL
34549 };
34550
34551 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetEventHandler",kwnames,&obj0)) goto fail;
34552 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34553 if (SWIG_arg_fail(1)) SWIG_fail;
34554 {
34555 PyThreadState* __tstate = wxPyBeginAllowThreads();
34556 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
34557
34558 wxPyEndAllowThreads(__tstate);
34559 if (PyErr_Occurred()) SWIG_fail;
34560 }
34561 {
34562 resultobj = wxPyMake_wxObject(result, 0);
34563 }
34564 return resultobj;
34565 fail:
34566 return NULL;
34567 }
34568
34569
34570 static PyObject *_wrap_Menu_SetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34571 PyObject *resultobj;
34572 wxMenu *arg1 = (wxMenu *) 0 ;
34573 wxWindow *arg2 = (wxWindow *) 0 ;
34574 PyObject * obj0 = 0 ;
34575 PyObject * obj1 = 0 ;
34576 char *kwnames[] = {
34577 (char *) "self",(char *) "win", NULL
34578 };
34579
34580 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) goto fail;
34581 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34582 if (SWIG_arg_fail(1)) SWIG_fail;
34583 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
34584 if (SWIG_arg_fail(2)) SWIG_fail;
34585 {
34586 PyThreadState* __tstate = wxPyBeginAllowThreads();
34587 (arg1)->SetInvokingWindow(arg2);
34588
34589 wxPyEndAllowThreads(__tstate);
34590 if (PyErr_Occurred()) SWIG_fail;
34591 }
34592 Py_INCREF(Py_None); resultobj = Py_None;
34593 return resultobj;
34594 fail:
34595 return NULL;
34596 }
34597
34598
34599 static PyObject *_wrap_Menu_GetInvokingWindow(PyObject *, PyObject *args, PyObject *kwargs) {
34600 PyObject *resultobj;
34601 wxMenu *arg1 = (wxMenu *) 0 ;
34602 wxWindow *result;
34603 PyObject * obj0 = 0 ;
34604 char *kwnames[] = {
34605 (char *) "self", NULL
34606 };
34607
34608 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetInvokingWindow",kwnames,&obj0)) goto fail;
34609 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34610 if (SWIG_arg_fail(1)) SWIG_fail;
34611 {
34612 PyThreadState* __tstate = wxPyBeginAllowThreads();
34613 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
34614
34615 wxPyEndAllowThreads(__tstate);
34616 if (PyErr_Occurred()) SWIG_fail;
34617 }
34618 {
34619 resultobj = wxPyMake_wxObject(result, 0);
34620 }
34621 return resultobj;
34622 fail:
34623 return NULL;
34624 }
34625
34626
34627 static PyObject *_wrap_Menu_GetStyle(PyObject *, PyObject *args, PyObject *kwargs) {
34628 PyObject *resultobj;
34629 wxMenu *arg1 = (wxMenu *) 0 ;
34630 long result;
34631 PyObject * obj0 = 0 ;
34632 char *kwnames[] = {
34633 (char *) "self", NULL
34634 };
34635
34636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetStyle",kwnames,&obj0)) goto fail;
34637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34638 if (SWIG_arg_fail(1)) SWIG_fail;
34639 {
34640 PyThreadState* __tstate = wxPyBeginAllowThreads();
34641 result = (long)((wxMenu const *)arg1)->GetStyle();
34642
34643 wxPyEndAllowThreads(__tstate);
34644 if (PyErr_Occurred()) SWIG_fail;
34645 }
34646 {
34647 resultobj = SWIG_From_long((long)(result));
34648 }
34649 return resultobj;
34650 fail:
34651 return NULL;
34652 }
34653
34654
34655 static PyObject *_wrap_Menu_UpdateUI(PyObject *, PyObject *args, PyObject *kwargs) {
34656 PyObject *resultobj;
34657 wxMenu *arg1 = (wxMenu *) 0 ;
34658 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
34659 PyObject * obj0 = 0 ;
34660 PyObject * obj1 = 0 ;
34661 char *kwnames[] = {
34662 (char *) "self",(char *) "source", NULL
34663 };
34664
34665 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) goto fail;
34666 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34667 if (SWIG_arg_fail(1)) SWIG_fail;
34668 if (obj1) {
34669 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_EXCEPTION | 0);
34670 if (SWIG_arg_fail(2)) SWIG_fail;
34671 }
34672 {
34673 PyThreadState* __tstate = wxPyBeginAllowThreads();
34674 (arg1)->UpdateUI(arg2);
34675
34676 wxPyEndAllowThreads(__tstate);
34677 if (PyErr_Occurred()) SWIG_fail;
34678 }
34679 Py_INCREF(Py_None); resultobj = Py_None;
34680 return resultobj;
34681 fail:
34682 return NULL;
34683 }
34684
34685
34686 static PyObject *_wrap_Menu_GetMenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34687 PyObject *resultobj;
34688 wxMenu *arg1 = (wxMenu *) 0 ;
34689 wxMenuBar *result;
34690 PyObject * obj0 = 0 ;
34691 char *kwnames[] = {
34692 (char *) "self", NULL
34693 };
34694
34695 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetMenuBar",kwnames,&obj0)) goto fail;
34696 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34697 if (SWIG_arg_fail(1)) SWIG_fail;
34698 {
34699 PyThreadState* __tstate = wxPyBeginAllowThreads();
34700 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
34701
34702 wxPyEndAllowThreads(__tstate);
34703 if (PyErr_Occurred()) SWIG_fail;
34704 }
34705 {
34706 resultobj = wxPyMake_wxObject(result, 0);
34707 }
34708 return resultobj;
34709 fail:
34710 return NULL;
34711 }
34712
34713
34714 static PyObject *_wrap_Menu_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
34715 PyObject *resultobj;
34716 wxMenu *arg1 = (wxMenu *) 0 ;
34717 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
34718 PyObject * obj0 = 0 ;
34719 PyObject * obj1 = 0 ;
34720 char *kwnames[] = {
34721 (char *) "self",(char *) "menubar", NULL
34722 };
34723
34724 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) goto fail;
34725 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34726 if (SWIG_arg_fail(1)) SWIG_fail;
34727 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenuBarBase, SWIG_POINTER_EXCEPTION | 0);
34728 if (SWIG_arg_fail(2)) SWIG_fail;
34729 {
34730 PyThreadState* __tstate = wxPyBeginAllowThreads();
34731 (arg1)->Attach(arg2);
34732
34733 wxPyEndAllowThreads(__tstate);
34734 if (PyErr_Occurred()) SWIG_fail;
34735 }
34736 Py_INCREF(Py_None); resultobj = Py_None;
34737 return resultobj;
34738 fail:
34739 return NULL;
34740 }
34741
34742
34743 static PyObject *_wrap_Menu_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
34744 PyObject *resultobj;
34745 wxMenu *arg1 = (wxMenu *) 0 ;
34746 PyObject * obj0 = 0 ;
34747 char *kwnames[] = {
34748 (char *) "self", NULL
34749 };
34750
34751 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_Detach",kwnames,&obj0)) goto fail;
34752 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34753 if (SWIG_arg_fail(1)) SWIG_fail;
34754 {
34755 PyThreadState* __tstate = wxPyBeginAllowThreads();
34756 (arg1)->Detach();
34757
34758 wxPyEndAllowThreads(__tstate);
34759 if (PyErr_Occurred()) SWIG_fail;
34760 }
34761 Py_INCREF(Py_None); resultobj = Py_None;
34762 return resultobj;
34763 fail:
34764 return NULL;
34765 }
34766
34767
34768 static PyObject *_wrap_Menu_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
34769 PyObject *resultobj;
34770 wxMenu *arg1 = (wxMenu *) 0 ;
34771 bool result;
34772 PyObject * obj0 = 0 ;
34773 char *kwnames[] = {
34774 (char *) "self", NULL
34775 };
34776
34777 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_IsAttached",kwnames,&obj0)) goto fail;
34778 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34779 if (SWIG_arg_fail(1)) SWIG_fail;
34780 {
34781 PyThreadState* __tstate = wxPyBeginAllowThreads();
34782 result = (bool)((wxMenu const *)arg1)->IsAttached();
34783
34784 wxPyEndAllowThreads(__tstate);
34785 if (PyErr_Occurred()) SWIG_fail;
34786 }
34787 {
34788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34789 }
34790 return resultobj;
34791 fail:
34792 return NULL;
34793 }
34794
34795
34796 static PyObject *_wrap_Menu_SetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34797 PyObject *resultobj;
34798 wxMenu *arg1 = (wxMenu *) 0 ;
34799 wxMenu *arg2 = (wxMenu *) 0 ;
34800 PyObject * obj0 = 0 ;
34801 PyObject * obj1 = 0 ;
34802 char *kwnames[] = {
34803 (char *) "self",(char *) "parent", NULL
34804 };
34805
34806 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) goto fail;
34807 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34808 if (SWIG_arg_fail(1)) SWIG_fail;
34809 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34810 if (SWIG_arg_fail(2)) SWIG_fail;
34811 {
34812 PyThreadState* __tstate = wxPyBeginAllowThreads();
34813 (arg1)->SetParent(arg2);
34814
34815 wxPyEndAllowThreads(__tstate);
34816 if (PyErr_Occurred()) SWIG_fail;
34817 }
34818 Py_INCREF(Py_None); resultobj = Py_None;
34819 return resultobj;
34820 fail:
34821 return NULL;
34822 }
34823
34824
34825 static PyObject *_wrap_Menu_GetParent(PyObject *, PyObject *args, PyObject *kwargs) {
34826 PyObject *resultobj;
34827 wxMenu *arg1 = (wxMenu *) 0 ;
34828 wxMenu *result;
34829 PyObject * obj0 = 0 ;
34830 char *kwnames[] = {
34831 (char *) "self", NULL
34832 };
34833
34834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Menu_GetParent",kwnames,&obj0)) goto fail;
34835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34836 if (SWIG_arg_fail(1)) SWIG_fail;
34837 {
34838 PyThreadState* __tstate = wxPyBeginAllowThreads();
34839 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
34840
34841 wxPyEndAllowThreads(__tstate);
34842 if (PyErr_Occurred()) SWIG_fail;
34843 }
34844 {
34845 resultobj = wxPyMake_wxObject(result, 0);
34846 }
34847 return resultobj;
34848 fail:
34849 return NULL;
34850 }
34851
34852
34853 static PyObject * Menu_swigregister(PyObject *, PyObject *args) {
34854 PyObject *obj;
34855 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
34856 SWIG_TypeClientData(SWIGTYPE_p_wxMenu, obj);
34857 Py_INCREF(obj);
34858 return Py_BuildValue((char *)"");
34859 }
34860 static PyObject *_wrap_new_MenuBar(PyObject *, PyObject *args, PyObject *kwargs) {
34861 PyObject *resultobj;
34862 long arg1 = (long) 0 ;
34863 wxMenuBar *result;
34864 PyObject * obj0 = 0 ;
34865 char *kwnames[] = {
34866 (char *) "style", NULL
34867 };
34868
34869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) goto fail;
34870 if (obj0) {
34871 {
34872 arg1 = (long)(SWIG_As_long(obj0));
34873 if (SWIG_arg_fail(1)) SWIG_fail;
34874 }
34875 }
34876 {
34877 if (!wxPyCheckForApp()) SWIG_fail;
34878 PyThreadState* __tstate = wxPyBeginAllowThreads();
34879 result = (wxMenuBar *)new wxMenuBar(arg1);
34880
34881 wxPyEndAllowThreads(__tstate);
34882 if (PyErr_Occurred()) SWIG_fail;
34883 }
34884 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxMenuBar, 1);
34885 return resultobj;
34886 fail:
34887 return NULL;
34888 }
34889
34890
34891 static PyObject *_wrap_MenuBar_Append(PyObject *, PyObject *args, PyObject *kwargs) {
34892 PyObject *resultobj;
34893 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34894 wxMenu *arg2 = (wxMenu *) 0 ;
34895 wxString *arg3 = 0 ;
34896 bool result;
34897 bool temp3 = false ;
34898 PyObject * obj0 = 0 ;
34899 PyObject * obj1 = 0 ;
34900 PyObject * obj2 = 0 ;
34901 char *kwnames[] = {
34902 (char *) "self",(char *) "menu",(char *) "title", NULL
34903 };
34904
34905 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
34906 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34907 if (SWIG_arg_fail(1)) SWIG_fail;
34908 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34909 if (SWIG_arg_fail(2)) SWIG_fail;
34910 {
34911 arg3 = wxString_in_helper(obj2);
34912 if (arg3 == NULL) SWIG_fail;
34913 temp3 = true;
34914 }
34915 {
34916 PyThreadState* __tstate = wxPyBeginAllowThreads();
34917 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
34918
34919 wxPyEndAllowThreads(__tstate);
34920 if (PyErr_Occurred()) SWIG_fail;
34921 }
34922 {
34923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34924 }
34925 {
34926 if (temp3)
34927 delete arg3;
34928 }
34929 return resultobj;
34930 fail:
34931 {
34932 if (temp3)
34933 delete arg3;
34934 }
34935 return NULL;
34936 }
34937
34938
34939 static PyObject *_wrap_MenuBar_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
34940 PyObject *resultobj;
34941 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34942 size_t arg2 ;
34943 wxMenu *arg3 = (wxMenu *) 0 ;
34944 wxString *arg4 = 0 ;
34945 bool result;
34946 bool temp4 = false ;
34947 PyObject * obj0 = 0 ;
34948 PyObject * obj1 = 0 ;
34949 PyObject * obj2 = 0 ;
34950 PyObject * obj3 = 0 ;
34951 char *kwnames[] = {
34952 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
34953 };
34954
34955 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
34956 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
34957 if (SWIG_arg_fail(1)) SWIG_fail;
34958 {
34959 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
34960 if (SWIG_arg_fail(2)) SWIG_fail;
34961 }
34962 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
34963 if (SWIG_arg_fail(3)) SWIG_fail;
34964 {
34965 arg4 = wxString_in_helper(obj3);
34966 if (arg4 == NULL) SWIG_fail;
34967 temp4 = true;
34968 }
34969 {
34970 PyThreadState* __tstate = wxPyBeginAllowThreads();
34971 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
34972
34973 wxPyEndAllowThreads(__tstate);
34974 if (PyErr_Occurred()) SWIG_fail;
34975 }
34976 {
34977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34978 }
34979 {
34980 if (temp4)
34981 delete arg4;
34982 }
34983 return resultobj;
34984 fail:
34985 {
34986 if (temp4)
34987 delete arg4;
34988 }
34989 return NULL;
34990 }
34991
34992
34993 static PyObject *_wrap_MenuBar_GetMenuCount(PyObject *, PyObject *args, PyObject *kwargs) {
34994 PyObject *resultobj;
34995 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
34996 size_t result;
34997 PyObject * obj0 = 0 ;
34998 char *kwnames[] = {
34999 (char *) "self", NULL
35000 };
35001
35002 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetMenuCount",kwnames,&obj0)) goto fail;
35003 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35004 if (SWIG_arg_fail(1)) SWIG_fail;
35005 {
35006 PyThreadState* __tstate = wxPyBeginAllowThreads();
35007 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
35008
35009 wxPyEndAllowThreads(__tstate);
35010 if (PyErr_Occurred()) SWIG_fail;
35011 }
35012 {
35013 resultobj = SWIG_From_unsigned_SS_long((unsigned long)(result));
35014 }
35015 return resultobj;
35016 fail:
35017 return NULL;
35018 }
35019
35020
35021 static PyObject *_wrap_MenuBar_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35022 PyObject *resultobj;
35023 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35024 size_t arg2 ;
35025 wxMenu *result;
35026 PyObject * obj0 = 0 ;
35027 PyObject * obj1 = 0 ;
35028 char *kwnames[] = {
35029 (char *) "self",(char *) "pos", NULL
35030 };
35031
35032 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) goto fail;
35033 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35034 if (SWIG_arg_fail(1)) SWIG_fail;
35035 {
35036 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35037 if (SWIG_arg_fail(2)) SWIG_fail;
35038 }
35039 {
35040 PyThreadState* __tstate = wxPyBeginAllowThreads();
35041 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
35042
35043 wxPyEndAllowThreads(__tstate);
35044 if (PyErr_Occurred()) SWIG_fail;
35045 }
35046 {
35047 resultobj = wxPyMake_wxObject(result, 0);
35048 }
35049 return resultobj;
35050 fail:
35051 return NULL;
35052 }
35053
35054
35055 static PyObject *_wrap_MenuBar_Replace(PyObject *, PyObject *args, PyObject *kwargs) {
35056 PyObject *resultobj;
35057 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35058 size_t arg2 ;
35059 wxMenu *arg3 = (wxMenu *) 0 ;
35060 wxString *arg4 = 0 ;
35061 wxMenu *result;
35062 bool temp4 = false ;
35063 PyObject * obj0 = 0 ;
35064 PyObject * obj1 = 0 ;
35065 PyObject * obj2 = 0 ;
35066 PyObject * obj3 = 0 ;
35067 char *kwnames[] = {
35068 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
35069 };
35070
35071 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
35072 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35073 if (SWIG_arg_fail(1)) SWIG_fail;
35074 {
35075 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35076 if (SWIG_arg_fail(2)) SWIG_fail;
35077 }
35078 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35079 if (SWIG_arg_fail(3)) SWIG_fail;
35080 {
35081 arg4 = wxString_in_helper(obj3);
35082 if (arg4 == NULL) SWIG_fail;
35083 temp4 = true;
35084 }
35085 {
35086 PyThreadState* __tstate = wxPyBeginAllowThreads();
35087 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
35088
35089 wxPyEndAllowThreads(__tstate);
35090 if (PyErr_Occurred()) SWIG_fail;
35091 }
35092 {
35093 resultobj = wxPyMake_wxObject(result, 0);
35094 }
35095 {
35096 if (temp4)
35097 delete arg4;
35098 }
35099 return resultobj;
35100 fail:
35101 {
35102 if (temp4)
35103 delete arg4;
35104 }
35105 return NULL;
35106 }
35107
35108
35109 static PyObject *_wrap_MenuBar_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
35110 PyObject *resultobj;
35111 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35112 size_t arg2 ;
35113 wxMenu *result;
35114 PyObject * obj0 = 0 ;
35115 PyObject * obj1 = 0 ;
35116 char *kwnames[] = {
35117 (char *) "self",(char *) "pos", NULL
35118 };
35119
35120 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) goto fail;
35121 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35122 if (SWIG_arg_fail(1)) SWIG_fail;
35123 {
35124 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35125 if (SWIG_arg_fail(2)) SWIG_fail;
35126 }
35127 {
35128 PyThreadState* __tstate = wxPyBeginAllowThreads();
35129 result = (wxMenu *)(arg1)->Remove(arg2);
35130
35131 wxPyEndAllowThreads(__tstate);
35132 if (PyErr_Occurred()) SWIG_fail;
35133 }
35134 {
35135 resultobj = wxPyMake_wxObject(result, 0);
35136 }
35137 return resultobj;
35138 fail:
35139 return NULL;
35140 }
35141
35142
35143 static PyObject *_wrap_MenuBar_EnableTop(PyObject *, PyObject *args, PyObject *kwargs) {
35144 PyObject *resultobj;
35145 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35146 size_t arg2 ;
35147 bool arg3 ;
35148 PyObject * obj0 = 0 ;
35149 PyObject * obj1 = 0 ;
35150 PyObject * obj2 = 0 ;
35151 char *kwnames[] = {
35152 (char *) "self",(char *) "pos",(char *) "enable", NULL
35153 };
35154
35155 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35156 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35157 if (SWIG_arg_fail(1)) SWIG_fail;
35158 {
35159 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35160 if (SWIG_arg_fail(2)) SWIG_fail;
35161 }
35162 {
35163 arg3 = (bool)(SWIG_As_bool(obj2));
35164 if (SWIG_arg_fail(3)) SWIG_fail;
35165 }
35166 {
35167 PyThreadState* __tstate = wxPyBeginAllowThreads();
35168 (arg1)->EnableTop(arg2,arg3);
35169
35170 wxPyEndAllowThreads(__tstate);
35171 if (PyErr_Occurred()) SWIG_fail;
35172 }
35173 Py_INCREF(Py_None); resultobj = Py_None;
35174 return resultobj;
35175 fail:
35176 return NULL;
35177 }
35178
35179
35180 static PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *, PyObject *args, PyObject *kwargs) {
35181 PyObject *resultobj;
35182 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35183 size_t arg2 ;
35184 bool result;
35185 PyObject * obj0 = 0 ;
35186 PyObject * obj1 = 0 ;
35187 char *kwnames[] = {
35188 (char *) "self",(char *) "pos", NULL
35189 };
35190
35191 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) goto fail;
35192 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35193 if (SWIG_arg_fail(1)) SWIG_fail;
35194 {
35195 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35196 if (SWIG_arg_fail(2)) SWIG_fail;
35197 }
35198 {
35199 PyThreadState* __tstate = wxPyBeginAllowThreads();
35200 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
35201
35202 wxPyEndAllowThreads(__tstate);
35203 if (PyErr_Occurred()) SWIG_fail;
35204 }
35205 {
35206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35207 }
35208 return resultobj;
35209 fail:
35210 return NULL;
35211 }
35212
35213
35214 static PyObject *_wrap_MenuBar_SetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35215 PyObject *resultobj;
35216 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35217 size_t arg2 ;
35218 wxString *arg3 = 0 ;
35219 bool temp3 = false ;
35220 PyObject * obj0 = 0 ;
35221 PyObject * obj1 = 0 ;
35222 PyObject * obj2 = 0 ;
35223 char *kwnames[] = {
35224 (char *) "self",(char *) "pos",(char *) "label", NULL
35225 };
35226
35227 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) goto fail;
35228 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35229 if (SWIG_arg_fail(1)) SWIG_fail;
35230 {
35231 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35232 if (SWIG_arg_fail(2)) SWIG_fail;
35233 }
35234 {
35235 arg3 = wxString_in_helper(obj2);
35236 if (arg3 == NULL) SWIG_fail;
35237 temp3 = true;
35238 }
35239 {
35240 PyThreadState* __tstate = wxPyBeginAllowThreads();
35241 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
35242
35243 wxPyEndAllowThreads(__tstate);
35244 if (PyErr_Occurred()) SWIG_fail;
35245 }
35246 Py_INCREF(Py_None); resultobj = Py_None;
35247 {
35248 if (temp3)
35249 delete arg3;
35250 }
35251 return resultobj;
35252 fail:
35253 {
35254 if (temp3)
35255 delete arg3;
35256 }
35257 return NULL;
35258 }
35259
35260
35261 static PyObject *_wrap_MenuBar_GetLabelTop(PyObject *, PyObject *args, PyObject *kwargs) {
35262 PyObject *resultobj;
35263 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35264 size_t arg2 ;
35265 wxString result;
35266 PyObject * obj0 = 0 ;
35267 PyObject * obj1 = 0 ;
35268 char *kwnames[] = {
35269 (char *) "self",(char *) "pos", NULL
35270 };
35271
35272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) goto fail;
35273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35274 if (SWIG_arg_fail(1)) SWIG_fail;
35275 {
35276 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
35277 if (SWIG_arg_fail(2)) SWIG_fail;
35278 }
35279 {
35280 PyThreadState* __tstate = wxPyBeginAllowThreads();
35281 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
35282
35283 wxPyEndAllowThreads(__tstate);
35284 if (PyErr_Occurred()) SWIG_fail;
35285 }
35286 {
35287 #if wxUSE_UNICODE
35288 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35289 #else
35290 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35291 #endif
35292 }
35293 return resultobj;
35294 fail:
35295 return NULL;
35296 }
35297
35298
35299 static PyObject *_wrap_MenuBar_FindMenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35300 PyObject *resultobj;
35301 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35302 wxString *arg2 = 0 ;
35303 wxString *arg3 = 0 ;
35304 int result;
35305 bool temp2 = false ;
35306 bool temp3 = false ;
35307 PyObject * obj0 = 0 ;
35308 PyObject * obj1 = 0 ;
35309 PyObject * obj2 = 0 ;
35310 char *kwnames[] = {
35311 (char *) "self",(char *) "menu",(char *) "item", NULL
35312 };
35313
35314 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
35315 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35316 if (SWIG_arg_fail(1)) SWIG_fail;
35317 {
35318 arg2 = wxString_in_helper(obj1);
35319 if (arg2 == NULL) SWIG_fail;
35320 temp2 = true;
35321 }
35322 {
35323 arg3 = wxString_in_helper(obj2);
35324 if (arg3 == NULL) SWIG_fail;
35325 temp3 = true;
35326 }
35327 {
35328 PyThreadState* __tstate = wxPyBeginAllowThreads();
35329 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
35330
35331 wxPyEndAllowThreads(__tstate);
35332 if (PyErr_Occurred()) SWIG_fail;
35333 }
35334 {
35335 resultobj = SWIG_From_int((int)(result));
35336 }
35337 {
35338 if (temp2)
35339 delete arg2;
35340 }
35341 {
35342 if (temp3)
35343 delete arg3;
35344 }
35345 return resultobj;
35346 fail:
35347 {
35348 if (temp2)
35349 delete arg2;
35350 }
35351 {
35352 if (temp3)
35353 delete arg3;
35354 }
35355 return NULL;
35356 }
35357
35358
35359 static PyObject *_wrap_MenuBar_FindItemById(PyObject *, PyObject *args, PyObject *kwargs) {
35360 PyObject *resultobj;
35361 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35362 int arg2 ;
35363 wxMenuItem *result;
35364 PyObject * obj0 = 0 ;
35365 PyObject * obj1 = 0 ;
35366 char *kwnames[] = {
35367 (char *) "self",(char *) "id", NULL
35368 };
35369
35370 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) goto fail;
35371 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35372 if (SWIG_arg_fail(1)) SWIG_fail;
35373 {
35374 arg2 = (int)(SWIG_As_int(obj1));
35375 if (SWIG_arg_fail(2)) SWIG_fail;
35376 }
35377 {
35378 PyThreadState* __tstate = wxPyBeginAllowThreads();
35379 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
35380
35381 wxPyEndAllowThreads(__tstate);
35382 if (PyErr_Occurred()) SWIG_fail;
35383 }
35384 {
35385 resultobj = wxPyMake_wxObject(result, 0);
35386 }
35387 return resultobj;
35388 fail:
35389 return NULL;
35390 }
35391
35392
35393 static PyObject *_wrap_MenuBar_FindMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35394 PyObject *resultobj;
35395 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35396 wxString *arg2 = 0 ;
35397 int result;
35398 bool temp2 = false ;
35399 PyObject * obj0 = 0 ;
35400 PyObject * obj1 = 0 ;
35401 char *kwnames[] = {
35402 (char *) "self",(char *) "title", NULL
35403 };
35404
35405 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) goto fail;
35406 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35407 if (SWIG_arg_fail(1)) SWIG_fail;
35408 {
35409 arg2 = wxString_in_helper(obj1);
35410 if (arg2 == NULL) SWIG_fail;
35411 temp2 = true;
35412 }
35413 {
35414 PyThreadState* __tstate = wxPyBeginAllowThreads();
35415 result = (int)((wxMenuBar const *)arg1)->FindMenu((wxString const &)*arg2);
35416
35417 wxPyEndAllowThreads(__tstate);
35418 if (PyErr_Occurred()) SWIG_fail;
35419 }
35420 {
35421 resultobj = SWIG_From_int((int)(result));
35422 }
35423 {
35424 if (temp2)
35425 delete arg2;
35426 }
35427 return resultobj;
35428 fail:
35429 {
35430 if (temp2)
35431 delete arg2;
35432 }
35433 return NULL;
35434 }
35435
35436
35437 static PyObject *_wrap_MenuBar_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
35438 PyObject *resultobj;
35439 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35440 int arg2 ;
35441 bool arg3 ;
35442 PyObject * obj0 = 0 ;
35443 PyObject * obj1 = 0 ;
35444 PyObject * obj2 = 0 ;
35445 char *kwnames[] = {
35446 (char *) "self",(char *) "id",(char *) "enable", NULL
35447 };
35448
35449 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) goto fail;
35450 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35451 if (SWIG_arg_fail(1)) SWIG_fail;
35452 {
35453 arg2 = (int)(SWIG_As_int(obj1));
35454 if (SWIG_arg_fail(2)) SWIG_fail;
35455 }
35456 {
35457 arg3 = (bool)(SWIG_As_bool(obj2));
35458 if (SWIG_arg_fail(3)) SWIG_fail;
35459 }
35460 {
35461 PyThreadState* __tstate = wxPyBeginAllowThreads();
35462 (arg1)->Enable(arg2,arg3);
35463
35464 wxPyEndAllowThreads(__tstate);
35465 if (PyErr_Occurred()) SWIG_fail;
35466 }
35467 Py_INCREF(Py_None); resultobj = Py_None;
35468 return resultobj;
35469 fail:
35470 return NULL;
35471 }
35472
35473
35474 static PyObject *_wrap_MenuBar_Check(PyObject *, PyObject *args, PyObject *kwargs) {
35475 PyObject *resultobj;
35476 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35477 int arg2 ;
35478 bool arg3 ;
35479 PyObject * obj0 = 0 ;
35480 PyObject * obj1 = 0 ;
35481 PyObject * obj2 = 0 ;
35482 char *kwnames[] = {
35483 (char *) "self",(char *) "id",(char *) "check", NULL
35484 };
35485
35486 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) goto fail;
35487 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35488 if (SWIG_arg_fail(1)) SWIG_fail;
35489 {
35490 arg2 = (int)(SWIG_As_int(obj1));
35491 if (SWIG_arg_fail(2)) SWIG_fail;
35492 }
35493 {
35494 arg3 = (bool)(SWIG_As_bool(obj2));
35495 if (SWIG_arg_fail(3)) SWIG_fail;
35496 }
35497 {
35498 PyThreadState* __tstate = wxPyBeginAllowThreads();
35499 (arg1)->Check(arg2,arg3);
35500
35501 wxPyEndAllowThreads(__tstate);
35502 if (PyErr_Occurred()) SWIG_fail;
35503 }
35504 Py_INCREF(Py_None); resultobj = Py_None;
35505 return resultobj;
35506 fail:
35507 return NULL;
35508 }
35509
35510
35511 static PyObject *_wrap_MenuBar_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
35512 PyObject *resultobj;
35513 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35514 int arg2 ;
35515 bool result;
35516 PyObject * obj0 = 0 ;
35517 PyObject * obj1 = 0 ;
35518 char *kwnames[] = {
35519 (char *) "self",(char *) "id", NULL
35520 };
35521
35522 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) goto fail;
35523 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35524 if (SWIG_arg_fail(1)) SWIG_fail;
35525 {
35526 arg2 = (int)(SWIG_As_int(obj1));
35527 if (SWIG_arg_fail(2)) SWIG_fail;
35528 }
35529 {
35530 PyThreadState* __tstate = wxPyBeginAllowThreads();
35531 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
35532
35533 wxPyEndAllowThreads(__tstate);
35534 if (PyErr_Occurred()) SWIG_fail;
35535 }
35536 {
35537 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35538 }
35539 return resultobj;
35540 fail:
35541 return NULL;
35542 }
35543
35544
35545 static PyObject *_wrap_MenuBar_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
35546 PyObject *resultobj;
35547 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35548 int arg2 ;
35549 bool result;
35550 PyObject * obj0 = 0 ;
35551 PyObject * obj1 = 0 ;
35552 char *kwnames[] = {
35553 (char *) "self",(char *) "id", NULL
35554 };
35555
35556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) goto fail;
35557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35558 if (SWIG_arg_fail(1)) SWIG_fail;
35559 {
35560 arg2 = (int)(SWIG_As_int(obj1));
35561 if (SWIG_arg_fail(2)) SWIG_fail;
35562 }
35563 {
35564 PyThreadState* __tstate = wxPyBeginAllowThreads();
35565 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
35566
35567 wxPyEndAllowThreads(__tstate);
35568 if (PyErr_Occurred()) SWIG_fail;
35569 }
35570 {
35571 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35572 }
35573 return resultobj;
35574 fail:
35575 return NULL;
35576 }
35577
35578
35579 static PyObject *_wrap_MenuBar_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35580 PyObject *resultobj;
35581 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35582 int arg2 ;
35583 wxString *arg3 = 0 ;
35584 bool temp3 = false ;
35585 PyObject * obj0 = 0 ;
35586 PyObject * obj1 = 0 ;
35587 PyObject * obj2 = 0 ;
35588 char *kwnames[] = {
35589 (char *) "self",(char *) "id",(char *) "label", NULL
35590 };
35591
35592 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) goto fail;
35593 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35594 if (SWIG_arg_fail(1)) SWIG_fail;
35595 {
35596 arg2 = (int)(SWIG_As_int(obj1));
35597 if (SWIG_arg_fail(2)) SWIG_fail;
35598 }
35599 {
35600 arg3 = wxString_in_helper(obj2);
35601 if (arg3 == NULL) SWIG_fail;
35602 temp3 = true;
35603 }
35604 {
35605 PyThreadState* __tstate = wxPyBeginAllowThreads();
35606 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
35607
35608 wxPyEndAllowThreads(__tstate);
35609 if (PyErr_Occurred()) SWIG_fail;
35610 }
35611 Py_INCREF(Py_None); resultobj = Py_None;
35612 {
35613 if (temp3)
35614 delete arg3;
35615 }
35616 return resultobj;
35617 fail:
35618 {
35619 if (temp3)
35620 delete arg3;
35621 }
35622 return NULL;
35623 }
35624
35625
35626 static PyObject *_wrap_MenuBar_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
35627 PyObject *resultobj;
35628 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35629 int arg2 ;
35630 wxString result;
35631 PyObject * obj0 = 0 ;
35632 PyObject * obj1 = 0 ;
35633 char *kwnames[] = {
35634 (char *) "self",(char *) "id", NULL
35635 };
35636
35637 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) goto fail;
35638 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35639 if (SWIG_arg_fail(1)) SWIG_fail;
35640 {
35641 arg2 = (int)(SWIG_As_int(obj1));
35642 if (SWIG_arg_fail(2)) SWIG_fail;
35643 }
35644 {
35645 PyThreadState* __tstate = wxPyBeginAllowThreads();
35646 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
35647
35648 wxPyEndAllowThreads(__tstate);
35649 if (PyErr_Occurred()) SWIG_fail;
35650 }
35651 {
35652 #if wxUSE_UNICODE
35653 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35654 #else
35655 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35656 #endif
35657 }
35658 return resultobj;
35659 fail:
35660 return NULL;
35661 }
35662
35663
35664 static PyObject *_wrap_MenuBar_SetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35665 PyObject *resultobj;
35666 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35667 int arg2 ;
35668 wxString *arg3 = 0 ;
35669 bool temp3 = false ;
35670 PyObject * obj0 = 0 ;
35671 PyObject * obj1 = 0 ;
35672 PyObject * obj2 = 0 ;
35673 char *kwnames[] = {
35674 (char *) "self",(char *) "id",(char *) "helpString", NULL
35675 };
35676
35677 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) goto fail;
35678 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35679 if (SWIG_arg_fail(1)) SWIG_fail;
35680 {
35681 arg2 = (int)(SWIG_As_int(obj1));
35682 if (SWIG_arg_fail(2)) SWIG_fail;
35683 }
35684 {
35685 arg3 = wxString_in_helper(obj2);
35686 if (arg3 == NULL) SWIG_fail;
35687 temp3 = true;
35688 }
35689 {
35690 PyThreadState* __tstate = wxPyBeginAllowThreads();
35691 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
35692
35693 wxPyEndAllowThreads(__tstate);
35694 if (PyErr_Occurred()) SWIG_fail;
35695 }
35696 Py_INCREF(Py_None); resultobj = Py_None;
35697 {
35698 if (temp3)
35699 delete arg3;
35700 }
35701 return resultobj;
35702 fail:
35703 {
35704 if (temp3)
35705 delete arg3;
35706 }
35707 return NULL;
35708 }
35709
35710
35711 static PyObject *_wrap_MenuBar_GetHelpString(PyObject *, PyObject *args, PyObject *kwargs) {
35712 PyObject *resultobj;
35713 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35714 int arg2 ;
35715 wxString result;
35716 PyObject * obj0 = 0 ;
35717 PyObject * obj1 = 0 ;
35718 char *kwnames[] = {
35719 (char *) "self",(char *) "id", NULL
35720 };
35721
35722 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) goto fail;
35723 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35724 if (SWIG_arg_fail(1)) SWIG_fail;
35725 {
35726 arg2 = (int)(SWIG_As_int(obj1));
35727 if (SWIG_arg_fail(2)) SWIG_fail;
35728 }
35729 {
35730 PyThreadState* __tstate = wxPyBeginAllowThreads();
35731 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
35732
35733 wxPyEndAllowThreads(__tstate);
35734 if (PyErr_Occurred()) SWIG_fail;
35735 }
35736 {
35737 #if wxUSE_UNICODE
35738 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
35739 #else
35740 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
35741 #endif
35742 }
35743 return resultobj;
35744 fail:
35745 return NULL;
35746 }
35747
35748
35749 static PyObject *_wrap_MenuBar_GetFrame(PyObject *, PyObject *args, PyObject *kwargs) {
35750 PyObject *resultobj;
35751 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35752 wxFrame *result;
35753 PyObject * obj0 = 0 ;
35754 char *kwnames[] = {
35755 (char *) "self", NULL
35756 };
35757
35758 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_GetFrame",kwnames,&obj0)) goto fail;
35759 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35760 if (SWIG_arg_fail(1)) SWIG_fail;
35761 {
35762 PyThreadState* __tstate = wxPyBeginAllowThreads();
35763 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
35764
35765 wxPyEndAllowThreads(__tstate);
35766 if (PyErr_Occurred()) SWIG_fail;
35767 }
35768 {
35769 resultobj = wxPyMake_wxObject(result, 0);
35770 }
35771 return resultobj;
35772 fail:
35773 return NULL;
35774 }
35775
35776
35777 static PyObject *_wrap_MenuBar_IsAttached(PyObject *, PyObject *args, PyObject *kwargs) {
35778 PyObject *resultobj;
35779 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35780 bool result;
35781 PyObject * obj0 = 0 ;
35782 char *kwnames[] = {
35783 (char *) "self", NULL
35784 };
35785
35786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_IsAttached",kwnames,&obj0)) goto fail;
35787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35788 if (SWIG_arg_fail(1)) SWIG_fail;
35789 {
35790 PyThreadState* __tstate = wxPyBeginAllowThreads();
35791 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
35792
35793 wxPyEndAllowThreads(__tstate);
35794 if (PyErr_Occurred()) SWIG_fail;
35795 }
35796 {
35797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35798 }
35799 return resultobj;
35800 fail:
35801 return NULL;
35802 }
35803
35804
35805 static PyObject *_wrap_MenuBar_Attach(PyObject *, PyObject *args, PyObject *kwargs) {
35806 PyObject *resultobj;
35807 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35808 wxFrame *arg2 = (wxFrame *) 0 ;
35809 PyObject * obj0 = 0 ;
35810 PyObject * obj1 = 0 ;
35811 char *kwnames[] = {
35812 (char *) "self",(char *) "frame", NULL
35813 };
35814
35815 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) goto fail;
35816 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuBar, SWIG_POINTER_EXCEPTION | 0);
35817 if (SWIG_arg_fail(1)) SWIG_fail;
35818 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFrame, SWIG_POINTER_EXCEPTION | 0);
35819 if (SWIG_arg_fail(2)) SWIG_fail;
35820 {
35821 PyThreadState* __tstate = wxPyBeginAllowThreads();
35822 (arg1)->Attach(arg2);
35823
35824 wxPyEndAllowThreads(__tstate);
35825 if (PyErr_Occurred()) SWIG_fail;
35826 }
35827 Py_INCREF(Py_None); resultobj = Py_None;
35828 return resultobj;
35829 fail:
35830 return NULL;
35831 }
35832
35833
35834 static PyObject *_wrap_MenuBar_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
35835 PyObject *resultobj;
35836 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
35837 PyObject * obj0 = 0 ;
35838 char *kwnames[] = {
35839 (char *) "self", NULL
35840 };
35841
35842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_Detach",kwnames,&obj0)) 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 PyThreadState* __tstate = wxPyBeginAllowThreads();
35847 (arg1)->Detach();
35848
35849 wxPyEndAllowThreads(__tstate);
35850 if (PyErr_Occurred()) SWIG_fail;
35851 }
35852 Py_INCREF(Py_None); resultobj = Py_None;
35853 return resultobj;
35854 fail:
35855 return NULL;
35856 }
35857
35858
35859 static PyObject * MenuBar_swigregister(PyObject *, PyObject *args) {
35860 PyObject *obj;
35861 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
35862 SWIG_TypeClientData(SWIGTYPE_p_wxMenuBar, obj);
35863 Py_INCREF(obj);
35864 return Py_BuildValue((char *)"");
35865 }
35866 static PyObject *_wrap_new_MenuItem(PyObject *, PyObject *args, PyObject *kwargs) {
35867 PyObject *resultobj;
35868 wxMenu *arg1 = (wxMenu *) NULL ;
35869 int arg2 = (int) wxID_ANY ;
35870 wxString const &arg3_defvalue = wxPyEmptyString ;
35871 wxString *arg3 = (wxString *) &arg3_defvalue ;
35872 wxString const &arg4_defvalue = wxPyEmptyString ;
35873 wxString *arg4 = (wxString *) &arg4_defvalue ;
35874 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
35875 wxMenu *arg6 = (wxMenu *) NULL ;
35876 wxMenuItem *result;
35877 bool temp3 = false ;
35878 bool temp4 = false ;
35879 PyObject * obj0 = 0 ;
35880 PyObject * obj1 = 0 ;
35881 PyObject * obj2 = 0 ;
35882 PyObject * obj3 = 0 ;
35883 PyObject * obj4 = 0 ;
35884 PyObject * obj5 = 0 ;
35885 char *kwnames[] = {
35886 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
35887 };
35888
35889 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
35890 if (obj0) {
35891 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35892 if (SWIG_arg_fail(1)) SWIG_fail;
35893 }
35894 if (obj1) {
35895 {
35896 arg2 = (int)(SWIG_As_int(obj1));
35897 if (SWIG_arg_fail(2)) SWIG_fail;
35898 }
35899 }
35900 if (obj2) {
35901 {
35902 arg3 = wxString_in_helper(obj2);
35903 if (arg3 == NULL) SWIG_fail;
35904 temp3 = true;
35905 }
35906 }
35907 if (obj3) {
35908 {
35909 arg4 = wxString_in_helper(obj3);
35910 if (arg4 == NULL) SWIG_fail;
35911 temp4 = true;
35912 }
35913 }
35914 if (obj4) {
35915 {
35916 arg5 = (wxItemKind)(SWIG_As_int(obj4));
35917 if (SWIG_arg_fail(5)) SWIG_fail;
35918 }
35919 }
35920 if (obj5) {
35921 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35922 if (SWIG_arg_fail(6)) SWIG_fail;
35923 }
35924 {
35925 PyThreadState* __tstate = wxPyBeginAllowThreads();
35926 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,(wxItemKind )arg5,arg6);
35927
35928 wxPyEndAllowThreads(__tstate);
35929 if (PyErr_Occurred()) SWIG_fail;
35930 }
35931 {
35932 resultobj = wxPyMake_wxObject(result, 1);
35933 }
35934 {
35935 if (temp3)
35936 delete arg3;
35937 }
35938 {
35939 if (temp4)
35940 delete arg4;
35941 }
35942 return resultobj;
35943 fail:
35944 {
35945 if (temp3)
35946 delete arg3;
35947 }
35948 {
35949 if (temp4)
35950 delete arg4;
35951 }
35952 return NULL;
35953 }
35954
35955
35956 static PyObject *_wrap_MenuItem_GetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35957 PyObject *resultobj;
35958 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35959 wxMenu *result;
35960 PyObject * obj0 = 0 ;
35961 char *kwnames[] = {
35962 (char *) "self", NULL
35963 };
35964
35965 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMenu",kwnames,&obj0)) goto fail;
35966 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35967 if (SWIG_arg_fail(1)) SWIG_fail;
35968 {
35969 PyThreadState* __tstate = wxPyBeginAllowThreads();
35970 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
35971
35972 wxPyEndAllowThreads(__tstate);
35973 if (PyErr_Occurred()) SWIG_fail;
35974 }
35975 {
35976 resultobj = wxPyMake_wxObject(result, 0);
35977 }
35978 return resultobj;
35979 fail:
35980 return NULL;
35981 }
35982
35983
35984 static PyObject *_wrap_MenuItem_SetMenu(PyObject *, PyObject *args, PyObject *kwargs) {
35985 PyObject *resultobj;
35986 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
35987 wxMenu *arg2 = (wxMenu *) 0 ;
35988 PyObject * obj0 = 0 ;
35989 PyObject * obj1 = 0 ;
35990 char *kwnames[] = {
35991 (char *) "self",(char *) "menu", NULL
35992 };
35993
35994 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) goto fail;
35995 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
35996 if (SWIG_arg_fail(1)) SWIG_fail;
35997 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
35998 if (SWIG_arg_fail(2)) SWIG_fail;
35999 {
36000 PyThreadState* __tstate = wxPyBeginAllowThreads();
36001 (arg1)->SetMenu(arg2);
36002
36003 wxPyEndAllowThreads(__tstate);
36004 if (PyErr_Occurred()) SWIG_fail;
36005 }
36006 Py_INCREF(Py_None); resultobj = Py_None;
36007 return resultobj;
36008 fail:
36009 return NULL;
36010 }
36011
36012
36013 static PyObject *_wrap_MenuItem_SetId(PyObject *, PyObject *args, PyObject *kwargs) {
36014 PyObject *resultobj;
36015 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36016 int arg2 ;
36017 PyObject * obj0 = 0 ;
36018 PyObject * obj1 = 0 ;
36019 char *kwnames[] = {
36020 (char *) "self",(char *) "id", NULL
36021 };
36022
36023 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) goto fail;
36024 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36025 if (SWIG_arg_fail(1)) SWIG_fail;
36026 {
36027 arg2 = (int)(SWIG_As_int(obj1));
36028 if (SWIG_arg_fail(2)) SWIG_fail;
36029 }
36030 {
36031 PyThreadState* __tstate = wxPyBeginAllowThreads();
36032 (arg1)->SetId(arg2);
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_MenuItem_GetId(PyObject *, PyObject *args, PyObject *kwargs) {
36045 PyObject *resultobj;
36046 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36047 int result;
36048 PyObject * obj0 = 0 ;
36049 char *kwnames[] = {
36050 (char *) "self", NULL
36051 };
36052
36053 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetId",kwnames,&obj0)) goto fail;
36054 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36055 if (SWIG_arg_fail(1)) SWIG_fail;
36056 {
36057 PyThreadState* __tstate = wxPyBeginAllowThreads();
36058 result = (int)((wxMenuItem const *)arg1)->GetId();
36059
36060 wxPyEndAllowThreads(__tstate);
36061 if (PyErr_Occurred()) SWIG_fail;
36062 }
36063 {
36064 resultobj = SWIG_From_int((int)(result));
36065 }
36066 return resultobj;
36067 fail:
36068 return NULL;
36069 }
36070
36071
36072 static PyObject *_wrap_MenuItem_IsSeparator(PyObject *, PyObject *args, PyObject *kwargs) {
36073 PyObject *resultobj;
36074 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36075 bool result;
36076 PyObject * obj0 = 0 ;
36077 char *kwnames[] = {
36078 (char *) "self", NULL
36079 };
36080
36081 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSeparator",kwnames,&obj0)) goto fail;
36082 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36083 if (SWIG_arg_fail(1)) SWIG_fail;
36084 {
36085 PyThreadState* __tstate = wxPyBeginAllowThreads();
36086 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
36087
36088 wxPyEndAllowThreads(__tstate);
36089 if (PyErr_Occurred()) SWIG_fail;
36090 }
36091 {
36092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36093 }
36094 return resultobj;
36095 fail:
36096 return NULL;
36097 }
36098
36099
36100 static PyObject *_wrap_MenuItem_SetText(PyObject *, PyObject *args, PyObject *kwargs) {
36101 PyObject *resultobj;
36102 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36103 wxString *arg2 = 0 ;
36104 bool temp2 = false ;
36105 PyObject * obj0 = 0 ;
36106 PyObject * obj1 = 0 ;
36107 char *kwnames[] = {
36108 (char *) "self",(char *) "str", NULL
36109 };
36110
36111 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) goto fail;
36112 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36113 if (SWIG_arg_fail(1)) SWIG_fail;
36114 {
36115 arg2 = wxString_in_helper(obj1);
36116 if (arg2 == NULL) SWIG_fail;
36117 temp2 = true;
36118 }
36119 {
36120 PyThreadState* __tstate = wxPyBeginAllowThreads();
36121 (arg1)->SetText((wxString const &)*arg2);
36122
36123 wxPyEndAllowThreads(__tstate);
36124 if (PyErr_Occurred()) SWIG_fail;
36125 }
36126 Py_INCREF(Py_None); resultobj = Py_None;
36127 {
36128 if (temp2)
36129 delete arg2;
36130 }
36131 return resultobj;
36132 fail:
36133 {
36134 if (temp2)
36135 delete arg2;
36136 }
36137 return NULL;
36138 }
36139
36140
36141 static PyObject *_wrap_MenuItem_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
36142 PyObject *resultobj;
36143 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36144 wxString result;
36145 PyObject * obj0 = 0 ;
36146 char *kwnames[] = {
36147 (char *) "self", NULL
36148 };
36149
36150 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabel",kwnames,&obj0)) goto fail;
36151 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36152 if (SWIG_arg_fail(1)) SWIG_fail;
36153 {
36154 PyThreadState* __tstate = wxPyBeginAllowThreads();
36155 result = ((wxMenuItem const *)arg1)->GetLabel();
36156
36157 wxPyEndAllowThreads(__tstate);
36158 if (PyErr_Occurred()) SWIG_fail;
36159 }
36160 {
36161 #if wxUSE_UNICODE
36162 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36163 #else
36164 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36165 #endif
36166 }
36167 return resultobj;
36168 fail:
36169 return NULL;
36170 }
36171
36172
36173 static PyObject *_wrap_MenuItem_GetText(PyObject *, PyObject *args, PyObject *kwargs) {
36174 PyObject *resultobj;
36175 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36176 wxString *result;
36177 PyObject * obj0 = 0 ;
36178 char *kwnames[] = {
36179 (char *) "self", NULL
36180 };
36181
36182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetText",kwnames,&obj0)) goto fail;
36183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36184 if (SWIG_arg_fail(1)) SWIG_fail;
36185 {
36186 PyThreadState* __tstate = wxPyBeginAllowThreads();
36187 {
36188 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
36189 result = (wxString *) &_result_ref;
36190 }
36191
36192 wxPyEndAllowThreads(__tstate);
36193 if (PyErr_Occurred()) SWIG_fail;
36194 }
36195 {
36196 #if wxUSE_UNICODE
36197 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36198 #else
36199 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36200 #endif
36201 }
36202 return resultobj;
36203 fail:
36204 return NULL;
36205 }
36206
36207
36208 static PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *, PyObject *args, PyObject *kwargs) {
36209 PyObject *resultobj;
36210 wxString *arg1 = 0 ;
36211 wxString result;
36212 bool temp1 = false ;
36213 PyObject * obj0 = 0 ;
36214 char *kwnames[] = {
36215 (char *) "text", NULL
36216 };
36217
36218 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) goto fail;
36219 {
36220 arg1 = wxString_in_helper(obj0);
36221 if (arg1 == NULL) SWIG_fail;
36222 temp1 = true;
36223 }
36224 {
36225 PyThreadState* __tstate = wxPyBeginAllowThreads();
36226 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
36227
36228 wxPyEndAllowThreads(__tstate);
36229 if (PyErr_Occurred()) SWIG_fail;
36230 }
36231 {
36232 #if wxUSE_UNICODE
36233 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36234 #else
36235 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36236 #endif
36237 }
36238 {
36239 if (temp1)
36240 delete arg1;
36241 }
36242 return resultobj;
36243 fail:
36244 {
36245 if (temp1)
36246 delete arg1;
36247 }
36248 return NULL;
36249 }
36250
36251
36252 static PyObject *_wrap_MenuItem_GetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36253 PyObject *resultobj;
36254 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36255 wxItemKind result;
36256 PyObject * obj0 = 0 ;
36257 char *kwnames[] = {
36258 (char *) "self", NULL
36259 };
36260
36261 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetKind",kwnames,&obj0)) goto fail;
36262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36263 if (SWIG_arg_fail(1)) SWIG_fail;
36264 {
36265 PyThreadState* __tstate = wxPyBeginAllowThreads();
36266 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
36267
36268 wxPyEndAllowThreads(__tstate);
36269 if (PyErr_Occurred()) SWIG_fail;
36270 }
36271 resultobj = SWIG_From_int((result));
36272 return resultobj;
36273 fail:
36274 return NULL;
36275 }
36276
36277
36278 static PyObject *_wrap_MenuItem_SetKind(PyObject *, PyObject *args, PyObject *kwargs) {
36279 PyObject *resultobj;
36280 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36281 wxItemKind arg2 ;
36282 PyObject * obj0 = 0 ;
36283 PyObject * obj1 = 0 ;
36284 char *kwnames[] = {
36285 (char *) "self",(char *) "kind", NULL
36286 };
36287
36288 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) goto fail;
36289 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36290 if (SWIG_arg_fail(1)) SWIG_fail;
36291 {
36292 arg2 = (wxItemKind)(SWIG_As_int(obj1));
36293 if (SWIG_arg_fail(2)) SWIG_fail;
36294 }
36295 {
36296 PyThreadState* __tstate = wxPyBeginAllowThreads();
36297 (arg1)->SetKind((wxItemKind )arg2);
36298
36299 wxPyEndAllowThreads(__tstate);
36300 if (PyErr_Occurred()) SWIG_fail;
36301 }
36302 Py_INCREF(Py_None); resultobj = Py_None;
36303 return resultobj;
36304 fail:
36305 return NULL;
36306 }
36307
36308
36309 static PyObject *_wrap_MenuItem_SetCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36310 PyObject *resultobj;
36311 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36312 bool arg2 ;
36313 PyObject * obj0 = 0 ;
36314 PyObject * obj1 = 0 ;
36315 char *kwnames[] = {
36316 (char *) "self",(char *) "checkable", NULL
36317 };
36318
36319 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) goto fail;
36320 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36321 if (SWIG_arg_fail(1)) SWIG_fail;
36322 {
36323 arg2 = (bool)(SWIG_As_bool(obj1));
36324 if (SWIG_arg_fail(2)) SWIG_fail;
36325 }
36326 {
36327 PyThreadState* __tstate = wxPyBeginAllowThreads();
36328 (arg1)->SetCheckable(arg2);
36329
36330 wxPyEndAllowThreads(__tstate);
36331 if (PyErr_Occurred()) SWIG_fail;
36332 }
36333 Py_INCREF(Py_None); resultobj = Py_None;
36334 return resultobj;
36335 fail:
36336 return NULL;
36337 }
36338
36339
36340 static PyObject *_wrap_MenuItem_IsCheckable(PyObject *, PyObject *args, PyObject *kwargs) {
36341 PyObject *resultobj;
36342 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36343 bool result;
36344 PyObject * obj0 = 0 ;
36345 char *kwnames[] = {
36346 (char *) "self", NULL
36347 };
36348
36349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsCheckable",kwnames,&obj0)) goto fail;
36350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36351 if (SWIG_arg_fail(1)) SWIG_fail;
36352 {
36353 PyThreadState* __tstate = wxPyBeginAllowThreads();
36354 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
36355
36356 wxPyEndAllowThreads(__tstate);
36357 if (PyErr_Occurred()) SWIG_fail;
36358 }
36359 {
36360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36361 }
36362 return resultobj;
36363 fail:
36364 return NULL;
36365 }
36366
36367
36368 static PyObject *_wrap_MenuItem_IsSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36369 PyObject *resultobj;
36370 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36371 bool result;
36372 PyObject * obj0 = 0 ;
36373 char *kwnames[] = {
36374 (char *) "self", NULL
36375 };
36376
36377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsSubMenu",kwnames,&obj0)) goto fail;
36378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36379 if (SWIG_arg_fail(1)) SWIG_fail;
36380 {
36381 PyThreadState* __tstate = wxPyBeginAllowThreads();
36382 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
36383
36384 wxPyEndAllowThreads(__tstate);
36385 if (PyErr_Occurred()) SWIG_fail;
36386 }
36387 {
36388 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36389 }
36390 return resultobj;
36391 fail:
36392 return NULL;
36393 }
36394
36395
36396 static PyObject *_wrap_MenuItem_SetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36397 PyObject *resultobj;
36398 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36399 wxMenu *arg2 = (wxMenu *) 0 ;
36400 PyObject * obj0 = 0 ;
36401 PyObject * obj1 = 0 ;
36402 char *kwnames[] = {
36403 (char *) "self",(char *) "menu", NULL
36404 };
36405
36406 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) goto fail;
36407 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36408 if (SWIG_arg_fail(1)) SWIG_fail;
36409 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxMenu, SWIG_POINTER_EXCEPTION | 0);
36410 if (SWIG_arg_fail(2)) SWIG_fail;
36411 {
36412 PyThreadState* __tstate = wxPyBeginAllowThreads();
36413 (arg1)->SetSubMenu(arg2);
36414
36415 wxPyEndAllowThreads(__tstate);
36416 if (PyErr_Occurred()) SWIG_fail;
36417 }
36418 Py_INCREF(Py_None); resultobj = Py_None;
36419 return resultobj;
36420 fail:
36421 return NULL;
36422 }
36423
36424
36425 static PyObject *_wrap_MenuItem_GetSubMenu(PyObject *, PyObject *args, PyObject *kwargs) {
36426 PyObject *resultobj;
36427 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36428 wxMenu *result;
36429 PyObject * obj0 = 0 ;
36430 char *kwnames[] = {
36431 (char *) "self", NULL
36432 };
36433
36434 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetSubMenu",kwnames,&obj0)) goto fail;
36435 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36436 if (SWIG_arg_fail(1)) SWIG_fail;
36437 {
36438 PyThreadState* __tstate = wxPyBeginAllowThreads();
36439 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
36440
36441 wxPyEndAllowThreads(__tstate);
36442 if (PyErr_Occurred()) SWIG_fail;
36443 }
36444 {
36445 resultobj = wxPyMake_wxObject(result, 0);
36446 }
36447 return resultobj;
36448 fail:
36449 return NULL;
36450 }
36451
36452
36453 static PyObject *_wrap_MenuItem_Enable(PyObject *, PyObject *args, PyObject *kwargs) {
36454 PyObject *resultobj;
36455 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36456 bool arg2 = (bool) true ;
36457 PyObject * obj0 = 0 ;
36458 PyObject * obj1 = 0 ;
36459 char *kwnames[] = {
36460 (char *) "self",(char *) "enable", NULL
36461 };
36462
36463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) goto fail;
36464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36465 if (SWIG_arg_fail(1)) SWIG_fail;
36466 if (obj1) {
36467 {
36468 arg2 = (bool)(SWIG_As_bool(obj1));
36469 if (SWIG_arg_fail(2)) SWIG_fail;
36470 }
36471 }
36472 {
36473 PyThreadState* __tstate = wxPyBeginAllowThreads();
36474 (arg1)->Enable(arg2);
36475
36476 wxPyEndAllowThreads(__tstate);
36477 if (PyErr_Occurred()) SWIG_fail;
36478 }
36479 Py_INCREF(Py_None); resultobj = Py_None;
36480 return resultobj;
36481 fail:
36482 return NULL;
36483 }
36484
36485
36486 static PyObject *_wrap_MenuItem_IsEnabled(PyObject *, PyObject *args, PyObject *kwargs) {
36487 PyObject *resultobj;
36488 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36489 bool result;
36490 PyObject * obj0 = 0 ;
36491 char *kwnames[] = {
36492 (char *) "self", NULL
36493 };
36494
36495 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsEnabled",kwnames,&obj0)) goto fail;
36496 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36497 if (SWIG_arg_fail(1)) SWIG_fail;
36498 {
36499 PyThreadState* __tstate = wxPyBeginAllowThreads();
36500 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
36501
36502 wxPyEndAllowThreads(__tstate);
36503 if (PyErr_Occurred()) SWIG_fail;
36504 }
36505 {
36506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36507 }
36508 return resultobj;
36509 fail:
36510 return NULL;
36511 }
36512
36513
36514 static PyObject *_wrap_MenuItem_Check(PyObject *, PyObject *args, PyObject *kwargs) {
36515 PyObject *resultobj;
36516 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36517 bool arg2 = (bool) true ;
36518 PyObject * obj0 = 0 ;
36519 PyObject * obj1 = 0 ;
36520 char *kwnames[] = {
36521 (char *) "self",(char *) "check", NULL
36522 };
36523
36524 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) goto fail;
36525 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36526 if (SWIG_arg_fail(1)) SWIG_fail;
36527 if (obj1) {
36528 {
36529 arg2 = (bool)(SWIG_As_bool(obj1));
36530 if (SWIG_arg_fail(2)) SWIG_fail;
36531 }
36532 }
36533 {
36534 PyThreadState* __tstate = wxPyBeginAllowThreads();
36535 (arg1)->Check(arg2);
36536
36537 wxPyEndAllowThreads(__tstate);
36538 if (PyErr_Occurred()) SWIG_fail;
36539 }
36540 Py_INCREF(Py_None); resultobj = Py_None;
36541 return resultobj;
36542 fail:
36543 return NULL;
36544 }
36545
36546
36547 static PyObject *_wrap_MenuItem_IsChecked(PyObject *, PyObject *args, PyObject *kwargs) {
36548 PyObject *resultobj;
36549 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36550 bool result;
36551 PyObject * obj0 = 0 ;
36552 char *kwnames[] = {
36553 (char *) "self", NULL
36554 };
36555
36556 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsChecked",kwnames,&obj0)) goto fail;
36557 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36558 if (SWIG_arg_fail(1)) SWIG_fail;
36559 {
36560 PyThreadState* __tstate = wxPyBeginAllowThreads();
36561 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
36562
36563 wxPyEndAllowThreads(__tstate);
36564 if (PyErr_Occurred()) SWIG_fail;
36565 }
36566 {
36567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36568 }
36569 return resultobj;
36570 fail:
36571 return NULL;
36572 }
36573
36574
36575 static PyObject *_wrap_MenuItem_Toggle(PyObject *, PyObject *args, PyObject *kwargs) {
36576 PyObject *resultobj;
36577 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36578 PyObject * obj0 = 0 ;
36579 char *kwnames[] = {
36580 (char *) "self", NULL
36581 };
36582
36583 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_Toggle",kwnames,&obj0)) goto fail;
36584 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36585 if (SWIG_arg_fail(1)) SWIG_fail;
36586 {
36587 PyThreadState* __tstate = wxPyBeginAllowThreads();
36588 (arg1)->Toggle();
36589
36590 wxPyEndAllowThreads(__tstate);
36591 if (PyErr_Occurred()) SWIG_fail;
36592 }
36593 Py_INCREF(Py_None); resultobj = Py_None;
36594 return resultobj;
36595 fail:
36596 return NULL;
36597 }
36598
36599
36600 static PyObject *_wrap_MenuItem_SetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36601 PyObject *resultobj;
36602 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36603 wxString *arg2 = 0 ;
36604 bool temp2 = false ;
36605 PyObject * obj0 = 0 ;
36606 PyObject * obj1 = 0 ;
36607 char *kwnames[] = {
36608 (char *) "self",(char *) "str", NULL
36609 };
36610
36611 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) goto fail;
36612 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36613 if (SWIG_arg_fail(1)) SWIG_fail;
36614 {
36615 arg2 = wxString_in_helper(obj1);
36616 if (arg2 == NULL) SWIG_fail;
36617 temp2 = true;
36618 }
36619 {
36620 PyThreadState* __tstate = wxPyBeginAllowThreads();
36621 (arg1)->SetHelp((wxString const &)*arg2);
36622
36623 wxPyEndAllowThreads(__tstate);
36624 if (PyErr_Occurred()) SWIG_fail;
36625 }
36626 Py_INCREF(Py_None); resultobj = Py_None;
36627 {
36628 if (temp2)
36629 delete arg2;
36630 }
36631 return resultobj;
36632 fail:
36633 {
36634 if (temp2)
36635 delete arg2;
36636 }
36637 return NULL;
36638 }
36639
36640
36641 static PyObject *_wrap_MenuItem_GetHelp(PyObject *, PyObject *args, PyObject *kwargs) {
36642 PyObject *resultobj;
36643 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36644 wxString *result;
36645 PyObject * obj0 = 0 ;
36646 char *kwnames[] = {
36647 (char *) "self", NULL
36648 };
36649
36650 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetHelp",kwnames,&obj0)) goto fail;
36651 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36652 if (SWIG_arg_fail(1)) SWIG_fail;
36653 {
36654 PyThreadState* __tstate = wxPyBeginAllowThreads();
36655 {
36656 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
36657 result = (wxString *) &_result_ref;
36658 }
36659
36660 wxPyEndAllowThreads(__tstate);
36661 if (PyErr_Occurred()) SWIG_fail;
36662 }
36663 {
36664 #if wxUSE_UNICODE
36665 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
36666 #else
36667 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
36668 #endif
36669 }
36670 return resultobj;
36671 fail:
36672 return NULL;
36673 }
36674
36675
36676 static PyObject *_wrap_MenuItem_GetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36677 PyObject *resultobj;
36678 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36679 wxAcceleratorEntry *result;
36680 PyObject * obj0 = 0 ;
36681 char *kwnames[] = {
36682 (char *) "self", NULL
36683 };
36684
36685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetAccel",kwnames,&obj0)) goto fail;
36686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36687 if (SWIG_arg_fail(1)) SWIG_fail;
36688 {
36689 PyThreadState* __tstate = wxPyBeginAllowThreads();
36690 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
36691
36692 wxPyEndAllowThreads(__tstate);
36693 if (PyErr_Occurred()) SWIG_fail;
36694 }
36695 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxAcceleratorEntry, 0);
36696 return resultobj;
36697 fail:
36698 return NULL;
36699 }
36700
36701
36702 static PyObject *_wrap_MenuItem_SetAccel(PyObject *, PyObject *args, PyObject *kwargs) {
36703 PyObject *resultobj;
36704 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36705 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
36706 PyObject * obj0 = 0 ;
36707 PyObject * obj1 = 0 ;
36708 char *kwnames[] = {
36709 (char *) "self",(char *) "accel", NULL
36710 };
36711
36712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) goto fail;
36713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36714 if (SWIG_arg_fail(1)) SWIG_fail;
36715 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_EXCEPTION | 0);
36716 if (SWIG_arg_fail(2)) SWIG_fail;
36717 {
36718 PyThreadState* __tstate = wxPyBeginAllowThreads();
36719 (arg1)->SetAccel(arg2);
36720
36721 wxPyEndAllowThreads(__tstate);
36722 if (PyErr_Occurred()) SWIG_fail;
36723 }
36724 Py_INCREF(Py_None); resultobj = Py_None;
36725 return resultobj;
36726 fail:
36727 return NULL;
36728 }
36729
36730
36731 static PyObject *_wrap_MenuItem_SetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36732 PyObject *resultobj;
36733 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36734 wxFont *arg2 = 0 ;
36735 PyObject * obj0 = 0 ;
36736 PyObject * obj1 = 0 ;
36737 char *kwnames[] = {
36738 (char *) "self",(char *) "font", NULL
36739 };
36740
36741 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) goto fail;
36742 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36743 if (SWIG_arg_fail(1)) SWIG_fail;
36744 {
36745 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxFont, SWIG_POINTER_EXCEPTION | 0);
36746 if (SWIG_arg_fail(2)) SWIG_fail;
36747 if (arg2 == NULL) {
36748 SWIG_null_ref("wxFont");
36749 }
36750 if (SWIG_arg_fail(2)) SWIG_fail;
36751 }
36752 {
36753 PyThreadState* __tstate = wxPyBeginAllowThreads();
36754 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
36755
36756 wxPyEndAllowThreads(__tstate);
36757 if (PyErr_Occurred()) SWIG_fail;
36758 }
36759 Py_INCREF(Py_None); resultobj = Py_None;
36760 return resultobj;
36761 fail:
36762 return NULL;
36763 }
36764
36765
36766 static PyObject *_wrap_MenuItem_GetFont(PyObject *, PyObject *args, PyObject *kwargs) {
36767 PyObject *resultobj;
36768 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36769 wxFont result;
36770 PyObject * obj0 = 0 ;
36771 char *kwnames[] = {
36772 (char *) "self", NULL
36773 };
36774
36775 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetFont",kwnames,&obj0)) goto fail;
36776 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36777 if (SWIG_arg_fail(1)) SWIG_fail;
36778 {
36779 PyThreadState* __tstate = wxPyBeginAllowThreads();
36780 result = wxMenuItem_GetFont(arg1);
36781
36782 wxPyEndAllowThreads(__tstate);
36783 if (PyErr_Occurred()) SWIG_fail;
36784 }
36785 {
36786 wxFont * resultptr;
36787 resultptr = new wxFont((wxFont &)(result));
36788 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxFont, 1);
36789 }
36790 return resultobj;
36791 fail:
36792 return NULL;
36793 }
36794
36795
36796 static PyObject *_wrap_MenuItem_SetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36797 PyObject *resultobj;
36798 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36799 wxColour *arg2 = 0 ;
36800 wxColour temp2 ;
36801 PyObject * obj0 = 0 ;
36802 PyObject * obj1 = 0 ;
36803 char *kwnames[] = {
36804 (char *) "self",(char *) "colText", NULL
36805 };
36806
36807 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) goto fail;
36808 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36809 if (SWIG_arg_fail(1)) SWIG_fail;
36810 {
36811 arg2 = &temp2;
36812 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36813 }
36814 {
36815 PyThreadState* __tstate = wxPyBeginAllowThreads();
36816 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
36817
36818 wxPyEndAllowThreads(__tstate);
36819 if (PyErr_Occurred()) SWIG_fail;
36820 }
36821 Py_INCREF(Py_None); resultobj = Py_None;
36822 return resultobj;
36823 fail:
36824 return NULL;
36825 }
36826
36827
36828 static PyObject *_wrap_MenuItem_GetTextColour(PyObject *, PyObject *args, PyObject *kwargs) {
36829 PyObject *resultobj;
36830 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36831 wxColour result;
36832 PyObject * obj0 = 0 ;
36833 char *kwnames[] = {
36834 (char *) "self", NULL
36835 };
36836
36837 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetTextColour",kwnames,&obj0)) goto fail;
36838 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36839 if (SWIG_arg_fail(1)) SWIG_fail;
36840 {
36841 PyThreadState* __tstate = wxPyBeginAllowThreads();
36842 result = wxMenuItem_GetTextColour(arg1);
36843
36844 wxPyEndAllowThreads(__tstate);
36845 if (PyErr_Occurred()) SWIG_fail;
36846 }
36847 {
36848 wxColour * resultptr;
36849 resultptr = new wxColour((wxColour &)(result));
36850 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36851 }
36852 return resultobj;
36853 fail:
36854 return NULL;
36855 }
36856
36857
36858 static PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36859 PyObject *resultobj;
36860 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36861 wxColour *arg2 = 0 ;
36862 wxColour temp2 ;
36863 PyObject * obj0 = 0 ;
36864 PyObject * obj1 = 0 ;
36865 char *kwnames[] = {
36866 (char *) "self",(char *) "colBack", NULL
36867 };
36868
36869 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) goto fail;
36870 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36871 if (SWIG_arg_fail(1)) SWIG_fail;
36872 {
36873 arg2 = &temp2;
36874 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
36875 }
36876 {
36877 PyThreadState* __tstate = wxPyBeginAllowThreads();
36878 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
36879
36880 wxPyEndAllowThreads(__tstate);
36881 if (PyErr_Occurred()) SWIG_fail;
36882 }
36883 Py_INCREF(Py_None); resultobj = Py_None;
36884 return resultobj;
36885 fail:
36886 return NULL;
36887 }
36888
36889
36890 static PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *, PyObject *args, PyObject *kwargs) {
36891 PyObject *resultobj;
36892 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36893 wxColour result;
36894 PyObject * obj0 = 0 ;
36895 char *kwnames[] = {
36896 (char *) "self", NULL
36897 };
36898
36899 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBackgroundColour",kwnames,&obj0)) goto fail;
36900 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36901 if (SWIG_arg_fail(1)) SWIG_fail;
36902 {
36903 PyThreadState* __tstate = wxPyBeginAllowThreads();
36904 result = wxMenuItem_GetBackgroundColour(arg1);
36905
36906 wxPyEndAllowThreads(__tstate);
36907 if (PyErr_Occurred()) SWIG_fail;
36908 }
36909 {
36910 wxColour * resultptr;
36911 resultptr = new wxColour((wxColour &)(result));
36912 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxColour, 1);
36913 }
36914 return resultobj;
36915 fail:
36916 return NULL;
36917 }
36918
36919
36920 static PyObject *_wrap_MenuItem_SetBitmaps(PyObject *, PyObject *args, PyObject *kwargs) {
36921 PyObject *resultobj;
36922 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36923 wxBitmap *arg2 = 0 ;
36924 wxBitmap const &arg3_defvalue = wxNullBitmap ;
36925 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
36926 PyObject * obj0 = 0 ;
36927 PyObject * obj1 = 0 ;
36928 PyObject * obj2 = 0 ;
36929 char *kwnames[] = {
36930 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
36931 };
36932
36933 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) goto fail;
36934 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36935 if (SWIG_arg_fail(1)) SWIG_fail;
36936 {
36937 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36938 if (SWIG_arg_fail(2)) SWIG_fail;
36939 if (arg2 == NULL) {
36940 SWIG_null_ref("wxBitmap");
36941 }
36942 if (SWIG_arg_fail(2)) SWIG_fail;
36943 }
36944 if (obj2) {
36945 {
36946 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36947 if (SWIG_arg_fail(3)) SWIG_fail;
36948 if (arg3 == NULL) {
36949 SWIG_null_ref("wxBitmap");
36950 }
36951 if (SWIG_arg_fail(3)) SWIG_fail;
36952 }
36953 }
36954 {
36955 PyThreadState* __tstate = wxPyBeginAllowThreads();
36956 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
36957
36958 wxPyEndAllowThreads(__tstate);
36959 if (PyErr_Occurred()) SWIG_fail;
36960 }
36961 Py_INCREF(Py_None); resultobj = Py_None;
36962 return resultobj;
36963 fail:
36964 return NULL;
36965 }
36966
36967
36968 static PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
36969 PyObject *resultobj;
36970 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
36971 wxBitmap *arg2 = 0 ;
36972 PyObject * obj0 = 0 ;
36973 PyObject * obj1 = 0 ;
36974 char *kwnames[] = {
36975 (char *) "self",(char *) "bmpDisabled", NULL
36976 };
36977
36978 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) goto fail;
36979 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
36980 if (SWIG_arg_fail(1)) SWIG_fail;
36981 {
36982 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
36983 if (SWIG_arg_fail(2)) SWIG_fail;
36984 if (arg2 == NULL) {
36985 SWIG_null_ref("wxBitmap");
36986 }
36987 if (SWIG_arg_fail(2)) SWIG_fail;
36988 }
36989 {
36990 PyThreadState* __tstate = wxPyBeginAllowThreads();
36991 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
36992
36993 wxPyEndAllowThreads(__tstate);
36994 if (PyErr_Occurred()) SWIG_fail;
36995 }
36996 Py_INCREF(Py_None); resultobj = Py_None;
36997 return resultobj;
36998 fail:
36999 return NULL;
37000 }
37001
37002
37003 static PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37004 PyObject *resultobj;
37005 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37006 wxBitmap *result;
37007 PyObject * obj0 = 0 ;
37008 char *kwnames[] = {
37009 (char *) "self", NULL
37010 };
37011
37012 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetDisabledBitmap",kwnames,&obj0)) goto fail;
37013 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37014 if (SWIG_arg_fail(1)) SWIG_fail;
37015 {
37016 PyThreadState* __tstate = wxPyBeginAllowThreads();
37017 {
37018 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
37019 result = (wxBitmap *) &_result_ref;
37020 }
37021
37022 wxPyEndAllowThreads(__tstate);
37023 if (PyErr_Occurred()) SWIG_fail;
37024 }
37025 {
37026 wxBitmap* resultptr = new wxBitmap(*result);
37027 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37028 }
37029 return resultobj;
37030 fail:
37031 return NULL;
37032 }
37033
37034
37035 static PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37036 PyObject *resultobj;
37037 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37038 int arg2 ;
37039 PyObject * obj0 = 0 ;
37040 PyObject * obj1 = 0 ;
37041 char *kwnames[] = {
37042 (char *) "self",(char *) "nWidth", NULL
37043 };
37044
37045 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) goto fail;
37046 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37047 if (SWIG_arg_fail(1)) SWIG_fail;
37048 {
37049 arg2 = (int)(SWIG_As_int(obj1));
37050 if (SWIG_arg_fail(2)) SWIG_fail;
37051 }
37052 {
37053 PyThreadState* __tstate = wxPyBeginAllowThreads();
37054 wxMenuItem_SetMarginWidth(arg1,arg2);
37055
37056 wxPyEndAllowThreads(__tstate);
37057 if (PyErr_Occurred()) SWIG_fail;
37058 }
37059 Py_INCREF(Py_None); resultobj = Py_None;
37060 return resultobj;
37061 fail:
37062 return NULL;
37063 }
37064
37065
37066 static PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37067 PyObject *resultobj;
37068 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37069 int result;
37070 PyObject * obj0 = 0 ;
37071 char *kwnames[] = {
37072 (char *) "self", NULL
37073 };
37074
37075 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetMarginWidth",kwnames,&obj0)) goto fail;
37076 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37077 if (SWIG_arg_fail(1)) SWIG_fail;
37078 {
37079 PyThreadState* __tstate = wxPyBeginAllowThreads();
37080 result = (int)wxMenuItem_GetMarginWidth(arg1);
37081
37082 wxPyEndAllowThreads(__tstate);
37083 if (PyErr_Occurred()) SWIG_fail;
37084 }
37085 {
37086 resultobj = SWIG_From_int((int)(result));
37087 }
37088 return resultobj;
37089 fail:
37090 return NULL;
37091 }
37092
37093
37094 static PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *, PyObject *args, PyObject *kwargs) {
37095 PyObject *resultobj;
37096 int result;
37097 char *kwnames[] = {
37098 NULL
37099 };
37100
37101 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":MenuItem_GetDefaultMarginWidth",kwnames)) goto fail;
37102 {
37103 PyThreadState* __tstate = wxPyBeginAllowThreads();
37104 result = (int)MenuItem_GetDefaultMarginWidth();
37105
37106 wxPyEndAllowThreads(__tstate);
37107 if (PyErr_Occurred()) SWIG_fail;
37108 }
37109 {
37110 resultobj = SWIG_From_int((int)(result));
37111 }
37112 return resultobj;
37113 fail:
37114 return NULL;
37115 }
37116
37117
37118 static PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37119 PyObject *resultobj;
37120 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37121 bool result;
37122 PyObject * obj0 = 0 ;
37123 char *kwnames[] = {
37124 (char *) "self", NULL
37125 };
37126
37127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_IsOwnerDrawn",kwnames,&obj0)) goto fail;
37128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37129 if (SWIG_arg_fail(1)) SWIG_fail;
37130 {
37131 PyThreadState* __tstate = wxPyBeginAllowThreads();
37132 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
37133
37134 wxPyEndAllowThreads(__tstate);
37135 if (PyErr_Occurred()) SWIG_fail;
37136 }
37137 {
37138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37139 }
37140 return resultobj;
37141 fail:
37142 return NULL;
37143 }
37144
37145
37146 static PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37147 PyObject *resultobj;
37148 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37149 bool arg2 = (bool) true ;
37150 PyObject * obj0 = 0 ;
37151 PyObject * obj1 = 0 ;
37152 char *kwnames[] = {
37153 (char *) "self",(char *) "ownerDrawn", NULL
37154 };
37155
37156 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) goto fail;
37157 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37158 if (SWIG_arg_fail(1)) SWIG_fail;
37159 if (obj1) {
37160 {
37161 arg2 = (bool)(SWIG_As_bool(obj1));
37162 if (SWIG_arg_fail(2)) SWIG_fail;
37163 }
37164 }
37165 {
37166 PyThreadState* __tstate = wxPyBeginAllowThreads();
37167 wxMenuItem_SetOwnerDrawn(arg1,arg2);
37168
37169 wxPyEndAllowThreads(__tstate);
37170 if (PyErr_Occurred()) SWIG_fail;
37171 }
37172 Py_INCREF(Py_None); resultobj = Py_None;
37173 return resultobj;
37174 fail:
37175 return NULL;
37176 }
37177
37178
37179 static PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *, PyObject *args, PyObject *kwargs) {
37180 PyObject *resultobj;
37181 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37182 PyObject * obj0 = 0 ;
37183 char *kwnames[] = {
37184 (char *) "self", NULL
37185 };
37186
37187 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_ResetOwnerDrawn",kwnames,&obj0)) goto fail;
37188 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37189 if (SWIG_arg_fail(1)) SWIG_fail;
37190 {
37191 PyThreadState* __tstate = wxPyBeginAllowThreads();
37192 wxMenuItem_ResetOwnerDrawn(arg1);
37193
37194 wxPyEndAllowThreads(__tstate);
37195 if (PyErr_Occurred()) SWIG_fail;
37196 }
37197 Py_INCREF(Py_None); resultobj = Py_None;
37198 return resultobj;
37199 fail:
37200 return NULL;
37201 }
37202
37203
37204 static PyObject *_wrap_MenuItem_SetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37205 PyObject *resultobj;
37206 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37207 wxBitmap *arg2 = 0 ;
37208 PyObject * obj0 = 0 ;
37209 PyObject * obj1 = 0 ;
37210 char *kwnames[] = {
37211 (char *) "self",(char *) "bitmap", NULL
37212 };
37213
37214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) goto fail;
37215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37216 if (SWIG_arg_fail(1)) SWIG_fail;
37217 {
37218 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxBitmap, SWIG_POINTER_EXCEPTION | 0);
37219 if (SWIG_arg_fail(2)) SWIG_fail;
37220 if (arg2 == NULL) {
37221 SWIG_null_ref("wxBitmap");
37222 }
37223 if (SWIG_arg_fail(2)) SWIG_fail;
37224 }
37225 {
37226 PyThreadState* __tstate = wxPyBeginAllowThreads();
37227 (arg1)->SetBitmap((wxBitmap const &)*arg2);
37228
37229 wxPyEndAllowThreads(__tstate);
37230 if (PyErr_Occurred()) SWIG_fail;
37231 }
37232 Py_INCREF(Py_None); resultobj = Py_None;
37233 return resultobj;
37234 fail:
37235 return NULL;
37236 }
37237
37238
37239 static PyObject *_wrap_MenuItem_GetBitmap(PyObject *, PyObject *args, PyObject *kwargs) {
37240 PyObject *resultobj;
37241 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
37242 wxBitmap *result;
37243 PyObject * obj0 = 0 ;
37244 char *kwnames[] = {
37245 (char *) "self", NULL
37246 };
37247
37248 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetBitmap",kwnames,&obj0)) goto fail;
37249 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxMenuItem, SWIG_POINTER_EXCEPTION | 0);
37250 if (SWIG_arg_fail(1)) SWIG_fail;
37251 {
37252 PyThreadState* __tstate = wxPyBeginAllowThreads();
37253 {
37254 wxBitmap const &_result_ref = (arg1)->GetBitmap();
37255 result = (wxBitmap *) &_result_ref;
37256 }
37257
37258 wxPyEndAllowThreads(__tstate);
37259 if (PyErr_Occurred()) SWIG_fail;
37260 }
37261 {
37262 wxBitmap* resultptr = new wxBitmap(*result);
37263 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
37264 }
37265 return resultobj;
37266 fail:
37267 return NULL;
37268 }
37269
37270
37271 static PyObject * MenuItem_swigregister(PyObject *, PyObject *args) {
37272 PyObject *obj;
37273 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37274 SWIG_TypeClientData(SWIGTYPE_p_wxMenuItem, obj);
37275 Py_INCREF(obj);
37276 return Py_BuildValue((char *)"");
37277 }
37278 static int _wrap_ControlNameStr_set(PyObject *) {
37279 PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
37280 return 1;
37281 }
37282
37283
37284 static PyObject *_wrap_ControlNameStr_get(void) {
37285 PyObject *pyobj;
37286
37287 {
37288 #if wxUSE_UNICODE
37289 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37290 #else
37291 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
37292 #endif
37293 }
37294 return pyobj;
37295 }
37296
37297
37298 static PyObject *_wrap_new_Control(PyObject *, PyObject *args, PyObject *kwargs) {
37299 PyObject *resultobj;
37300 wxWindow *arg1 = (wxWindow *) 0 ;
37301 int arg2 = (int) -1 ;
37302 wxPoint const &arg3_defvalue = wxDefaultPosition ;
37303 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
37304 wxSize const &arg4_defvalue = wxDefaultSize ;
37305 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
37306 long arg5 = (long) 0 ;
37307 wxValidator const &arg6_defvalue = wxDefaultValidator ;
37308 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
37309 wxString const &arg7_defvalue = wxPyControlNameStr ;
37310 wxString *arg7 = (wxString *) &arg7_defvalue ;
37311 wxControl *result;
37312 wxPoint temp3 ;
37313 wxSize temp4 ;
37314 bool temp7 = false ;
37315 PyObject * obj0 = 0 ;
37316 PyObject * obj1 = 0 ;
37317 PyObject * obj2 = 0 ;
37318 PyObject * obj3 = 0 ;
37319 PyObject * obj4 = 0 ;
37320 PyObject * obj5 = 0 ;
37321 PyObject * obj6 = 0 ;
37322 char *kwnames[] = {
37323 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37324 };
37325
37326 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
37327 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37328 if (SWIG_arg_fail(1)) SWIG_fail;
37329 if (obj1) {
37330 {
37331 arg2 = (int)(SWIG_As_int(obj1));
37332 if (SWIG_arg_fail(2)) SWIG_fail;
37333 }
37334 }
37335 if (obj2) {
37336 {
37337 arg3 = &temp3;
37338 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
37339 }
37340 }
37341 if (obj3) {
37342 {
37343 arg4 = &temp4;
37344 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
37345 }
37346 }
37347 if (obj4) {
37348 {
37349 arg5 = (long)(SWIG_As_long(obj4));
37350 if (SWIG_arg_fail(5)) SWIG_fail;
37351 }
37352 }
37353 if (obj5) {
37354 {
37355 SWIG_Python_ConvertPtr(obj5, (void **)&arg6, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37356 if (SWIG_arg_fail(6)) SWIG_fail;
37357 if (arg6 == NULL) {
37358 SWIG_null_ref("wxValidator");
37359 }
37360 if (SWIG_arg_fail(6)) SWIG_fail;
37361 }
37362 }
37363 if (obj6) {
37364 {
37365 arg7 = wxString_in_helper(obj6);
37366 if (arg7 == NULL) SWIG_fail;
37367 temp7 = true;
37368 }
37369 }
37370 {
37371 if (!wxPyCheckForApp()) SWIG_fail;
37372 PyThreadState* __tstate = wxPyBeginAllowThreads();
37373 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
37374
37375 wxPyEndAllowThreads(__tstate);
37376 if (PyErr_Occurred()) SWIG_fail;
37377 }
37378 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37379 {
37380 if (temp7)
37381 delete arg7;
37382 }
37383 return resultobj;
37384 fail:
37385 {
37386 if (temp7)
37387 delete arg7;
37388 }
37389 return NULL;
37390 }
37391
37392
37393 static PyObject *_wrap_new_PreControl(PyObject *, PyObject *args, PyObject *kwargs) {
37394 PyObject *resultobj;
37395 wxControl *result;
37396 char *kwnames[] = {
37397 NULL
37398 };
37399
37400 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PreControl",kwnames)) goto fail;
37401 {
37402 if (!wxPyCheckForApp()) SWIG_fail;
37403 PyThreadState* __tstate = wxPyBeginAllowThreads();
37404 result = (wxControl *)new wxControl();
37405
37406 wxPyEndAllowThreads(__tstate);
37407 if (PyErr_Occurred()) SWIG_fail;
37408 }
37409 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxControl, 1);
37410 return resultobj;
37411 fail:
37412 return NULL;
37413 }
37414
37415
37416 static PyObject *_wrap_Control_Create(PyObject *, PyObject *args, PyObject *kwargs) {
37417 PyObject *resultobj;
37418 wxControl *arg1 = (wxControl *) 0 ;
37419 wxWindow *arg2 = (wxWindow *) 0 ;
37420 int arg3 = (int) -1 ;
37421 wxPoint const &arg4_defvalue = wxDefaultPosition ;
37422 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
37423 wxSize const &arg5_defvalue = wxDefaultSize ;
37424 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
37425 long arg6 = (long) 0 ;
37426 wxValidator const &arg7_defvalue = wxDefaultValidator ;
37427 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
37428 wxString const &arg8_defvalue = wxPyControlNameStr ;
37429 wxString *arg8 = (wxString *) &arg8_defvalue ;
37430 bool result;
37431 wxPoint temp4 ;
37432 wxSize temp5 ;
37433 bool temp8 = false ;
37434 PyObject * obj0 = 0 ;
37435 PyObject * obj1 = 0 ;
37436 PyObject * obj2 = 0 ;
37437 PyObject * obj3 = 0 ;
37438 PyObject * obj4 = 0 ;
37439 PyObject * obj5 = 0 ;
37440 PyObject * obj6 = 0 ;
37441 PyObject * obj7 = 0 ;
37442 char *kwnames[] = {
37443 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
37444 };
37445
37446 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) goto fail;
37447 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37448 if (SWIG_arg_fail(1)) SWIG_fail;
37449 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
37450 if (SWIG_arg_fail(2)) SWIG_fail;
37451 if (obj2) {
37452 {
37453 arg3 = (int)(SWIG_As_int(obj2));
37454 if (SWIG_arg_fail(3)) SWIG_fail;
37455 }
37456 }
37457 if (obj3) {
37458 {
37459 arg4 = &temp4;
37460 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
37461 }
37462 }
37463 if (obj4) {
37464 {
37465 arg5 = &temp5;
37466 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
37467 }
37468 }
37469 if (obj5) {
37470 {
37471 arg6 = (long)(SWIG_As_long(obj5));
37472 if (SWIG_arg_fail(6)) SWIG_fail;
37473 }
37474 }
37475 if (obj6) {
37476 {
37477 SWIG_Python_ConvertPtr(obj6, (void **)&arg7, SWIGTYPE_p_wxValidator, SWIG_POINTER_EXCEPTION | 0);
37478 if (SWIG_arg_fail(7)) SWIG_fail;
37479 if (arg7 == NULL) {
37480 SWIG_null_ref("wxValidator");
37481 }
37482 if (SWIG_arg_fail(7)) SWIG_fail;
37483 }
37484 }
37485 if (obj7) {
37486 {
37487 arg8 = wxString_in_helper(obj7);
37488 if (arg8 == NULL) SWIG_fail;
37489 temp8 = true;
37490 }
37491 }
37492 {
37493 PyThreadState* __tstate = wxPyBeginAllowThreads();
37494 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
37495
37496 wxPyEndAllowThreads(__tstate);
37497 if (PyErr_Occurred()) SWIG_fail;
37498 }
37499 {
37500 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37501 }
37502 {
37503 if (temp8)
37504 delete arg8;
37505 }
37506 return resultobj;
37507 fail:
37508 {
37509 if (temp8)
37510 delete arg8;
37511 }
37512 return NULL;
37513 }
37514
37515
37516 static PyObject *_wrap_Control_Command(PyObject *, PyObject *args, PyObject *kwargs) {
37517 PyObject *resultobj;
37518 wxControl *arg1 = (wxControl *) 0 ;
37519 wxCommandEvent *arg2 = 0 ;
37520 PyObject * obj0 = 0 ;
37521 PyObject * obj1 = 0 ;
37522 char *kwnames[] = {
37523 (char *) "self",(char *) "event", NULL
37524 };
37525
37526 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) goto fail;
37527 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37528 if (SWIG_arg_fail(1)) SWIG_fail;
37529 {
37530 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_EXCEPTION | 0);
37531 if (SWIG_arg_fail(2)) SWIG_fail;
37532 if (arg2 == NULL) {
37533 SWIG_null_ref("wxCommandEvent");
37534 }
37535 if (SWIG_arg_fail(2)) SWIG_fail;
37536 }
37537 {
37538 PyThreadState* __tstate = wxPyBeginAllowThreads();
37539 (arg1)->Command(*arg2);
37540
37541 wxPyEndAllowThreads(__tstate);
37542 if (PyErr_Occurred()) SWIG_fail;
37543 }
37544 Py_INCREF(Py_None); resultobj = Py_None;
37545 return resultobj;
37546 fail:
37547 return NULL;
37548 }
37549
37550
37551 static PyObject *_wrap_Control_GetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37552 PyObject *resultobj;
37553 wxControl *arg1 = (wxControl *) 0 ;
37554 wxString result;
37555 PyObject * obj0 = 0 ;
37556 char *kwnames[] = {
37557 (char *) "self", NULL
37558 };
37559
37560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Control_GetLabel",kwnames,&obj0)) goto fail;
37561 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37562 if (SWIG_arg_fail(1)) SWIG_fail;
37563 {
37564 PyThreadState* __tstate = wxPyBeginAllowThreads();
37565 result = (arg1)->GetLabel();
37566
37567 wxPyEndAllowThreads(__tstate);
37568 if (PyErr_Occurred()) SWIG_fail;
37569 }
37570 {
37571 #if wxUSE_UNICODE
37572 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37573 #else
37574 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37575 #endif
37576 }
37577 return resultobj;
37578 fail:
37579 return NULL;
37580 }
37581
37582
37583 static PyObject *_wrap_Control_SetLabel(PyObject *, PyObject *args, PyObject *kwargs) {
37584 PyObject *resultobj;
37585 wxControl *arg1 = (wxControl *) 0 ;
37586 wxString *arg2 = 0 ;
37587 bool temp2 = false ;
37588 PyObject * obj0 = 0 ;
37589 PyObject * obj1 = 0 ;
37590 char *kwnames[] = {
37591 (char *) "self",(char *) "label", NULL
37592 };
37593
37594 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_SetLabel",kwnames,&obj0,&obj1)) goto fail;
37595 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxControl, SWIG_POINTER_EXCEPTION | 0);
37596 if (SWIG_arg_fail(1)) SWIG_fail;
37597 {
37598 arg2 = wxString_in_helper(obj1);
37599 if (arg2 == NULL) SWIG_fail;
37600 temp2 = true;
37601 }
37602 {
37603 PyThreadState* __tstate = wxPyBeginAllowThreads();
37604 (arg1)->SetLabel((wxString const &)*arg2);
37605
37606 wxPyEndAllowThreads(__tstate);
37607 if (PyErr_Occurred()) SWIG_fail;
37608 }
37609 Py_INCREF(Py_None); resultobj = Py_None;
37610 {
37611 if (temp2)
37612 delete arg2;
37613 }
37614 return resultobj;
37615 fail:
37616 {
37617 if (temp2)
37618 delete arg2;
37619 }
37620 return NULL;
37621 }
37622
37623
37624 static PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *, PyObject *args, PyObject *kwargs) {
37625 PyObject *resultobj;
37626 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
37627 wxVisualAttributes result;
37628 PyObject * obj0 = 0 ;
37629 char *kwnames[] = {
37630 (char *) "variant", NULL
37631 };
37632
37633 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) goto fail;
37634 if (obj0) {
37635 {
37636 arg1 = (wxWindowVariant)(SWIG_As_int(obj0));
37637 if (SWIG_arg_fail(1)) SWIG_fail;
37638 }
37639 }
37640 {
37641 if (!wxPyCheckForApp()) SWIG_fail;
37642 PyThreadState* __tstate = wxPyBeginAllowThreads();
37643 result = wxControl::GetClassDefaultAttributes((wxWindowVariant )arg1);
37644
37645 wxPyEndAllowThreads(__tstate);
37646 if (PyErr_Occurred()) SWIG_fail;
37647 }
37648 {
37649 wxVisualAttributes * resultptr;
37650 resultptr = new wxVisualAttributes((wxVisualAttributes &)(result));
37651 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxVisualAttributes, 1);
37652 }
37653 return resultobj;
37654 fail:
37655 return NULL;
37656 }
37657
37658
37659 static PyObject * Control_swigregister(PyObject *, PyObject *args) {
37660 PyObject *obj;
37661 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
37662 SWIG_TypeClientData(SWIGTYPE_p_wxControl, obj);
37663 Py_INCREF(obj);
37664 return Py_BuildValue((char *)"");
37665 }
37666 static PyObject *_wrap_ItemContainer_Append(PyObject *, PyObject *args, PyObject *kwargs) {
37667 PyObject *resultobj;
37668 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37669 wxString *arg2 = 0 ;
37670 PyObject *arg3 = (PyObject *) NULL ;
37671 int result;
37672 bool temp2 = false ;
37673 PyObject * obj0 = 0 ;
37674 PyObject * obj1 = 0 ;
37675 PyObject * obj2 = 0 ;
37676 char *kwnames[] = {
37677 (char *) "self",(char *) "item",(char *) "clientData", NULL
37678 };
37679
37680 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) goto fail;
37681 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37682 if (SWIG_arg_fail(1)) SWIG_fail;
37683 {
37684 arg2 = wxString_in_helper(obj1);
37685 if (arg2 == NULL) SWIG_fail;
37686 temp2 = true;
37687 }
37688 if (obj2) {
37689 arg3 = obj2;
37690 }
37691 {
37692 PyThreadState* __tstate = wxPyBeginAllowThreads();
37693 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
37694
37695 wxPyEndAllowThreads(__tstate);
37696 if (PyErr_Occurred()) SWIG_fail;
37697 }
37698 {
37699 resultobj = SWIG_From_int((int)(result));
37700 }
37701 {
37702 if (temp2)
37703 delete arg2;
37704 }
37705 return resultobj;
37706 fail:
37707 {
37708 if (temp2)
37709 delete arg2;
37710 }
37711 return NULL;
37712 }
37713
37714
37715 static PyObject *_wrap_ItemContainer_AppendItems(PyObject *, PyObject *args, PyObject *kwargs) {
37716 PyObject *resultobj;
37717 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37718 wxArrayString *arg2 = 0 ;
37719 bool temp2 = false ;
37720 PyObject * obj0 = 0 ;
37721 PyObject * obj1 = 0 ;
37722 char *kwnames[] = {
37723 (char *) "self",(char *) "strings", NULL
37724 };
37725
37726 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) goto fail;
37727 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37728 if (SWIG_arg_fail(1)) SWIG_fail;
37729 {
37730 if (! PySequence_Check(obj1)) {
37731 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
37732 SWIG_fail;
37733 }
37734 arg2 = new wxArrayString;
37735 temp2 = true;
37736 int i, len=PySequence_Length(obj1);
37737 for (i=0; i<len; i++) {
37738 PyObject* item = PySequence_GetItem(obj1, i);
37739 #if wxUSE_UNICODE
37740 PyObject* str = PyObject_Unicode(item);
37741 #else
37742 PyObject* str = PyObject_Str(item);
37743 #endif
37744 if (PyErr_Occurred()) SWIG_fail;
37745 arg2->Add(Py2wxString(str));
37746 Py_DECREF(item);
37747 Py_DECREF(str);
37748 }
37749 }
37750 {
37751 PyThreadState* __tstate = wxPyBeginAllowThreads();
37752 (arg1)->Append((wxArrayString const &)*arg2);
37753
37754 wxPyEndAllowThreads(__tstate);
37755 if (PyErr_Occurred()) SWIG_fail;
37756 }
37757 Py_INCREF(Py_None); resultobj = Py_None;
37758 {
37759 if (temp2) delete arg2;
37760 }
37761 return resultobj;
37762 fail:
37763 {
37764 if (temp2) delete arg2;
37765 }
37766 return NULL;
37767 }
37768
37769
37770 static PyObject *_wrap_ItemContainer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
37771 PyObject *resultobj;
37772 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37773 wxString *arg2 = 0 ;
37774 int arg3 ;
37775 PyObject *arg4 = (PyObject *) NULL ;
37776 int result;
37777 bool temp2 = false ;
37778 PyObject * obj0 = 0 ;
37779 PyObject * obj1 = 0 ;
37780 PyObject * obj2 = 0 ;
37781 PyObject * obj3 = 0 ;
37782 char *kwnames[] = {
37783 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
37784 };
37785
37786 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
37787 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37788 if (SWIG_arg_fail(1)) SWIG_fail;
37789 {
37790 arg2 = wxString_in_helper(obj1);
37791 if (arg2 == NULL) SWIG_fail;
37792 temp2 = true;
37793 }
37794 {
37795 arg3 = (int)(SWIG_As_int(obj2));
37796 if (SWIG_arg_fail(3)) SWIG_fail;
37797 }
37798 if (obj3) {
37799 arg4 = obj3;
37800 }
37801 {
37802 PyThreadState* __tstate = wxPyBeginAllowThreads();
37803 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
37804
37805 wxPyEndAllowThreads(__tstate);
37806 if (PyErr_Occurred()) SWIG_fail;
37807 }
37808 {
37809 resultobj = SWIG_From_int((int)(result));
37810 }
37811 {
37812 if (temp2)
37813 delete arg2;
37814 }
37815 return resultobj;
37816 fail:
37817 {
37818 if (temp2)
37819 delete arg2;
37820 }
37821 return NULL;
37822 }
37823
37824
37825 static PyObject *_wrap_ItemContainer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
37826 PyObject *resultobj;
37827 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37828 PyObject * obj0 = 0 ;
37829 char *kwnames[] = {
37830 (char *) "self", NULL
37831 };
37832
37833 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_Clear",kwnames,&obj0)) goto fail;
37834 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37835 if (SWIG_arg_fail(1)) SWIG_fail;
37836 {
37837 PyThreadState* __tstate = wxPyBeginAllowThreads();
37838 (arg1)->Clear();
37839
37840 wxPyEndAllowThreads(__tstate);
37841 if (PyErr_Occurred()) SWIG_fail;
37842 }
37843 Py_INCREF(Py_None); resultobj = Py_None;
37844 return resultobj;
37845 fail:
37846 return NULL;
37847 }
37848
37849
37850 static PyObject *_wrap_ItemContainer_Delete(PyObject *, PyObject *args, PyObject *kwargs) {
37851 PyObject *resultobj;
37852 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37853 int arg2 ;
37854 PyObject * obj0 = 0 ;
37855 PyObject * obj1 = 0 ;
37856 char *kwnames[] = {
37857 (char *) "self",(char *) "n", NULL
37858 };
37859
37860 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) goto fail;
37861 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37862 if (SWIG_arg_fail(1)) SWIG_fail;
37863 {
37864 arg2 = (int)(SWIG_As_int(obj1));
37865 if (SWIG_arg_fail(2)) SWIG_fail;
37866 }
37867 {
37868 PyThreadState* __tstate = wxPyBeginAllowThreads();
37869 (arg1)->Delete(arg2);
37870
37871 wxPyEndAllowThreads(__tstate);
37872 if (PyErr_Occurred()) SWIG_fail;
37873 }
37874 Py_INCREF(Py_None); resultobj = Py_None;
37875 return resultobj;
37876 fail:
37877 return NULL;
37878 }
37879
37880
37881 static PyObject *_wrap_ItemContainer_GetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37882 PyObject *resultobj;
37883 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37884 int arg2 ;
37885 PyObject *result;
37886 PyObject * obj0 = 0 ;
37887 PyObject * obj1 = 0 ;
37888 char *kwnames[] = {
37889 (char *) "self",(char *) "n", NULL
37890 };
37891
37892 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) goto fail;
37893 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37894 if (SWIG_arg_fail(1)) SWIG_fail;
37895 {
37896 arg2 = (int)(SWIG_As_int(obj1));
37897 if (SWIG_arg_fail(2)) SWIG_fail;
37898 }
37899 {
37900 PyThreadState* __tstate = wxPyBeginAllowThreads();
37901 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
37902
37903 wxPyEndAllowThreads(__tstate);
37904 if (PyErr_Occurred()) SWIG_fail;
37905 }
37906 resultobj = result;
37907 return resultobj;
37908 fail:
37909 return NULL;
37910 }
37911
37912
37913 static PyObject *_wrap_ItemContainer_SetClientData(PyObject *, PyObject *args, PyObject *kwargs) {
37914 PyObject *resultobj;
37915 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37916 int arg2 ;
37917 PyObject *arg3 = (PyObject *) 0 ;
37918 PyObject * obj0 = 0 ;
37919 PyObject * obj1 = 0 ;
37920 PyObject * obj2 = 0 ;
37921 char *kwnames[] = {
37922 (char *) "self",(char *) "n",(char *) "clientData", NULL
37923 };
37924
37925 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) goto fail;
37926 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37927 if (SWIG_arg_fail(1)) SWIG_fail;
37928 {
37929 arg2 = (int)(SWIG_As_int(obj1));
37930 if (SWIG_arg_fail(2)) SWIG_fail;
37931 }
37932 arg3 = obj2;
37933 {
37934 PyThreadState* __tstate = wxPyBeginAllowThreads();
37935 wxItemContainer_SetClientData(arg1,arg2,arg3);
37936
37937 wxPyEndAllowThreads(__tstate);
37938 if (PyErr_Occurred()) SWIG_fail;
37939 }
37940 Py_INCREF(Py_None); resultobj = Py_None;
37941 return resultobj;
37942 fail:
37943 return NULL;
37944 }
37945
37946
37947 static PyObject *_wrap_ItemContainer_GetCount(PyObject *, PyObject *args, PyObject *kwargs) {
37948 PyObject *resultobj;
37949 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37950 int result;
37951 PyObject * obj0 = 0 ;
37952 char *kwnames[] = {
37953 (char *) "self", NULL
37954 };
37955
37956 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetCount",kwnames,&obj0)) goto fail;
37957 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37958 if (SWIG_arg_fail(1)) SWIG_fail;
37959 {
37960 PyThreadState* __tstate = wxPyBeginAllowThreads();
37961 result = (int)((wxItemContainer const *)arg1)->GetCount();
37962
37963 wxPyEndAllowThreads(__tstate);
37964 if (PyErr_Occurred()) SWIG_fail;
37965 }
37966 {
37967 resultobj = SWIG_From_int((int)(result));
37968 }
37969 return resultobj;
37970 fail:
37971 return NULL;
37972 }
37973
37974
37975 static PyObject *_wrap_ItemContainer_IsEmpty(PyObject *, PyObject *args, PyObject *kwargs) {
37976 PyObject *resultobj;
37977 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
37978 bool result;
37979 PyObject * obj0 = 0 ;
37980 char *kwnames[] = {
37981 (char *) "self", NULL
37982 };
37983
37984 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_IsEmpty",kwnames,&obj0)) goto fail;
37985 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
37986 if (SWIG_arg_fail(1)) SWIG_fail;
37987 {
37988 PyThreadState* __tstate = wxPyBeginAllowThreads();
37989 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
37990
37991 wxPyEndAllowThreads(__tstate);
37992 if (PyErr_Occurred()) SWIG_fail;
37993 }
37994 {
37995 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37996 }
37997 return resultobj;
37998 fail:
37999 return NULL;
38000 }
38001
38002
38003 static PyObject *_wrap_ItemContainer_GetString(PyObject *, PyObject *args, PyObject *kwargs) {
38004 PyObject *resultobj;
38005 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38006 int arg2 ;
38007 wxString result;
38008 PyObject * obj0 = 0 ;
38009 PyObject * obj1 = 0 ;
38010 char *kwnames[] = {
38011 (char *) "self",(char *) "n", NULL
38012 };
38013
38014 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) goto fail;
38015 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38016 if (SWIG_arg_fail(1)) SWIG_fail;
38017 {
38018 arg2 = (int)(SWIG_As_int(obj1));
38019 if (SWIG_arg_fail(2)) SWIG_fail;
38020 }
38021 {
38022 PyThreadState* __tstate = wxPyBeginAllowThreads();
38023 result = ((wxItemContainer const *)arg1)->GetString(arg2);
38024
38025 wxPyEndAllowThreads(__tstate);
38026 if (PyErr_Occurred()) SWIG_fail;
38027 }
38028 {
38029 #if wxUSE_UNICODE
38030 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38031 #else
38032 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38033 #endif
38034 }
38035 return resultobj;
38036 fail:
38037 return NULL;
38038 }
38039
38040
38041 static PyObject *_wrap_ItemContainer_GetStrings(PyObject *, PyObject *args, PyObject *kwargs) {
38042 PyObject *resultobj;
38043 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38044 wxArrayString result;
38045 PyObject * obj0 = 0 ;
38046 char *kwnames[] = {
38047 (char *) "self", NULL
38048 };
38049
38050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStrings",kwnames,&obj0)) goto fail;
38051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38052 if (SWIG_arg_fail(1)) SWIG_fail;
38053 {
38054 PyThreadState* __tstate = wxPyBeginAllowThreads();
38055 result = ((wxItemContainer const *)arg1)->GetStrings();
38056
38057 wxPyEndAllowThreads(__tstate);
38058 if (PyErr_Occurred()) SWIG_fail;
38059 }
38060 {
38061 resultobj = wxArrayString2PyList_helper(result);
38062 }
38063 return resultobj;
38064 fail:
38065 return NULL;
38066 }
38067
38068
38069 static PyObject *_wrap_ItemContainer_SetString(PyObject *, PyObject *args, PyObject *kwargs) {
38070 PyObject *resultobj;
38071 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38072 int arg2 ;
38073 wxString *arg3 = 0 ;
38074 bool temp3 = false ;
38075 PyObject * obj0 = 0 ;
38076 PyObject * obj1 = 0 ;
38077 PyObject * obj2 = 0 ;
38078 char *kwnames[] = {
38079 (char *) "self",(char *) "n",(char *) "s", NULL
38080 };
38081
38082 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) goto fail;
38083 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38084 if (SWIG_arg_fail(1)) SWIG_fail;
38085 {
38086 arg2 = (int)(SWIG_As_int(obj1));
38087 if (SWIG_arg_fail(2)) SWIG_fail;
38088 }
38089 {
38090 arg3 = wxString_in_helper(obj2);
38091 if (arg3 == NULL) SWIG_fail;
38092 temp3 = true;
38093 }
38094 {
38095 PyThreadState* __tstate = wxPyBeginAllowThreads();
38096 (arg1)->SetString(arg2,(wxString const &)*arg3);
38097
38098 wxPyEndAllowThreads(__tstate);
38099 if (PyErr_Occurred()) SWIG_fail;
38100 }
38101 Py_INCREF(Py_None); resultobj = Py_None;
38102 {
38103 if (temp3)
38104 delete arg3;
38105 }
38106 return resultobj;
38107 fail:
38108 {
38109 if (temp3)
38110 delete arg3;
38111 }
38112 return NULL;
38113 }
38114
38115
38116 static PyObject *_wrap_ItemContainer_FindString(PyObject *, PyObject *args, PyObject *kwargs) {
38117 PyObject *resultobj;
38118 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38119 wxString *arg2 = 0 ;
38120 int result;
38121 bool temp2 = false ;
38122 PyObject * obj0 = 0 ;
38123 PyObject * obj1 = 0 ;
38124 char *kwnames[] = {
38125 (char *) "self",(char *) "s", NULL
38126 };
38127
38128 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) goto fail;
38129 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38130 if (SWIG_arg_fail(1)) SWIG_fail;
38131 {
38132 arg2 = wxString_in_helper(obj1);
38133 if (arg2 == NULL) SWIG_fail;
38134 temp2 = true;
38135 }
38136 {
38137 PyThreadState* __tstate = wxPyBeginAllowThreads();
38138 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
38139
38140 wxPyEndAllowThreads(__tstate);
38141 if (PyErr_Occurred()) SWIG_fail;
38142 }
38143 {
38144 resultobj = SWIG_From_int((int)(result));
38145 }
38146 {
38147 if (temp2)
38148 delete arg2;
38149 }
38150 return resultobj;
38151 fail:
38152 {
38153 if (temp2)
38154 delete arg2;
38155 }
38156 return NULL;
38157 }
38158
38159
38160 static PyObject *_wrap_ItemContainer_SetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38161 PyObject *resultobj;
38162 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38163 int arg2 ;
38164 PyObject * obj0 = 0 ;
38165 PyObject * obj1 = 0 ;
38166 char *kwnames[] = {
38167 (char *) "self",(char *) "n", NULL
38168 };
38169
38170 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) goto fail;
38171 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38172 if (SWIG_arg_fail(1)) SWIG_fail;
38173 {
38174 arg2 = (int)(SWIG_As_int(obj1));
38175 if (SWIG_arg_fail(2)) SWIG_fail;
38176 }
38177 {
38178 PyThreadState* __tstate = wxPyBeginAllowThreads();
38179 (arg1)->SetSelection(arg2);
38180
38181 wxPyEndAllowThreads(__tstate);
38182 if (PyErr_Occurred()) SWIG_fail;
38183 }
38184 Py_INCREF(Py_None); resultobj = Py_None;
38185 return resultobj;
38186 fail:
38187 return NULL;
38188 }
38189
38190
38191 static PyObject *_wrap_ItemContainer_GetSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38192 PyObject *resultobj;
38193 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38194 int result;
38195 PyObject * obj0 = 0 ;
38196 char *kwnames[] = {
38197 (char *) "self", NULL
38198 };
38199
38200 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetSelection",kwnames,&obj0)) goto fail;
38201 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38202 if (SWIG_arg_fail(1)) SWIG_fail;
38203 {
38204 PyThreadState* __tstate = wxPyBeginAllowThreads();
38205 result = (int)((wxItemContainer const *)arg1)->GetSelection();
38206
38207 wxPyEndAllowThreads(__tstate);
38208 if (PyErr_Occurred()) SWIG_fail;
38209 }
38210 {
38211 resultobj = SWIG_From_int((int)(result));
38212 }
38213 return resultobj;
38214 fail:
38215 return NULL;
38216 }
38217
38218
38219 static PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38220 PyObject *resultobj;
38221 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38222 wxString *arg2 = 0 ;
38223 bool result;
38224 bool temp2 = false ;
38225 PyObject * obj0 = 0 ;
38226 PyObject * obj1 = 0 ;
38227 char *kwnames[] = {
38228 (char *) "self",(char *) "s", NULL
38229 };
38230
38231 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) goto fail;
38232 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38233 if (SWIG_arg_fail(1)) SWIG_fail;
38234 {
38235 arg2 = wxString_in_helper(obj1);
38236 if (arg2 == NULL) SWIG_fail;
38237 temp2 = true;
38238 }
38239 {
38240 PyThreadState* __tstate = wxPyBeginAllowThreads();
38241 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
38242
38243 wxPyEndAllowThreads(__tstate);
38244 if (PyErr_Occurred()) SWIG_fail;
38245 }
38246 {
38247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38248 }
38249 {
38250 if (temp2)
38251 delete arg2;
38252 }
38253 return resultobj;
38254 fail:
38255 {
38256 if (temp2)
38257 delete arg2;
38258 }
38259 return NULL;
38260 }
38261
38262
38263 static PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *, PyObject *args, PyObject *kwargs) {
38264 PyObject *resultobj;
38265 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38266 wxString result;
38267 PyObject * obj0 = 0 ;
38268 char *kwnames[] = {
38269 (char *) "self", NULL
38270 };
38271
38272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ItemContainer_GetStringSelection",kwnames,&obj0)) goto fail;
38273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38274 if (SWIG_arg_fail(1)) SWIG_fail;
38275 {
38276 PyThreadState* __tstate = wxPyBeginAllowThreads();
38277 result = ((wxItemContainer const *)arg1)->GetStringSelection();
38278
38279 wxPyEndAllowThreads(__tstate);
38280 if (PyErr_Occurred()) SWIG_fail;
38281 }
38282 {
38283 #if wxUSE_UNICODE
38284 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
38285 #else
38286 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
38287 #endif
38288 }
38289 return resultobj;
38290 fail:
38291 return NULL;
38292 }
38293
38294
38295 static PyObject *_wrap_ItemContainer_Select(PyObject *, PyObject *args, PyObject *kwargs) {
38296 PyObject *resultobj;
38297 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
38298 int arg2 ;
38299 PyObject * obj0 = 0 ;
38300 PyObject * obj1 = 0 ;
38301 char *kwnames[] = {
38302 (char *) "self",(char *) "n", NULL
38303 };
38304
38305 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) goto fail;
38306 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxItemContainer, SWIG_POINTER_EXCEPTION | 0);
38307 if (SWIG_arg_fail(1)) SWIG_fail;
38308 {
38309 arg2 = (int)(SWIG_As_int(obj1));
38310 if (SWIG_arg_fail(2)) SWIG_fail;
38311 }
38312 {
38313 PyThreadState* __tstate = wxPyBeginAllowThreads();
38314 (arg1)->Select(arg2);
38315
38316 wxPyEndAllowThreads(__tstate);
38317 if (PyErr_Occurred()) SWIG_fail;
38318 }
38319 Py_INCREF(Py_None); resultobj = Py_None;
38320 return resultobj;
38321 fail:
38322 return NULL;
38323 }
38324
38325
38326 static PyObject * ItemContainer_swigregister(PyObject *, PyObject *args) {
38327 PyObject *obj;
38328 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38329 SWIG_TypeClientData(SWIGTYPE_p_wxItemContainer, obj);
38330 Py_INCREF(obj);
38331 return Py_BuildValue((char *)"");
38332 }
38333 static PyObject * ControlWithItems_swigregister(PyObject *, PyObject *args) {
38334 PyObject *obj;
38335 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
38336 SWIG_TypeClientData(SWIGTYPE_p_wxControlWithItems, obj);
38337 Py_INCREF(obj);
38338 return Py_BuildValue((char *)"");
38339 }
38340 static PyObject *_wrap_new_SizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
38341 PyObject *resultobj;
38342 wxSizerItem *result;
38343 char *kwnames[] = {
38344 NULL
38345 };
38346
38347 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_SizerItem",kwnames)) goto fail;
38348 {
38349 PyThreadState* __tstate = wxPyBeginAllowThreads();
38350 result = (wxSizerItem *)new wxSizerItem();
38351
38352 wxPyEndAllowThreads(__tstate);
38353 if (PyErr_Occurred()) SWIG_fail;
38354 }
38355 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38356 return resultobj;
38357 fail:
38358 return NULL;
38359 }
38360
38361
38362 static PyObject *_wrap_new_SizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38363 PyObject *resultobj;
38364 wxWindow *arg1 = (wxWindow *) 0 ;
38365 int arg2 ;
38366 int arg3 ;
38367 int arg4 ;
38368 PyObject *arg5 = (PyObject *) NULL ;
38369 wxSizerItem *result;
38370 PyObject * obj0 = 0 ;
38371 PyObject * obj1 = 0 ;
38372 PyObject * obj2 = 0 ;
38373 PyObject * obj3 = 0 ;
38374 PyObject * obj4 = 0 ;
38375 char *kwnames[] = {
38376 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38377 };
38378
38379 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38380 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
38381 if (SWIG_arg_fail(1)) SWIG_fail;
38382 {
38383 arg2 = (int)(SWIG_As_int(obj1));
38384 if (SWIG_arg_fail(2)) SWIG_fail;
38385 }
38386 {
38387 arg3 = (int)(SWIG_As_int(obj2));
38388 if (SWIG_arg_fail(3)) SWIG_fail;
38389 }
38390 {
38391 arg4 = (int)(SWIG_As_int(obj3));
38392 if (SWIG_arg_fail(4)) SWIG_fail;
38393 }
38394 if (obj4) {
38395 arg5 = obj4;
38396 }
38397 {
38398 PyThreadState* __tstate = wxPyBeginAllowThreads();
38399 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38400
38401 wxPyEndAllowThreads(__tstate);
38402 if (PyErr_Occurred()) SWIG_fail;
38403 }
38404 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38405 return resultobj;
38406 fail:
38407 return NULL;
38408 }
38409
38410
38411 static PyObject *_wrap_new_SizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38412 PyObject *resultobj;
38413 int arg1 ;
38414 int arg2 ;
38415 int arg3 ;
38416 int arg4 ;
38417 int arg5 ;
38418 PyObject *arg6 = (PyObject *) NULL ;
38419 wxSizerItem *result;
38420 PyObject * obj0 = 0 ;
38421 PyObject * obj1 = 0 ;
38422 PyObject * obj2 = 0 ;
38423 PyObject * obj3 = 0 ;
38424 PyObject * obj4 = 0 ;
38425 PyObject * obj5 = 0 ;
38426 char *kwnames[] = {
38427 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38428 };
38429
38430 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
38431 {
38432 arg1 = (int)(SWIG_As_int(obj0));
38433 if (SWIG_arg_fail(1)) SWIG_fail;
38434 }
38435 {
38436 arg2 = (int)(SWIG_As_int(obj1));
38437 if (SWIG_arg_fail(2)) SWIG_fail;
38438 }
38439 {
38440 arg3 = (int)(SWIG_As_int(obj2));
38441 if (SWIG_arg_fail(3)) SWIG_fail;
38442 }
38443 {
38444 arg4 = (int)(SWIG_As_int(obj3));
38445 if (SWIG_arg_fail(4)) SWIG_fail;
38446 }
38447 {
38448 arg5 = (int)(SWIG_As_int(obj4));
38449 if (SWIG_arg_fail(5)) SWIG_fail;
38450 }
38451 if (obj5) {
38452 arg6 = obj5;
38453 }
38454 {
38455 PyThreadState* __tstate = wxPyBeginAllowThreads();
38456 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
38457
38458 wxPyEndAllowThreads(__tstate);
38459 if (PyErr_Occurred()) SWIG_fail;
38460 }
38461 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38462 return resultobj;
38463 fail:
38464 return NULL;
38465 }
38466
38467
38468 static PyObject *_wrap_new_SizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38469 PyObject *resultobj;
38470 wxSizer *arg1 = (wxSizer *) 0 ;
38471 int arg2 ;
38472 int arg3 ;
38473 int arg4 ;
38474 PyObject *arg5 = (PyObject *) NULL ;
38475 wxSizerItem *result;
38476 PyObject * obj0 = 0 ;
38477 PyObject * obj1 = 0 ;
38478 PyObject * obj2 = 0 ;
38479 PyObject * obj3 = 0 ;
38480 PyObject * obj4 = 0 ;
38481 char *kwnames[] = {
38482 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
38483 };
38484
38485 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
38486 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
38487 if (SWIG_arg_fail(1)) SWIG_fail;
38488 {
38489 arg2 = (int)(SWIG_As_int(obj1));
38490 if (SWIG_arg_fail(2)) SWIG_fail;
38491 }
38492 {
38493 arg3 = (int)(SWIG_As_int(obj2));
38494 if (SWIG_arg_fail(3)) SWIG_fail;
38495 }
38496 {
38497 arg4 = (int)(SWIG_As_int(obj3));
38498 if (SWIG_arg_fail(4)) SWIG_fail;
38499 }
38500 if (obj4) {
38501 arg5 = obj4;
38502 }
38503 {
38504 PyThreadState* __tstate = wxPyBeginAllowThreads();
38505 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
38506
38507 wxPyEndAllowThreads(__tstate);
38508 if (PyErr_Occurred()) SWIG_fail;
38509 }
38510 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 1);
38511 return resultobj;
38512 fail:
38513 return NULL;
38514 }
38515
38516
38517 static PyObject *_wrap_SizerItem_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
38518 PyObject *resultobj;
38519 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38520 PyObject * obj0 = 0 ;
38521 char *kwnames[] = {
38522 (char *) "self", NULL
38523 };
38524
38525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DeleteWindows",kwnames,&obj0)) goto fail;
38526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38527 if (SWIG_arg_fail(1)) SWIG_fail;
38528 {
38529 PyThreadState* __tstate = wxPyBeginAllowThreads();
38530 (arg1)->DeleteWindows();
38531
38532 wxPyEndAllowThreads(__tstate);
38533 if (PyErr_Occurred()) SWIG_fail;
38534 }
38535 Py_INCREF(Py_None); resultobj = Py_None;
38536 return resultobj;
38537 fail:
38538 return NULL;
38539 }
38540
38541
38542 static PyObject *_wrap_SizerItem_DetachSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38543 PyObject *resultobj;
38544 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38545 PyObject * obj0 = 0 ;
38546 char *kwnames[] = {
38547 (char *) "self", NULL
38548 };
38549
38550 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_DetachSizer",kwnames,&obj0)) goto fail;
38551 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38552 if (SWIG_arg_fail(1)) SWIG_fail;
38553 {
38554 PyThreadState* __tstate = wxPyBeginAllowThreads();
38555 (arg1)->DetachSizer();
38556
38557 wxPyEndAllowThreads(__tstate);
38558 if (PyErr_Occurred()) SWIG_fail;
38559 }
38560 Py_INCREF(Py_None); resultobj = Py_None;
38561 return resultobj;
38562 fail:
38563 return NULL;
38564 }
38565
38566
38567 static PyObject *_wrap_SizerItem_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
38568 PyObject *resultobj;
38569 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38570 wxSize result;
38571 PyObject * obj0 = 0 ;
38572 char *kwnames[] = {
38573 (char *) "self", NULL
38574 };
38575
38576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSize",kwnames,&obj0)) goto fail;
38577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38578 if (SWIG_arg_fail(1)) SWIG_fail;
38579 {
38580 PyThreadState* __tstate = wxPyBeginAllowThreads();
38581 result = (arg1)->GetSize();
38582
38583 wxPyEndAllowThreads(__tstate);
38584 if (PyErr_Occurred()) SWIG_fail;
38585 }
38586 {
38587 wxSize * resultptr;
38588 resultptr = new wxSize((wxSize &)(result));
38589 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38590 }
38591 return resultobj;
38592 fail:
38593 return NULL;
38594 }
38595
38596
38597 static PyObject *_wrap_SizerItem_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
38598 PyObject *resultobj;
38599 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38600 wxSize result;
38601 PyObject * obj0 = 0 ;
38602 char *kwnames[] = {
38603 (char *) "self", NULL
38604 };
38605
38606 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_CalcMin",kwnames,&obj0)) goto fail;
38607 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38608 if (SWIG_arg_fail(1)) SWIG_fail;
38609 {
38610 PyThreadState* __tstate = wxPyBeginAllowThreads();
38611 result = (arg1)->CalcMin();
38612
38613 wxPyEndAllowThreads(__tstate);
38614 if (PyErr_Occurred()) SWIG_fail;
38615 }
38616 {
38617 wxSize * resultptr;
38618 resultptr = new wxSize((wxSize &)(result));
38619 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38620 }
38621 return resultobj;
38622 fail:
38623 return NULL;
38624 }
38625
38626
38627 static PyObject *_wrap_SizerItem_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
38628 PyObject *resultobj;
38629 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38630 wxPoint arg2 ;
38631 wxSize arg3 ;
38632 PyObject * obj0 = 0 ;
38633 PyObject * obj1 = 0 ;
38634 PyObject * obj2 = 0 ;
38635 char *kwnames[] = {
38636 (char *) "self",(char *) "pos",(char *) "size", NULL
38637 };
38638
38639 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) goto fail;
38640 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38641 if (SWIG_arg_fail(1)) SWIG_fail;
38642 {
38643 wxPoint * argp;
38644 SWIG_Python_ConvertPtr(obj1, (void **)&argp, SWIGTYPE_p_wxPoint, SWIG_POINTER_EXCEPTION);
38645 if (SWIG_arg_fail(2)) SWIG_fail;
38646 if (argp == NULL) {
38647 SWIG_null_ref("wxPoint");
38648 }
38649 if (SWIG_arg_fail(2)) SWIG_fail;
38650 arg2 = *argp;
38651 }
38652 {
38653 wxSize * argp;
38654 SWIG_Python_ConvertPtr(obj2, (void **)&argp, SWIGTYPE_p_wxSize, SWIG_POINTER_EXCEPTION);
38655 if (SWIG_arg_fail(3)) SWIG_fail;
38656 if (argp == NULL) {
38657 SWIG_null_ref("wxSize");
38658 }
38659 if (SWIG_arg_fail(3)) SWIG_fail;
38660 arg3 = *argp;
38661 }
38662 {
38663 PyThreadState* __tstate = wxPyBeginAllowThreads();
38664 (arg1)->SetDimension(arg2,arg3);
38665
38666 wxPyEndAllowThreads(__tstate);
38667 if (PyErr_Occurred()) SWIG_fail;
38668 }
38669 Py_INCREF(Py_None); resultobj = Py_None;
38670 return resultobj;
38671 fail:
38672 return NULL;
38673 }
38674
38675
38676 static PyObject *_wrap_SizerItem_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
38677 PyObject *resultobj;
38678 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38679 wxSize result;
38680 PyObject * obj0 = 0 ;
38681 char *kwnames[] = {
38682 (char *) "self", NULL
38683 };
38684
38685 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSize",kwnames,&obj0)) goto fail;
38686 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38687 if (SWIG_arg_fail(1)) SWIG_fail;
38688 {
38689 PyThreadState* __tstate = wxPyBeginAllowThreads();
38690 result = (arg1)->GetMinSize();
38691
38692 wxPyEndAllowThreads(__tstate);
38693 if (PyErr_Occurred()) SWIG_fail;
38694 }
38695 {
38696 wxSize * resultptr;
38697 resultptr = new wxSize((wxSize &)(result));
38698 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38699 }
38700 return resultobj;
38701 fail:
38702 return NULL;
38703 }
38704
38705
38706 static PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *, PyObject *args, PyObject *kwargs) {
38707 PyObject *resultobj;
38708 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38709 wxSize result;
38710 PyObject * obj0 = 0 ;
38711 char *kwnames[] = {
38712 (char *) "self", NULL
38713 };
38714
38715 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetMinSizeWithBorder",kwnames,&obj0)) goto fail;
38716 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38717 if (SWIG_arg_fail(1)) SWIG_fail;
38718 {
38719 PyThreadState* __tstate = wxPyBeginAllowThreads();
38720 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
38721
38722 wxPyEndAllowThreads(__tstate);
38723 if (PyErr_Occurred()) SWIG_fail;
38724 }
38725 {
38726 wxSize * resultptr;
38727 resultptr = new wxSize((wxSize &)(result));
38728 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
38729 }
38730 return resultobj;
38731 fail:
38732 return NULL;
38733 }
38734
38735
38736 static PyObject *_wrap_SizerItem_SetInitSize(PyObject *, PyObject *args, PyObject *kwargs) {
38737 PyObject *resultobj;
38738 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38739 int arg2 ;
38740 int arg3 ;
38741 PyObject * obj0 = 0 ;
38742 PyObject * obj1 = 0 ;
38743 PyObject * obj2 = 0 ;
38744 char *kwnames[] = {
38745 (char *) "self",(char *) "x",(char *) "y", NULL
38746 };
38747
38748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
38749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38750 if (SWIG_arg_fail(1)) SWIG_fail;
38751 {
38752 arg2 = (int)(SWIG_As_int(obj1));
38753 if (SWIG_arg_fail(2)) SWIG_fail;
38754 }
38755 {
38756 arg3 = (int)(SWIG_As_int(obj2));
38757 if (SWIG_arg_fail(3)) SWIG_fail;
38758 }
38759 {
38760 PyThreadState* __tstate = wxPyBeginAllowThreads();
38761 (arg1)->SetInitSize(arg2,arg3);
38762
38763 wxPyEndAllowThreads(__tstate);
38764 if (PyErr_Occurred()) SWIG_fail;
38765 }
38766 Py_INCREF(Py_None); resultobj = Py_None;
38767 return resultobj;
38768 fail:
38769 return NULL;
38770 }
38771
38772
38773 static PyObject *_wrap_SizerItem_SetRatioWH(PyObject *, PyObject *args, PyObject *kwargs) {
38774 PyObject *resultobj;
38775 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38776 int arg2 ;
38777 int arg3 ;
38778 PyObject * obj0 = 0 ;
38779 PyObject * obj1 = 0 ;
38780 PyObject * obj2 = 0 ;
38781 char *kwnames[] = {
38782 (char *) "self",(char *) "width",(char *) "height", NULL
38783 };
38784
38785 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) goto fail;
38786 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38787 if (SWIG_arg_fail(1)) SWIG_fail;
38788 {
38789 arg2 = (int)(SWIG_As_int(obj1));
38790 if (SWIG_arg_fail(2)) SWIG_fail;
38791 }
38792 {
38793 arg3 = (int)(SWIG_As_int(obj2));
38794 if (SWIG_arg_fail(3)) SWIG_fail;
38795 }
38796 {
38797 PyThreadState* __tstate = wxPyBeginAllowThreads();
38798 (arg1)->SetRatio(arg2,arg3);
38799
38800 wxPyEndAllowThreads(__tstate);
38801 if (PyErr_Occurred()) SWIG_fail;
38802 }
38803 Py_INCREF(Py_None); resultobj = Py_None;
38804 return resultobj;
38805 fail:
38806 return NULL;
38807 }
38808
38809
38810 static PyObject *_wrap_SizerItem_SetRatioSize(PyObject *, PyObject *args, PyObject *kwargs) {
38811 PyObject *resultobj;
38812 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38813 wxSize *arg2 = 0 ;
38814 wxSize temp2 ;
38815 PyObject * obj0 = 0 ;
38816 PyObject * obj1 = 0 ;
38817 char *kwnames[] = {
38818 (char *) "self",(char *) "size", NULL
38819 };
38820
38821 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) goto fail;
38822 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38823 if (SWIG_arg_fail(1)) SWIG_fail;
38824 {
38825 arg2 = &temp2;
38826 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
38827 }
38828 {
38829 PyThreadState* __tstate = wxPyBeginAllowThreads();
38830 (arg1)->SetRatio((wxSize const &)*arg2);
38831
38832 wxPyEndAllowThreads(__tstate);
38833 if (PyErr_Occurred()) SWIG_fail;
38834 }
38835 Py_INCREF(Py_None); resultobj = Py_None;
38836 return resultobj;
38837 fail:
38838 return NULL;
38839 }
38840
38841
38842 static PyObject *_wrap_SizerItem_SetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38843 PyObject *resultobj;
38844 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38845 float arg2 ;
38846 PyObject * obj0 = 0 ;
38847 PyObject * obj1 = 0 ;
38848 char *kwnames[] = {
38849 (char *) "self",(char *) "ratio", NULL
38850 };
38851
38852 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) goto fail;
38853 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38854 if (SWIG_arg_fail(1)) SWIG_fail;
38855 {
38856 arg2 = (float)(SWIG_As_float(obj1));
38857 if (SWIG_arg_fail(2)) SWIG_fail;
38858 }
38859 {
38860 PyThreadState* __tstate = wxPyBeginAllowThreads();
38861 (arg1)->SetRatio(arg2);
38862
38863 wxPyEndAllowThreads(__tstate);
38864 if (PyErr_Occurred()) SWIG_fail;
38865 }
38866 Py_INCREF(Py_None); resultobj = Py_None;
38867 return resultobj;
38868 fail:
38869 return NULL;
38870 }
38871
38872
38873 static PyObject *_wrap_SizerItem_GetRatio(PyObject *, PyObject *args, PyObject *kwargs) {
38874 PyObject *resultobj;
38875 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38876 float result;
38877 PyObject * obj0 = 0 ;
38878 char *kwnames[] = {
38879 (char *) "self", NULL
38880 };
38881
38882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRatio",kwnames,&obj0)) goto fail;
38883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38884 if (SWIG_arg_fail(1)) SWIG_fail;
38885 {
38886 PyThreadState* __tstate = wxPyBeginAllowThreads();
38887 result = (float)(arg1)->GetRatio();
38888
38889 wxPyEndAllowThreads(__tstate);
38890 if (PyErr_Occurred()) SWIG_fail;
38891 }
38892 {
38893 resultobj = SWIG_From_float((float)(result));
38894 }
38895 return resultobj;
38896 fail:
38897 return NULL;
38898 }
38899
38900
38901 static PyObject *_wrap_SizerItem_GetRect(PyObject *, PyObject *args, PyObject *kwargs) {
38902 PyObject *resultobj;
38903 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38904 wxRect result;
38905 PyObject * obj0 = 0 ;
38906 char *kwnames[] = {
38907 (char *) "self", NULL
38908 };
38909
38910 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetRect",kwnames,&obj0)) goto fail;
38911 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38912 if (SWIG_arg_fail(1)) SWIG_fail;
38913 {
38914 PyThreadState* __tstate = wxPyBeginAllowThreads();
38915 result = (arg1)->GetRect();
38916
38917 wxPyEndAllowThreads(__tstate);
38918 if (PyErr_Occurred()) SWIG_fail;
38919 }
38920 {
38921 wxRect * resultptr;
38922 resultptr = new wxRect((wxRect &)(result));
38923 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxRect, 1);
38924 }
38925 return resultobj;
38926 fail:
38927 return NULL;
38928 }
38929
38930
38931 static PyObject *_wrap_SizerItem_IsWindow(PyObject *, PyObject *args, PyObject *kwargs) {
38932 PyObject *resultobj;
38933 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38934 bool result;
38935 PyObject * obj0 = 0 ;
38936 char *kwnames[] = {
38937 (char *) "self", NULL
38938 };
38939
38940 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsWindow",kwnames,&obj0)) goto fail;
38941 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38942 if (SWIG_arg_fail(1)) SWIG_fail;
38943 {
38944 PyThreadState* __tstate = wxPyBeginAllowThreads();
38945 result = (bool)(arg1)->IsWindow();
38946
38947 wxPyEndAllowThreads(__tstate);
38948 if (PyErr_Occurred()) SWIG_fail;
38949 }
38950 {
38951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38952 }
38953 return resultobj;
38954 fail:
38955 return NULL;
38956 }
38957
38958
38959 static PyObject *_wrap_SizerItem_IsSizer(PyObject *, PyObject *args, PyObject *kwargs) {
38960 PyObject *resultobj;
38961 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38962 bool result;
38963 PyObject * obj0 = 0 ;
38964 char *kwnames[] = {
38965 (char *) "self", NULL
38966 };
38967
38968 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSizer",kwnames,&obj0)) goto fail;
38969 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38970 if (SWIG_arg_fail(1)) SWIG_fail;
38971 {
38972 PyThreadState* __tstate = wxPyBeginAllowThreads();
38973 result = (bool)(arg1)->IsSizer();
38974
38975 wxPyEndAllowThreads(__tstate);
38976 if (PyErr_Occurred()) SWIG_fail;
38977 }
38978 {
38979 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38980 }
38981 return resultobj;
38982 fail:
38983 return NULL;
38984 }
38985
38986
38987 static PyObject *_wrap_SizerItem_IsSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
38988 PyObject *resultobj;
38989 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
38990 bool result;
38991 PyObject * obj0 = 0 ;
38992 char *kwnames[] = {
38993 (char *) "self", NULL
38994 };
38995
38996 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsSpacer",kwnames,&obj0)) goto fail;
38997 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
38998 if (SWIG_arg_fail(1)) SWIG_fail;
38999 {
39000 PyThreadState* __tstate = wxPyBeginAllowThreads();
39001 result = (bool)(arg1)->IsSpacer();
39002
39003 wxPyEndAllowThreads(__tstate);
39004 if (PyErr_Occurred()) SWIG_fail;
39005 }
39006 {
39007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39008 }
39009 return resultobj;
39010 fail:
39011 return NULL;
39012 }
39013
39014
39015 static PyObject *_wrap_SizerItem_SetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39016 PyObject *resultobj;
39017 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39018 int arg2 ;
39019 PyObject * obj0 = 0 ;
39020 PyObject * obj1 = 0 ;
39021 char *kwnames[] = {
39022 (char *) "self",(char *) "proportion", NULL
39023 };
39024
39025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) goto fail;
39026 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39027 if (SWIG_arg_fail(1)) SWIG_fail;
39028 {
39029 arg2 = (int)(SWIG_As_int(obj1));
39030 if (SWIG_arg_fail(2)) SWIG_fail;
39031 }
39032 {
39033 PyThreadState* __tstate = wxPyBeginAllowThreads();
39034 (arg1)->SetProportion(arg2);
39035
39036 wxPyEndAllowThreads(__tstate);
39037 if (PyErr_Occurred()) SWIG_fail;
39038 }
39039 Py_INCREF(Py_None); resultobj = Py_None;
39040 return resultobj;
39041 fail:
39042 return NULL;
39043 }
39044
39045
39046 static PyObject *_wrap_SizerItem_GetProportion(PyObject *, PyObject *args, PyObject *kwargs) {
39047 PyObject *resultobj;
39048 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39049 int result;
39050 PyObject * obj0 = 0 ;
39051 char *kwnames[] = {
39052 (char *) "self", NULL
39053 };
39054
39055 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetProportion",kwnames,&obj0)) goto fail;
39056 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39057 if (SWIG_arg_fail(1)) SWIG_fail;
39058 {
39059 PyThreadState* __tstate = wxPyBeginAllowThreads();
39060 result = (int)(arg1)->GetProportion();
39061
39062 wxPyEndAllowThreads(__tstate);
39063 if (PyErr_Occurred()) SWIG_fail;
39064 }
39065 {
39066 resultobj = SWIG_From_int((int)(result));
39067 }
39068 return resultobj;
39069 fail:
39070 return NULL;
39071 }
39072
39073
39074 static PyObject *_wrap_SizerItem_SetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39075 PyObject *resultobj;
39076 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39077 int arg2 ;
39078 PyObject * obj0 = 0 ;
39079 PyObject * obj1 = 0 ;
39080 char *kwnames[] = {
39081 (char *) "self",(char *) "flag", NULL
39082 };
39083
39084 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) goto fail;
39085 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39086 if (SWIG_arg_fail(1)) SWIG_fail;
39087 {
39088 arg2 = (int)(SWIG_As_int(obj1));
39089 if (SWIG_arg_fail(2)) SWIG_fail;
39090 }
39091 {
39092 PyThreadState* __tstate = wxPyBeginAllowThreads();
39093 (arg1)->SetFlag(arg2);
39094
39095 wxPyEndAllowThreads(__tstate);
39096 if (PyErr_Occurred()) SWIG_fail;
39097 }
39098 Py_INCREF(Py_None); resultobj = Py_None;
39099 return resultobj;
39100 fail:
39101 return NULL;
39102 }
39103
39104
39105 static PyObject *_wrap_SizerItem_GetFlag(PyObject *, PyObject *args, PyObject *kwargs) {
39106 PyObject *resultobj;
39107 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39108 int result;
39109 PyObject * obj0 = 0 ;
39110 char *kwnames[] = {
39111 (char *) "self", NULL
39112 };
39113
39114 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetFlag",kwnames,&obj0)) goto fail;
39115 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39116 if (SWIG_arg_fail(1)) SWIG_fail;
39117 {
39118 PyThreadState* __tstate = wxPyBeginAllowThreads();
39119 result = (int)(arg1)->GetFlag();
39120
39121 wxPyEndAllowThreads(__tstate);
39122 if (PyErr_Occurred()) SWIG_fail;
39123 }
39124 {
39125 resultobj = SWIG_From_int((int)(result));
39126 }
39127 return resultobj;
39128 fail:
39129 return NULL;
39130 }
39131
39132
39133 static PyObject *_wrap_SizerItem_SetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39134 PyObject *resultobj;
39135 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39136 int arg2 ;
39137 PyObject * obj0 = 0 ;
39138 PyObject * obj1 = 0 ;
39139 char *kwnames[] = {
39140 (char *) "self",(char *) "border", NULL
39141 };
39142
39143 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) goto fail;
39144 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39145 if (SWIG_arg_fail(1)) SWIG_fail;
39146 {
39147 arg2 = (int)(SWIG_As_int(obj1));
39148 if (SWIG_arg_fail(2)) SWIG_fail;
39149 }
39150 {
39151 PyThreadState* __tstate = wxPyBeginAllowThreads();
39152 (arg1)->SetBorder(arg2);
39153
39154 wxPyEndAllowThreads(__tstate);
39155 if (PyErr_Occurred()) SWIG_fail;
39156 }
39157 Py_INCREF(Py_None); resultobj = Py_None;
39158 return resultobj;
39159 fail:
39160 return NULL;
39161 }
39162
39163
39164 static PyObject *_wrap_SizerItem_GetBorder(PyObject *, PyObject *args, PyObject *kwargs) {
39165 PyObject *resultobj;
39166 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39167 int result;
39168 PyObject * obj0 = 0 ;
39169 char *kwnames[] = {
39170 (char *) "self", NULL
39171 };
39172
39173 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetBorder",kwnames,&obj0)) goto fail;
39174 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39175 if (SWIG_arg_fail(1)) SWIG_fail;
39176 {
39177 PyThreadState* __tstate = wxPyBeginAllowThreads();
39178 result = (int)(arg1)->GetBorder();
39179
39180 wxPyEndAllowThreads(__tstate);
39181 if (PyErr_Occurred()) SWIG_fail;
39182 }
39183 {
39184 resultobj = SWIG_From_int((int)(result));
39185 }
39186 return resultobj;
39187 fail:
39188 return NULL;
39189 }
39190
39191
39192 static PyObject *_wrap_SizerItem_GetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39193 PyObject *resultobj;
39194 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39195 wxWindow *result;
39196 PyObject * obj0 = 0 ;
39197 char *kwnames[] = {
39198 (char *) "self", NULL
39199 };
39200
39201 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetWindow",kwnames,&obj0)) goto fail;
39202 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39203 if (SWIG_arg_fail(1)) SWIG_fail;
39204 {
39205 PyThreadState* __tstate = wxPyBeginAllowThreads();
39206 result = (wxWindow *)(arg1)->GetWindow();
39207
39208 wxPyEndAllowThreads(__tstate);
39209 if (PyErr_Occurred()) SWIG_fail;
39210 }
39211 {
39212 resultobj = wxPyMake_wxObject(result, 0);
39213 }
39214 return resultobj;
39215 fail:
39216 return NULL;
39217 }
39218
39219
39220 static PyObject *_wrap_SizerItem_SetWindow(PyObject *, PyObject *args, PyObject *kwargs) {
39221 PyObject *resultobj;
39222 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39223 wxWindow *arg2 = (wxWindow *) 0 ;
39224 PyObject * obj0 = 0 ;
39225 PyObject * obj1 = 0 ;
39226 char *kwnames[] = {
39227 (char *) "self",(char *) "window", NULL
39228 };
39229
39230 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) goto fail;
39231 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39232 if (SWIG_arg_fail(1)) SWIG_fail;
39233 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
39234 if (SWIG_arg_fail(2)) SWIG_fail;
39235 {
39236 PyThreadState* __tstate = wxPyBeginAllowThreads();
39237 (arg1)->SetWindow(arg2);
39238
39239 wxPyEndAllowThreads(__tstate);
39240 if (PyErr_Occurred()) SWIG_fail;
39241 }
39242 Py_INCREF(Py_None); resultobj = Py_None;
39243 return resultobj;
39244 fail:
39245 return NULL;
39246 }
39247
39248
39249 static PyObject *_wrap_SizerItem_GetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39250 PyObject *resultobj;
39251 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39252 wxSizer *result;
39253 PyObject * obj0 = 0 ;
39254 char *kwnames[] = {
39255 (char *) "self", NULL
39256 };
39257
39258 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSizer",kwnames,&obj0)) goto fail;
39259 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39260 if (SWIG_arg_fail(1)) SWIG_fail;
39261 {
39262 PyThreadState* __tstate = wxPyBeginAllowThreads();
39263 result = (wxSizer *)(arg1)->GetSizer();
39264
39265 wxPyEndAllowThreads(__tstate);
39266 if (PyErr_Occurred()) SWIG_fail;
39267 }
39268 {
39269 resultobj = wxPyMake_wxSizer(result, 0);
39270 }
39271 return resultobj;
39272 fail:
39273 return NULL;
39274 }
39275
39276
39277 static PyObject *_wrap_SizerItem_SetSizer(PyObject *, PyObject *args, PyObject *kwargs) {
39278 PyObject *resultobj;
39279 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39280 wxSizer *arg2 = (wxSizer *) 0 ;
39281 PyObject * obj0 = 0 ;
39282 PyObject * obj1 = 0 ;
39283 char *kwnames[] = {
39284 (char *) "self",(char *) "sizer", NULL
39285 };
39286
39287 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) goto fail;
39288 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39289 if (SWIG_arg_fail(1)) SWIG_fail;
39290 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39291 if (SWIG_arg_fail(2)) SWIG_fail;
39292 {
39293 PyThreadState* __tstate = wxPyBeginAllowThreads();
39294 (arg1)->SetSizer(arg2);
39295
39296 wxPyEndAllowThreads(__tstate);
39297 if (PyErr_Occurred()) SWIG_fail;
39298 }
39299 Py_INCREF(Py_None); resultobj = Py_None;
39300 return resultobj;
39301 fail:
39302 return NULL;
39303 }
39304
39305
39306 static PyObject *_wrap_SizerItem_GetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39307 PyObject *resultobj;
39308 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39309 wxSize *result;
39310 PyObject * obj0 = 0 ;
39311 char *kwnames[] = {
39312 (char *) "self", NULL
39313 };
39314
39315 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetSpacer",kwnames,&obj0)) goto fail;
39316 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39317 if (SWIG_arg_fail(1)) SWIG_fail;
39318 {
39319 PyThreadState* __tstate = wxPyBeginAllowThreads();
39320 {
39321 wxSize const &_result_ref = (arg1)->GetSpacer();
39322 result = (wxSize *) &_result_ref;
39323 }
39324
39325 wxPyEndAllowThreads(__tstate);
39326 if (PyErr_Occurred()) SWIG_fail;
39327 }
39328 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSize, 0);
39329 return resultobj;
39330 fail:
39331 return NULL;
39332 }
39333
39334
39335 static PyObject *_wrap_SizerItem_SetSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
39336 PyObject *resultobj;
39337 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39338 wxSize *arg2 = 0 ;
39339 wxSize temp2 ;
39340 PyObject * obj0 = 0 ;
39341 PyObject * obj1 = 0 ;
39342 char *kwnames[] = {
39343 (char *) "self",(char *) "size", NULL
39344 };
39345
39346 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) goto fail;
39347 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39348 if (SWIG_arg_fail(1)) SWIG_fail;
39349 {
39350 arg2 = &temp2;
39351 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39352 }
39353 {
39354 PyThreadState* __tstate = wxPyBeginAllowThreads();
39355 (arg1)->SetSpacer((wxSize const &)*arg2);
39356
39357 wxPyEndAllowThreads(__tstate);
39358 if (PyErr_Occurred()) SWIG_fail;
39359 }
39360 Py_INCREF(Py_None); resultobj = Py_None;
39361 return resultobj;
39362 fail:
39363 return NULL;
39364 }
39365
39366
39367 static PyObject *_wrap_SizerItem_Show(PyObject *, PyObject *args, PyObject *kwargs) {
39368 PyObject *resultobj;
39369 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39370 bool arg2 ;
39371 PyObject * obj0 = 0 ;
39372 PyObject * obj1 = 0 ;
39373 char *kwnames[] = {
39374 (char *) "self",(char *) "show", NULL
39375 };
39376
39377 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) goto fail;
39378 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39379 if (SWIG_arg_fail(1)) SWIG_fail;
39380 {
39381 arg2 = (bool)(SWIG_As_bool(obj1));
39382 if (SWIG_arg_fail(2)) SWIG_fail;
39383 }
39384 {
39385 PyThreadState* __tstate = wxPyBeginAllowThreads();
39386 (arg1)->Show(arg2);
39387
39388 wxPyEndAllowThreads(__tstate);
39389 if (PyErr_Occurred()) SWIG_fail;
39390 }
39391 Py_INCREF(Py_None); resultobj = Py_None;
39392 return resultobj;
39393 fail:
39394 return NULL;
39395 }
39396
39397
39398 static PyObject *_wrap_SizerItem_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
39399 PyObject *resultobj;
39400 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39401 bool result;
39402 PyObject * obj0 = 0 ;
39403 char *kwnames[] = {
39404 (char *) "self", NULL
39405 };
39406
39407 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_IsShown",kwnames,&obj0)) goto fail;
39408 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39409 if (SWIG_arg_fail(1)) SWIG_fail;
39410 {
39411 PyThreadState* __tstate = wxPyBeginAllowThreads();
39412 result = (bool)(arg1)->IsShown();
39413
39414 wxPyEndAllowThreads(__tstate);
39415 if (PyErr_Occurred()) SWIG_fail;
39416 }
39417 {
39418 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39419 }
39420 return resultobj;
39421 fail:
39422 return NULL;
39423 }
39424
39425
39426 static PyObject *_wrap_SizerItem_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
39427 PyObject *resultobj;
39428 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39429 wxPoint result;
39430 PyObject * obj0 = 0 ;
39431 char *kwnames[] = {
39432 (char *) "self", NULL
39433 };
39434
39435 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetPosition",kwnames,&obj0)) goto fail;
39436 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39437 if (SWIG_arg_fail(1)) SWIG_fail;
39438 {
39439 PyThreadState* __tstate = wxPyBeginAllowThreads();
39440 result = (arg1)->GetPosition();
39441
39442 wxPyEndAllowThreads(__tstate);
39443 if (PyErr_Occurred()) SWIG_fail;
39444 }
39445 {
39446 wxPoint * resultptr;
39447 resultptr = new wxPoint((wxPoint &)(result));
39448 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
39449 }
39450 return resultobj;
39451 fail:
39452 return NULL;
39453 }
39454
39455
39456 static PyObject *_wrap_SizerItem_GetUserData(PyObject *, PyObject *args, PyObject *kwargs) {
39457 PyObject *resultobj;
39458 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
39459 PyObject *result;
39460 PyObject * obj0 = 0 ;
39461 char *kwnames[] = {
39462 (char *) "self", NULL
39463 };
39464
39465 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SizerItem_GetUserData",kwnames,&obj0)) goto fail;
39466 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39467 if (SWIG_arg_fail(1)) SWIG_fail;
39468 {
39469 PyThreadState* __tstate = wxPyBeginAllowThreads();
39470 result = (PyObject *)wxSizerItem_GetUserData(arg1);
39471
39472 wxPyEndAllowThreads(__tstate);
39473 if (PyErr_Occurred()) SWIG_fail;
39474 }
39475 resultobj = result;
39476 return resultobj;
39477 fail:
39478 return NULL;
39479 }
39480
39481
39482 static PyObject * SizerItem_swigregister(PyObject *, PyObject *args) {
39483 PyObject *obj;
39484 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
39485 SWIG_TypeClientData(SWIGTYPE_p_wxSizerItem, obj);
39486 Py_INCREF(obj);
39487 return Py_BuildValue((char *)"");
39488 }
39489 static PyObject *_wrap_Sizer__setOORInfo(PyObject *, PyObject *args, PyObject *kwargs) {
39490 PyObject *resultobj;
39491 wxSizer *arg1 = (wxSizer *) 0 ;
39492 PyObject *arg2 = (PyObject *) 0 ;
39493 PyObject * obj0 = 0 ;
39494 PyObject * obj1 = 0 ;
39495 char *kwnames[] = {
39496 (char *) "self",(char *) "_self", NULL
39497 };
39498
39499 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) goto fail;
39500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39501 if (SWIG_arg_fail(1)) SWIG_fail;
39502 arg2 = obj1;
39503 {
39504 PyThreadState* __tstate = wxPyBeginAllowThreads();
39505 wxSizer__setOORInfo(arg1,arg2);
39506
39507 wxPyEndAllowThreads(__tstate);
39508 if (PyErr_Occurred()) SWIG_fail;
39509 }
39510 Py_INCREF(Py_None); resultobj = Py_None;
39511 return resultobj;
39512 fail:
39513 return NULL;
39514 }
39515
39516
39517 static PyObject *_wrap_Sizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
39518 PyObject *resultobj;
39519 wxSizer *arg1 = (wxSizer *) 0 ;
39520 PyObject *arg2 = (PyObject *) 0 ;
39521 int arg3 = (int) 0 ;
39522 int arg4 = (int) 0 ;
39523 int arg5 = (int) 0 ;
39524 PyObject *arg6 = (PyObject *) NULL ;
39525 wxSizerItem *result;
39526 PyObject * obj0 = 0 ;
39527 PyObject * obj1 = 0 ;
39528 PyObject * obj2 = 0 ;
39529 PyObject * obj3 = 0 ;
39530 PyObject * obj4 = 0 ;
39531 PyObject * obj5 = 0 ;
39532 char *kwnames[] = {
39533 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39534 };
39535
39536 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39537 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39538 if (SWIG_arg_fail(1)) SWIG_fail;
39539 arg2 = obj1;
39540 if (obj2) {
39541 {
39542 arg3 = (int)(SWIG_As_int(obj2));
39543 if (SWIG_arg_fail(3)) SWIG_fail;
39544 }
39545 }
39546 if (obj3) {
39547 {
39548 arg4 = (int)(SWIG_As_int(obj3));
39549 if (SWIG_arg_fail(4)) SWIG_fail;
39550 }
39551 }
39552 if (obj4) {
39553 {
39554 arg5 = (int)(SWIG_As_int(obj4));
39555 if (SWIG_arg_fail(5)) SWIG_fail;
39556 }
39557 }
39558 if (obj5) {
39559 arg6 = obj5;
39560 }
39561 {
39562 PyThreadState* __tstate = wxPyBeginAllowThreads();
39563 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
39564
39565 wxPyEndAllowThreads(__tstate);
39566 if (PyErr_Occurred()) SWIG_fail;
39567 }
39568 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39569 return resultobj;
39570 fail:
39571 return NULL;
39572 }
39573
39574
39575 static PyObject *_wrap_Sizer_Insert(PyObject *, PyObject *args, PyObject *kwargs) {
39576 PyObject *resultobj;
39577 wxSizer *arg1 = (wxSizer *) 0 ;
39578 int arg2 ;
39579 PyObject *arg3 = (PyObject *) 0 ;
39580 int arg4 = (int) 0 ;
39581 int arg5 = (int) 0 ;
39582 int arg6 = (int) 0 ;
39583 PyObject *arg7 = (PyObject *) NULL ;
39584 wxSizerItem *result;
39585 PyObject * obj0 = 0 ;
39586 PyObject * obj1 = 0 ;
39587 PyObject * obj2 = 0 ;
39588 PyObject * obj3 = 0 ;
39589 PyObject * obj4 = 0 ;
39590 PyObject * obj5 = 0 ;
39591 PyObject * obj6 = 0 ;
39592 char *kwnames[] = {
39593 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39594 };
39595
39596 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
39597 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39598 if (SWIG_arg_fail(1)) SWIG_fail;
39599 {
39600 arg2 = (int)(SWIG_As_int(obj1));
39601 if (SWIG_arg_fail(2)) SWIG_fail;
39602 }
39603 arg3 = obj2;
39604 if (obj3) {
39605 {
39606 arg4 = (int)(SWIG_As_int(obj3));
39607 if (SWIG_arg_fail(4)) SWIG_fail;
39608 }
39609 }
39610 if (obj4) {
39611 {
39612 arg5 = (int)(SWIG_As_int(obj4));
39613 if (SWIG_arg_fail(5)) SWIG_fail;
39614 }
39615 }
39616 if (obj5) {
39617 {
39618 arg6 = (int)(SWIG_As_int(obj5));
39619 if (SWIG_arg_fail(6)) SWIG_fail;
39620 }
39621 }
39622 if (obj6) {
39623 arg7 = obj6;
39624 }
39625 {
39626 PyThreadState* __tstate = wxPyBeginAllowThreads();
39627 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
39628
39629 wxPyEndAllowThreads(__tstate);
39630 if (PyErr_Occurred()) SWIG_fail;
39631 }
39632 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39633 return resultobj;
39634 fail:
39635 return NULL;
39636 }
39637
39638
39639 static PyObject *_wrap_Sizer_Prepend(PyObject *, PyObject *args, PyObject *kwargs) {
39640 PyObject *resultobj;
39641 wxSizer *arg1 = (wxSizer *) 0 ;
39642 PyObject *arg2 = (PyObject *) 0 ;
39643 int arg3 = (int) 0 ;
39644 int arg4 = (int) 0 ;
39645 int arg5 = (int) 0 ;
39646 PyObject *arg6 = (PyObject *) NULL ;
39647 wxSizerItem *result;
39648 PyObject * obj0 = 0 ;
39649 PyObject * obj1 = 0 ;
39650 PyObject * obj2 = 0 ;
39651 PyObject * obj3 = 0 ;
39652 PyObject * obj4 = 0 ;
39653 PyObject * obj5 = 0 ;
39654 char *kwnames[] = {
39655 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
39656 };
39657
39658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
39659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39660 if (SWIG_arg_fail(1)) SWIG_fail;
39661 arg2 = obj1;
39662 if (obj2) {
39663 {
39664 arg3 = (int)(SWIG_As_int(obj2));
39665 if (SWIG_arg_fail(3)) SWIG_fail;
39666 }
39667 }
39668 if (obj3) {
39669 {
39670 arg4 = (int)(SWIG_As_int(obj3));
39671 if (SWIG_arg_fail(4)) SWIG_fail;
39672 }
39673 }
39674 if (obj4) {
39675 {
39676 arg5 = (int)(SWIG_As_int(obj4));
39677 if (SWIG_arg_fail(5)) SWIG_fail;
39678 }
39679 }
39680 if (obj5) {
39681 arg6 = obj5;
39682 }
39683 {
39684 PyThreadState* __tstate = wxPyBeginAllowThreads();
39685 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
39686
39687 wxPyEndAllowThreads(__tstate);
39688 if (PyErr_Occurred()) SWIG_fail;
39689 }
39690 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39691 return resultobj;
39692 fail:
39693 return NULL;
39694 }
39695
39696
39697 static PyObject *_wrap_Sizer_Remove(PyObject *, PyObject *args, PyObject *kwargs) {
39698 PyObject *resultobj;
39699 wxSizer *arg1 = (wxSizer *) 0 ;
39700 PyObject *arg2 = (PyObject *) 0 ;
39701 bool result;
39702 PyObject * obj0 = 0 ;
39703 PyObject * obj1 = 0 ;
39704 char *kwnames[] = {
39705 (char *) "self",(char *) "item", NULL
39706 };
39707
39708 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) goto fail;
39709 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39710 if (SWIG_arg_fail(1)) SWIG_fail;
39711 arg2 = obj1;
39712 {
39713 PyThreadState* __tstate = wxPyBeginAllowThreads();
39714 result = (bool)wxSizer_Remove(arg1,arg2);
39715
39716 wxPyEndAllowThreads(__tstate);
39717 if (PyErr_Occurred()) SWIG_fail;
39718 }
39719 {
39720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39721 }
39722 return resultobj;
39723 fail:
39724 return NULL;
39725 }
39726
39727
39728 static PyObject *_wrap_Sizer_Detach(PyObject *, PyObject *args, PyObject *kwargs) {
39729 PyObject *resultobj;
39730 wxSizer *arg1 = (wxSizer *) 0 ;
39731 PyObject *arg2 = (PyObject *) 0 ;
39732 bool result;
39733 PyObject * obj0 = 0 ;
39734 PyObject * obj1 = 0 ;
39735 char *kwnames[] = {
39736 (char *) "self",(char *) "item", NULL
39737 };
39738
39739 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) goto fail;
39740 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39741 if (SWIG_arg_fail(1)) SWIG_fail;
39742 arg2 = obj1;
39743 {
39744 PyThreadState* __tstate = wxPyBeginAllowThreads();
39745 result = (bool)wxSizer_Detach(arg1,arg2);
39746
39747 wxPyEndAllowThreads(__tstate);
39748 if (PyErr_Occurred()) SWIG_fail;
39749 }
39750 {
39751 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39752 }
39753 return resultobj;
39754 fail:
39755 return NULL;
39756 }
39757
39758
39759 static PyObject *_wrap_Sizer_GetItem(PyObject *, PyObject *args, PyObject *kwargs) {
39760 PyObject *resultobj;
39761 wxSizer *arg1 = (wxSizer *) 0 ;
39762 PyObject *arg2 = (PyObject *) 0 ;
39763 wxSizerItem *result;
39764 PyObject * obj0 = 0 ;
39765 PyObject * obj1 = 0 ;
39766 char *kwnames[] = {
39767 (char *) "self",(char *) "item", NULL
39768 };
39769
39770 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) goto fail;
39771 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39772 if (SWIG_arg_fail(1)) SWIG_fail;
39773 arg2 = obj1;
39774 {
39775 PyThreadState* __tstate = wxPyBeginAllowThreads();
39776 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
39777
39778 wxPyEndAllowThreads(__tstate);
39779 if (PyErr_Occurred()) SWIG_fail;
39780 }
39781 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39782 return resultobj;
39783 fail:
39784 return NULL;
39785 }
39786
39787
39788 static PyObject *_wrap_Sizer__SetItemMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39789 PyObject *resultobj;
39790 wxSizer *arg1 = (wxSizer *) 0 ;
39791 PyObject *arg2 = (PyObject *) 0 ;
39792 wxSize *arg3 = 0 ;
39793 wxSize temp3 ;
39794 PyObject * obj0 = 0 ;
39795 PyObject * obj1 = 0 ;
39796 PyObject * obj2 = 0 ;
39797 char *kwnames[] = {
39798 (char *) "self",(char *) "item",(char *) "size", NULL
39799 };
39800
39801 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
39802 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39803 if (SWIG_arg_fail(1)) SWIG_fail;
39804 arg2 = obj1;
39805 {
39806 arg3 = &temp3;
39807 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
39808 }
39809 {
39810 PyThreadState* __tstate = wxPyBeginAllowThreads();
39811 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
39812
39813 wxPyEndAllowThreads(__tstate);
39814 if (PyErr_Occurred()) SWIG_fail;
39815 }
39816 Py_INCREF(Py_None); resultobj = Py_None;
39817 return resultobj;
39818 fail:
39819 return NULL;
39820 }
39821
39822
39823 static PyObject *_wrap_Sizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
39824 PyObject *resultobj;
39825 wxSizer *arg1 = (wxSizer *) 0 ;
39826 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39827 wxSizerItem *result;
39828 PyObject * obj0 = 0 ;
39829 PyObject * obj1 = 0 ;
39830 char *kwnames[] = {
39831 (char *) "self",(char *) "item", NULL
39832 };
39833
39834 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
39835 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39836 if (SWIG_arg_fail(1)) SWIG_fail;
39837 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39838 if (SWIG_arg_fail(2)) SWIG_fail;
39839 {
39840 PyThreadState* __tstate = wxPyBeginAllowThreads();
39841 result = (wxSizerItem *)(arg1)->Add(arg2);
39842
39843 wxPyEndAllowThreads(__tstate);
39844 if (PyErr_Occurred()) SWIG_fail;
39845 }
39846 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39847 return resultobj;
39848 fail:
39849 return NULL;
39850 }
39851
39852
39853 static PyObject *_wrap_Sizer_InsertItem(PyObject *, PyObject *args, PyObject *kwargs) {
39854 PyObject *resultobj;
39855 wxSizer *arg1 = (wxSizer *) 0 ;
39856 size_t arg2 ;
39857 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
39858 wxSizerItem *result;
39859 PyObject * obj0 = 0 ;
39860 PyObject * obj1 = 0 ;
39861 PyObject * obj2 = 0 ;
39862 char *kwnames[] = {
39863 (char *) "self",(char *) "index",(char *) "item", NULL
39864 };
39865
39866 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
39867 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39868 if (SWIG_arg_fail(1)) SWIG_fail;
39869 {
39870 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
39871 if (SWIG_arg_fail(2)) SWIG_fail;
39872 }
39873 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39874 if (SWIG_arg_fail(3)) SWIG_fail;
39875 {
39876 PyThreadState* __tstate = wxPyBeginAllowThreads();
39877 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
39878
39879 wxPyEndAllowThreads(__tstate);
39880 if (PyErr_Occurred()) SWIG_fail;
39881 }
39882 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39883 return resultobj;
39884 fail:
39885 return NULL;
39886 }
39887
39888
39889 static PyObject *_wrap_Sizer_PrependItem(PyObject *, PyObject *args, PyObject *kwargs) {
39890 PyObject *resultobj;
39891 wxSizer *arg1 = (wxSizer *) 0 ;
39892 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
39893 wxSizerItem *result;
39894 PyObject * obj0 = 0 ;
39895 PyObject * obj1 = 0 ;
39896 char *kwnames[] = {
39897 (char *) "self",(char *) "item", NULL
39898 };
39899
39900 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) goto fail;
39901 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39902 if (SWIG_arg_fail(1)) SWIG_fail;
39903 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizerItem, SWIG_POINTER_EXCEPTION | 0);
39904 if (SWIG_arg_fail(2)) SWIG_fail;
39905 {
39906 PyThreadState* __tstate = wxPyBeginAllowThreads();
39907 result = (wxSizerItem *)(arg1)->Prepend(arg2);
39908
39909 wxPyEndAllowThreads(__tstate);
39910 if (PyErr_Occurred()) SWIG_fail;
39911 }
39912 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxSizerItem, 0);
39913 return resultobj;
39914 fail:
39915 return NULL;
39916 }
39917
39918
39919 static PyObject *_wrap_Sizer_SetDimension(PyObject *, PyObject *args, PyObject *kwargs) {
39920 PyObject *resultobj;
39921 wxSizer *arg1 = (wxSizer *) 0 ;
39922 int arg2 ;
39923 int arg3 ;
39924 int arg4 ;
39925 int arg5 ;
39926 PyObject * obj0 = 0 ;
39927 PyObject * obj1 = 0 ;
39928 PyObject * obj2 = 0 ;
39929 PyObject * obj3 = 0 ;
39930 PyObject * obj4 = 0 ;
39931 char *kwnames[] = {
39932 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
39933 };
39934
39935 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) goto fail;
39936 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39937 if (SWIG_arg_fail(1)) SWIG_fail;
39938 {
39939 arg2 = (int)(SWIG_As_int(obj1));
39940 if (SWIG_arg_fail(2)) SWIG_fail;
39941 }
39942 {
39943 arg3 = (int)(SWIG_As_int(obj2));
39944 if (SWIG_arg_fail(3)) SWIG_fail;
39945 }
39946 {
39947 arg4 = (int)(SWIG_As_int(obj3));
39948 if (SWIG_arg_fail(4)) SWIG_fail;
39949 }
39950 {
39951 arg5 = (int)(SWIG_As_int(obj4));
39952 if (SWIG_arg_fail(5)) SWIG_fail;
39953 }
39954 {
39955 PyThreadState* __tstate = wxPyBeginAllowThreads();
39956 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
39957
39958 wxPyEndAllowThreads(__tstate);
39959 if (PyErr_Occurred()) SWIG_fail;
39960 }
39961 Py_INCREF(Py_None); resultobj = Py_None;
39962 return resultobj;
39963 fail:
39964 return NULL;
39965 }
39966
39967
39968 static PyObject *_wrap_Sizer_SetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
39969 PyObject *resultobj;
39970 wxSizer *arg1 = (wxSizer *) 0 ;
39971 wxSize *arg2 = 0 ;
39972 wxSize temp2 ;
39973 PyObject * obj0 = 0 ;
39974 PyObject * obj1 = 0 ;
39975 char *kwnames[] = {
39976 (char *) "self",(char *) "size", NULL
39977 };
39978
39979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) goto fail;
39980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
39981 if (SWIG_arg_fail(1)) SWIG_fail;
39982 {
39983 arg2 = &temp2;
39984 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
39985 }
39986 {
39987 PyThreadState* __tstate = wxPyBeginAllowThreads();
39988 (arg1)->SetMinSize((wxSize const &)*arg2);
39989
39990 wxPyEndAllowThreads(__tstate);
39991 if (PyErr_Occurred()) SWIG_fail;
39992 }
39993 Py_INCREF(Py_None); resultobj = Py_None;
39994 return resultobj;
39995 fail:
39996 return NULL;
39997 }
39998
39999
40000 static PyObject *_wrap_Sizer_GetSize(PyObject *, PyObject *args, PyObject *kwargs) {
40001 PyObject *resultobj;
40002 wxSizer *arg1 = (wxSizer *) 0 ;
40003 wxSize result;
40004 PyObject * obj0 = 0 ;
40005 char *kwnames[] = {
40006 (char *) "self", NULL
40007 };
40008
40009 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetSize",kwnames,&obj0)) goto fail;
40010 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40011 if (SWIG_arg_fail(1)) SWIG_fail;
40012 {
40013 PyThreadState* __tstate = wxPyBeginAllowThreads();
40014 result = (arg1)->GetSize();
40015
40016 wxPyEndAllowThreads(__tstate);
40017 if (PyErr_Occurred()) SWIG_fail;
40018 }
40019 {
40020 wxSize * resultptr;
40021 resultptr = new wxSize((wxSize &)(result));
40022 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40023 }
40024 return resultobj;
40025 fail:
40026 return NULL;
40027 }
40028
40029
40030 static PyObject *_wrap_Sizer_GetPosition(PyObject *, PyObject *args, PyObject *kwargs) {
40031 PyObject *resultobj;
40032 wxSizer *arg1 = (wxSizer *) 0 ;
40033 wxPoint result;
40034 PyObject * obj0 = 0 ;
40035 char *kwnames[] = {
40036 (char *) "self", NULL
40037 };
40038
40039 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetPosition",kwnames,&obj0)) goto fail;
40040 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40041 if (SWIG_arg_fail(1)) SWIG_fail;
40042 {
40043 PyThreadState* __tstate = wxPyBeginAllowThreads();
40044 result = (arg1)->GetPosition();
40045
40046 wxPyEndAllowThreads(__tstate);
40047 if (PyErr_Occurred()) SWIG_fail;
40048 }
40049 {
40050 wxPoint * resultptr;
40051 resultptr = new wxPoint((wxPoint &)(result));
40052 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxPoint, 1);
40053 }
40054 return resultobj;
40055 fail:
40056 return NULL;
40057 }
40058
40059
40060 static PyObject *_wrap_Sizer_GetMinSize(PyObject *, PyObject *args, PyObject *kwargs) {
40061 PyObject *resultobj;
40062 wxSizer *arg1 = (wxSizer *) 0 ;
40063 wxSize result;
40064 PyObject * obj0 = 0 ;
40065 char *kwnames[] = {
40066 (char *) "self", NULL
40067 };
40068
40069 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetMinSize",kwnames,&obj0)) goto fail;
40070 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40071 if (SWIG_arg_fail(1)) SWIG_fail;
40072 {
40073 PyThreadState* __tstate = wxPyBeginAllowThreads();
40074 result = (arg1)->GetMinSize();
40075
40076 wxPyEndAllowThreads(__tstate);
40077 if (PyErr_Occurred()) SWIG_fail;
40078 }
40079 {
40080 wxSize * resultptr;
40081 resultptr = new wxSize((wxSize &)(result));
40082 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40083 }
40084 return resultobj;
40085 fail:
40086 return NULL;
40087 }
40088
40089
40090 static PyObject *_wrap_Sizer_RecalcSizes(PyObject *, PyObject *args, PyObject *kwargs) {
40091 PyObject *resultobj;
40092 wxSizer *arg1 = (wxSizer *) 0 ;
40093 PyObject * obj0 = 0 ;
40094 char *kwnames[] = {
40095 (char *) "self", NULL
40096 };
40097
40098 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_RecalcSizes",kwnames,&obj0)) goto fail;
40099 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40100 if (SWIG_arg_fail(1)) SWIG_fail;
40101 {
40102 PyThreadState* __tstate = wxPyBeginAllowThreads();
40103 (arg1)->RecalcSizes();
40104
40105 wxPyEndAllowThreads(__tstate);
40106 if (PyErr_Occurred()) SWIG_fail;
40107 }
40108 Py_INCREF(Py_None); resultobj = Py_None;
40109 return resultobj;
40110 fail:
40111 return NULL;
40112 }
40113
40114
40115 static PyObject *_wrap_Sizer_CalcMin(PyObject *, PyObject *args, PyObject *kwargs) {
40116 PyObject *resultobj;
40117 wxSizer *arg1 = (wxSizer *) 0 ;
40118 wxSize result;
40119 PyObject * obj0 = 0 ;
40120 char *kwnames[] = {
40121 (char *) "self", NULL
40122 };
40123
40124 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_CalcMin",kwnames,&obj0)) goto fail;
40125 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40126 if (SWIG_arg_fail(1)) SWIG_fail;
40127 {
40128 PyThreadState* __tstate = wxPyBeginAllowThreads();
40129 result = (arg1)->CalcMin();
40130
40131 wxPyEndAllowThreads(__tstate);
40132 if (PyErr_Occurred()) SWIG_fail;
40133 }
40134 {
40135 wxSize * resultptr;
40136 resultptr = new wxSize((wxSize &)(result));
40137 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40138 }
40139 return resultobj;
40140 fail:
40141 return NULL;
40142 }
40143
40144
40145 static PyObject *_wrap_Sizer_Layout(PyObject *, PyObject *args, PyObject *kwargs) {
40146 PyObject *resultobj;
40147 wxSizer *arg1 = (wxSizer *) 0 ;
40148 PyObject * obj0 = 0 ;
40149 char *kwnames[] = {
40150 (char *) "self", NULL
40151 };
40152
40153 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_Layout",kwnames,&obj0)) 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 {
40157 PyThreadState* __tstate = wxPyBeginAllowThreads();
40158 (arg1)->Layout();
40159
40160 wxPyEndAllowThreads(__tstate);
40161 if (PyErr_Occurred()) SWIG_fail;
40162 }
40163 Py_INCREF(Py_None); resultobj = Py_None;
40164 return resultobj;
40165 fail:
40166 return NULL;
40167 }
40168
40169
40170 static PyObject *_wrap_Sizer_Fit(PyObject *, PyObject *args, PyObject *kwargs) {
40171 PyObject *resultobj;
40172 wxSizer *arg1 = (wxSizer *) 0 ;
40173 wxWindow *arg2 = (wxWindow *) 0 ;
40174 wxSize result;
40175 PyObject * obj0 = 0 ;
40176 PyObject * obj1 = 0 ;
40177 char *kwnames[] = {
40178 (char *) "self",(char *) "window", NULL
40179 };
40180
40181 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) goto fail;
40182 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40183 if (SWIG_arg_fail(1)) SWIG_fail;
40184 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40185 if (SWIG_arg_fail(2)) SWIG_fail;
40186 {
40187 PyThreadState* __tstate = wxPyBeginAllowThreads();
40188 result = (arg1)->Fit(arg2);
40189
40190 wxPyEndAllowThreads(__tstate);
40191 if (PyErr_Occurred()) SWIG_fail;
40192 }
40193 {
40194 wxSize * resultptr;
40195 resultptr = new wxSize((wxSize &)(result));
40196 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
40197 }
40198 return resultobj;
40199 fail:
40200 return NULL;
40201 }
40202
40203
40204 static PyObject *_wrap_Sizer_FitInside(PyObject *, PyObject *args, PyObject *kwargs) {
40205 PyObject *resultobj;
40206 wxSizer *arg1 = (wxSizer *) 0 ;
40207 wxWindow *arg2 = (wxWindow *) 0 ;
40208 PyObject * obj0 = 0 ;
40209 PyObject * obj1 = 0 ;
40210 char *kwnames[] = {
40211 (char *) "self",(char *) "window", NULL
40212 };
40213
40214 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) goto fail;
40215 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40216 if (SWIG_arg_fail(1)) SWIG_fail;
40217 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40218 if (SWIG_arg_fail(2)) SWIG_fail;
40219 {
40220 PyThreadState* __tstate = wxPyBeginAllowThreads();
40221 (arg1)->FitInside(arg2);
40222
40223 wxPyEndAllowThreads(__tstate);
40224 if (PyErr_Occurred()) SWIG_fail;
40225 }
40226 Py_INCREF(Py_None); resultobj = Py_None;
40227 return resultobj;
40228 fail:
40229 return NULL;
40230 }
40231
40232
40233 static PyObject *_wrap_Sizer_SetSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40234 PyObject *resultobj;
40235 wxSizer *arg1 = (wxSizer *) 0 ;
40236 wxWindow *arg2 = (wxWindow *) 0 ;
40237 PyObject * obj0 = 0 ;
40238 PyObject * obj1 = 0 ;
40239 char *kwnames[] = {
40240 (char *) "self",(char *) "window", NULL
40241 };
40242
40243 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) goto fail;
40244 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40245 if (SWIG_arg_fail(1)) SWIG_fail;
40246 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40247 if (SWIG_arg_fail(2)) SWIG_fail;
40248 {
40249 PyThreadState* __tstate = wxPyBeginAllowThreads();
40250 (arg1)->SetSizeHints(arg2);
40251
40252 wxPyEndAllowThreads(__tstate);
40253 if (PyErr_Occurred()) SWIG_fail;
40254 }
40255 Py_INCREF(Py_None); resultobj = Py_None;
40256 return resultobj;
40257 fail:
40258 return NULL;
40259 }
40260
40261
40262 static PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *, PyObject *args, PyObject *kwargs) {
40263 PyObject *resultobj;
40264 wxSizer *arg1 = (wxSizer *) 0 ;
40265 wxWindow *arg2 = (wxWindow *) 0 ;
40266 PyObject * obj0 = 0 ;
40267 PyObject * obj1 = 0 ;
40268 char *kwnames[] = {
40269 (char *) "self",(char *) "window", NULL
40270 };
40271
40272 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) goto fail;
40273 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40274 if (SWIG_arg_fail(1)) SWIG_fail;
40275 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
40276 if (SWIG_arg_fail(2)) SWIG_fail;
40277 {
40278 PyThreadState* __tstate = wxPyBeginAllowThreads();
40279 (arg1)->SetVirtualSizeHints(arg2);
40280
40281 wxPyEndAllowThreads(__tstate);
40282 if (PyErr_Occurred()) SWIG_fail;
40283 }
40284 Py_INCREF(Py_None); resultobj = Py_None;
40285 return resultobj;
40286 fail:
40287 return NULL;
40288 }
40289
40290
40291 static PyObject *_wrap_Sizer_Clear(PyObject *, PyObject *args, PyObject *kwargs) {
40292 PyObject *resultobj;
40293 wxSizer *arg1 = (wxSizer *) 0 ;
40294 bool arg2 = (bool) false ;
40295 PyObject * obj0 = 0 ;
40296 PyObject * obj1 = 0 ;
40297 char *kwnames[] = {
40298 (char *) "self",(char *) "deleteWindows", NULL
40299 };
40300
40301 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) goto fail;
40302 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40303 if (SWIG_arg_fail(1)) SWIG_fail;
40304 if (obj1) {
40305 {
40306 arg2 = (bool)(SWIG_As_bool(obj1));
40307 if (SWIG_arg_fail(2)) SWIG_fail;
40308 }
40309 }
40310 {
40311 PyThreadState* __tstate = wxPyBeginAllowThreads();
40312 (arg1)->Clear(arg2);
40313
40314 wxPyEndAllowThreads(__tstate);
40315 if (PyErr_Occurred()) SWIG_fail;
40316 }
40317 Py_INCREF(Py_None); resultobj = Py_None;
40318 return resultobj;
40319 fail:
40320 return NULL;
40321 }
40322
40323
40324 static PyObject *_wrap_Sizer_DeleteWindows(PyObject *, PyObject *args, PyObject *kwargs) {
40325 PyObject *resultobj;
40326 wxSizer *arg1 = (wxSizer *) 0 ;
40327 PyObject * obj0 = 0 ;
40328 char *kwnames[] = {
40329 (char *) "self", NULL
40330 };
40331
40332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_DeleteWindows",kwnames,&obj0)) goto fail;
40333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40334 if (SWIG_arg_fail(1)) SWIG_fail;
40335 {
40336 PyThreadState* __tstate = wxPyBeginAllowThreads();
40337 (arg1)->DeleteWindows();
40338
40339 wxPyEndAllowThreads(__tstate);
40340 if (PyErr_Occurred()) SWIG_fail;
40341 }
40342 Py_INCREF(Py_None); resultobj = Py_None;
40343 return resultobj;
40344 fail:
40345 return NULL;
40346 }
40347
40348
40349 static PyObject *_wrap_Sizer_GetChildren(PyObject *, PyObject *args, PyObject *kwargs) {
40350 PyObject *resultobj;
40351 wxSizer *arg1 = (wxSizer *) 0 ;
40352 PyObject *result;
40353 PyObject * obj0 = 0 ;
40354 char *kwnames[] = {
40355 (char *) "self", NULL
40356 };
40357
40358 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Sizer_GetChildren",kwnames,&obj0)) goto fail;
40359 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40360 if (SWIG_arg_fail(1)) SWIG_fail;
40361 {
40362 PyThreadState* __tstate = wxPyBeginAllowThreads();
40363 result = (PyObject *)wxSizer_GetChildren(arg1);
40364
40365 wxPyEndAllowThreads(__tstate);
40366 if (PyErr_Occurred()) SWIG_fail;
40367 }
40368 resultobj = result;
40369 return resultobj;
40370 fail:
40371 return NULL;
40372 }
40373
40374
40375 static PyObject *_wrap_Sizer_Show(PyObject *, PyObject *args, PyObject *kwargs) {
40376 PyObject *resultobj;
40377 wxSizer *arg1 = (wxSizer *) 0 ;
40378 PyObject *arg2 = (PyObject *) 0 ;
40379 bool arg3 = (bool) true ;
40380 bool arg4 = (bool) false ;
40381 bool result;
40382 PyObject * obj0 = 0 ;
40383 PyObject * obj1 = 0 ;
40384 PyObject * obj2 = 0 ;
40385 PyObject * obj3 = 0 ;
40386 char *kwnames[] = {
40387 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
40388 };
40389
40390 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40391 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40392 if (SWIG_arg_fail(1)) SWIG_fail;
40393 arg2 = obj1;
40394 if (obj2) {
40395 {
40396 arg3 = (bool)(SWIG_As_bool(obj2));
40397 if (SWIG_arg_fail(3)) SWIG_fail;
40398 }
40399 }
40400 if (obj3) {
40401 {
40402 arg4 = (bool)(SWIG_As_bool(obj3));
40403 if (SWIG_arg_fail(4)) SWIG_fail;
40404 }
40405 }
40406 {
40407 PyThreadState* __tstate = wxPyBeginAllowThreads();
40408 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
40409
40410 wxPyEndAllowThreads(__tstate);
40411 if (PyErr_Occurred()) SWIG_fail;
40412 }
40413 {
40414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40415 }
40416 return resultobj;
40417 fail:
40418 return NULL;
40419 }
40420
40421
40422 static PyObject *_wrap_Sizer_IsShown(PyObject *, PyObject *args, PyObject *kwargs) {
40423 PyObject *resultobj;
40424 wxSizer *arg1 = (wxSizer *) 0 ;
40425 PyObject *arg2 = (PyObject *) 0 ;
40426 bool result;
40427 PyObject * obj0 = 0 ;
40428 PyObject * obj1 = 0 ;
40429 char *kwnames[] = {
40430 (char *) "self",(char *) "item", NULL
40431 };
40432
40433 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) goto fail;
40434 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40435 if (SWIG_arg_fail(1)) SWIG_fail;
40436 arg2 = obj1;
40437 {
40438 PyThreadState* __tstate = wxPyBeginAllowThreads();
40439 result = (bool)wxSizer_IsShown(arg1,arg2);
40440
40441 wxPyEndAllowThreads(__tstate);
40442 if (PyErr_Occurred()) SWIG_fail;
40443 }
40444 {
40445 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40446 }
40447 return resultobj;
40448 fail:
40449 return NULL;
40450 }
40451
40452
40453 static PyObject *_wrap_Sizer_ShowItems(PyObject *, PyObject *args, PyObject *kwargs) {
40454 PyObject *resultobj;
40455 wxSizer *arg1 = (wxSizer *) 0 ;
40456 bool arg2 ;
40457 PyObject * obj0 = 0 ;
40458 PyObject * obj1 = 0 ;
40459 char *kwnames[] = {
40460 (char *) "self",(char *) "show", NULL
40461 };
40462
40463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) goto fail;
40464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
40465 if (SWIG_arg_fail(1)) SWIG_fail;
40466 {
40467 arg2 = (bool)(SWIG_As_bool(obj1));
40468 if (SWIG_arg_fail(2)) SWIG_fail;
40469 }
40470 {
40471 PyThreadState* __tstate = wxPyBeginAllowThreads();
40472 (arg1)->ShowItems(arg2);
40473
40474 wxPyEndAllowThreads(__tstate);
40475 if (PyErr_Occurred()) SWIG_fail;
40476 }
40477 Py_INCREF(Py_None); resultobj = Py_None;
40478 return resultobj;
40479 fail:
40480 return NULL;
40481 }
40482
40483
40484 static PyObject * Sizer_swigregister(PyObject *, PyObject *args) {
40485 PyObject *obj;
40486 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40487 SWIG_TypeClientData(SWIGTYPE_p_wxSizer, obj);
40488 Py_INCREF(obj);
40489 return Py_BuildValue((char *)"");
40490 }
40491 static PyObject *_wrap_new_PySizer(PyObject *, PyObject *args, PyObject *kwargs) {
40492 PyObject *resultobj;
40493 wxPySizer *result;
40494 char *kwnames[] = {
40495 NULL
40496 };
40497
40498 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_PySizer",kwnames)) goto fail;
40499 {
40500 PyThreadState* __tstate = wxPyBeginAllowThreads();
40501 result = (wxPySizer *)new wxPySizer();
40502
40503 wxPyEndAllowThreads(__tstate);
40504 if (PyErr_Occurred()) SWIG_fail;
40505 }
40506 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxPySizer, 1);
40507 return resultobj;
40508 fail:
40509 return NULL;
40510 }
40511
40512
40513 static PyObject *_wrap_PySizer__setCallbackInfo(PyObject *, PyObject *args, PyObject *kwargs) {
40514 PyObject *resultobj;
40515 wxPySizer *arg1 = (wxPySizer *) 0 ;
40516 PyObject *arg2 = (PyObject *) 0 ;
40517 PyObject *arg3 = (PyObject *) 0 ;
40518 PyObject * obj0 = 0 ;
40519 PyObject * obj1 = 0 ;
40520 PyObject * obj2 = 0 ;
40521 char *kwnames[] = {
40522 (char *) "self",(char *) "self",(char *) "_class", NULL
40523 };
40524
40525 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) goto fail;
40526 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxPySizer, SWIG_POINTER_EXCEPTION | 0);
40527 if (SWIG_arg_fail(1)) SWIG_fail;
40528 arg2 = obj1;
40529 arg3 = obj2;
40530 {
40531 PyThreadState* __tstate = wxPyBeginAllowThreads();
40532 (arg1)->_setCallbackInfo(arg2,arg3);
40533
40534 wxPyEndAllowThreads(__tstate);
40535 if (PyErr_Occurred()) SWIG_fail;
40536 }
40537 Py_INCREF(Py_None); resultobj = Py_None;
40538 return resultobj;
40539 fail:
40540 return NULL;
40541 }
40542
40543
40544 static PyObject * PySizer_swigregister(PyObject *, PyObject *args) {
40545 PyObject *obj;
40546 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40547 SWIG_TypeClientData(SWIGTYPE_p_wxPySizer, obj);
40548 Py_INCREF(obj);
40549 return Py_BuildValue((char *)"");
40550 }
40551 static PyObject *_wrap_new_BoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40552 PyObject *resultobj;
40553 int arg1 = (int) wxHORIZONTAL ;
40554 wxBoxSizer *result;
40555 PyObject * obj0 = 0 ;
40556 char *kwnames[] = {
40557 (char *) "orient", NULL
40558 };
40559
40560 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) goto fail;
40561 if (obj0) {
40562 {
40563 arg1 = (int)(SWIG_As_int(obj0));
40564 if (SWIG_arg_fail(1)) SWIG_fail;
40565 }
40566 }
40567 {
40568 PyThreadState* __tstate = wxPyBeginAllowThreads();
40569 result = (wxBoxSizer *)new wxBoxSizer(arg1);
40570
40571 wxPyEndAllowThreads(__tstate);
40572 if (PyErr_Occurred()) SWIG_fail;
40573 }
40574 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxBoxSizer, 1);
40575 return resultobj;
40576 fail:
40577 return NULL;
40578 }
40579
40580
40581 static PyObject *_wrap_BoxSizer_GetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40582 PyObject *resultobj;
40583 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40584 int result;
40585 PyObject * obj0 = 0 ;
40586 char *kwnames[] = {
40587 (char *) "self", NULL
40588 };
40589
40590 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:BoxSizer_GetOrientation",kwnames,&obj0)) goto fail;
40591 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40592 if (SWIG_arg_fail(1)) SWIG_fail;
40593 {
40594 PyThreadState* __tstate = wxPyBeginAllowThreads();
40595 result = (int)(arg1)->GetOrientation();
40596
40597 wxPyEndAllowThreads(__tstate);
40598 if (PyErr_Occurred()) SWIG_fail;
40599 }
40600 {
40601 resultobj = SWIG_From_int((int)(result));
40602 }
40603 return resultobj;
40604 fail:
40605 return NULL;
40606 }
40607
40608
40609 static PyObject *_wrap_BoxSizer_SetOrientation(PyObject *, PyObject *args, PyObject *kwargs) {
40610 PyObject *resultobj;
40611 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
40612 int arg2 ;
40613 PyObject * obj0 = 0 ;
40614 PyObject * obj1 = 0 ;
40615 char *kwnames[] = {
40616 (char *) "self",(char *) "orient", NULL
40617 };
40618
40619 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) goto fail;
40620 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40621 if (SWIG_arg_fail(1)) SWIG_fail;
40622 {
40623 arg2 = (int)(SWIG_As_int(obj1));
40624 if (SWIG_arg_fail(2)) SWIG_fail;
40625 }
40626 {
40627 PyThreadState* __tstate = wxPyBeginAllowThreads();
40628 (arg1)->SetOrientation(arg2);
40629
40630 wxPyEndAllowThreads(__tstate);
40631 if (PyErr_Occurred()) SWIG_fail;
40632 }
40633 Py_INCREF(Py_None); resultobj = Py_None;
40634 return resultobj;
40635 fail:
40636 return NULL;
40637 }
40638
40639
40640 static PyObject * BoxSizer_swigregister(PyObject *, PyObject *args) {
40641 PyObject *obj;
40642 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40643 SWIG_TypeClientData(SWIGTYPE_p_wxBoxSizer, obj);
40644 Py_INCREF(obj);
40645 return Py_BuildValue((char *)"");
40646 }
40647 static PyObject *_wrap_new_StaticBoxSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40648 PyObject *resultobj;
40649 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
40650 int arg2 = (int) wxHORIZONTAL ;
40651 wxStaticBoxSizer *result;
40652 PyObject * obj0 = 0 ;
40653 PyObject * obj1 = 0 ;
40654 char *kwnames[] = {
40655 (char *) "box",(char *) "orient", NULL
40656 };
40657
40658 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) goto fail;
40659 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBox, SWIG_POINTER_EXCEPTION | 0);
40660 if (SWIG_arg_fail(1)) SWIG_fail;
40661 if (obj1) {
40662 {
40663 arg2 = (int)(SWIG_As_int(obj1));
40664 if (SWIG_arg_fail(2)) SWIG_fail;
40665 }
40666 }
40667 {
40668 PyThreadState* __tstate = wxPyBeginAllowThreads();
40669 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
40670
40671 wxPyEndAllowThreads(__tstate);
40672 if (PyErr_Occurred()) SWIG_fail;
40673 }
40674 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStaticBoxSizer, 1);
40675 return resultobj;
40676 fail:
40677 return NULL;
40678 }
40679
40680
40681 static PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *, PyObject *args, PyObject *kwargs) {
40682 PyObject *resultobj;
40683 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
40684 wxStaticBox *result;
40685 PyObject * obj0 = 0 ;
40686 char *kwnames[] = {
40687 (char *) "self", NULL
40688 };
40689
40690 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StaticBoxSizer_GetStaticBox",kwnames,&obj0)) goto fail;
40691 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_EXCEPTION | 0);
40692 if (SWIG_arg_fail(1)) SWIG_fail;
40693 {
40694 PyThreadState* __tstate = wxPyBeginAllowThreads();
40695 result = (wxStaticBox *)(arg1)->GetStaticBox();
40696
40697 wxPyEndAllowThreads(__tstate);
40698 if (PyErr_Occurred()) SWIG_fail;
40699 }
40700 {
40701 resultobj = wxPyMake_wxObject(result, 0);
40702 }
40703 return resultobj;
40704 fail:
40705 return NULL;
40706 }
40707
40708
40709 static PyObject * StaticBoxSizer_swigregister(PyObject *, PyObject *args) {
40710 PyObject *obj;
40711 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
40712 SWIG_TypeClientData(SWIGTYPE_p_wxStaticBoxSizer, obj);
40713 Py_INCREF(obj);
40714 return Py_BuildValue((char *)"");
40715 }
40716 static PyObject *_wrap_new_GridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
40717 PyObject *resultobj;
40718 int arg1 = (int) 1 ;
40719 int arg2 = (int) 0 ;
40720 int arg3 = (int) 0 ;
40721 int arg4 = (int) 0 ;
40722 wxGridSizer *result;
40723 PyObject * obj0 = 0 ;
40724 PyObject * obj1 = 0 ;
40725 PyObject * obj2 = 0 ;
40726 PyObject * obj3 = 0 ;
40727 char *kwnames[] = {
40728 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
40729 };
40730
40731 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
40732 if (obj0) {
40733 {
40734 arg1 = (int)(SWIG_As_int(obj0));
40735 if (SWIG_arg_fail(1)) SWIG_fail;
40736 }
40737 }
40738 if (obj1) {
40739 {
40740 arg2 = (int)(SWIG_As_int(obj1));
40741 if (SWIG_arg_fail(2)) SWIG_fail;
40742 }
40743 }
40744 if (obj2) {
40745 {
40746 arg3 = (int)(SWIG_As_int(obj2));
40747 if (SWIG_arg_fail(3)) SWIG_fail;
40748 }
40749 }
40750 if (obj3) {
40751 {
40752 arg4 = (int)(SWIG_As_int(obj3));
40753 if (SWIG_arg_fail(4)) SWIG_fail;
40754 }
40755 }
40756 {
40757 PyThreadState* __tstate = wxPyBeginAllowThreads();
40758 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
40759
40760 wxPyEndAllowThreads(__tstate);
40761 if (PyErr_Occurred()) SWIG_fail;
40762 }
40763 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridSizer, 1);
40764 return resultobj;
40765 fail:
40766 return NULL;
40767 }
40768
40769
40770 static PyObject *_wrap_GridSizer_SetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40771 PyObject *resultobj;
40772 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40773 int arg2 ;
40774 PyObject * obj0 = 0 ;
40775 PyObject * obj1 = 0 ;
40776 char *kwnames[] = {
40777 (char *) "self",(char *) "cols", NULL
40778 };
40779
40780 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) goto fail;
40781 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40782 if (SWIG_arg_fail(1)) SWIG_fail;
40783 {
40784 arg2 = (int)(SWIG_As_int(obj1));
40785 if (SWIG_arg_fail(2)) SWIG_fail;
40786 }
40787 {
40788 PyThreadState* __tstate = wxPyBeginAllowThreads();
40789 (arg1)->SetCols(arg2);
40790
40791 wxPyEndAllowThreads(__tstate);
40792 if (PyErr_Occurred()) SWIG_fail;
40793 }
40794 Py_INCREF(Py_None); resultobj = Py_None;
40795 return resultobj;
40796 fail:
40797 return NULL;
40798 }
40799
40800
40801 static PyObject *_wrap_GridSizer_SetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40802 PyObject *resultobj;
40803 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40804 int arg2 ;
40805 PyObject * obj0 = 0 ;
40806 PyObject * obj1 = 0 ;
40807 char *kwnames[] = {
40808 (char *) "self",(char *) "rows", NULL
40809 };
40810
40811 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) goto fail;
40812 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40813 if (SWIG_arg_fail(1)) SWIG_fail;
40814 {
40815 arg2 = (int)(SWIG_As_int(obj1));
40816 if (SWIG_arg_fail(2)) SWIG_fail;
40817 }
40818 {
40819 PyThreadState* __tstate = wxPyBeginAllowThreads();
40820 (arg1)->SetRows(arg2);
40821
40822 wxPyEndAllowThreads(__tstate);
40823 if (PyErr_Occurred()) SWIG_fail;
40824 }
40825 Py_INCREF(Py_None); resultobj = Py_None;
40826 return resultobj;
40827 fail:
40828 return NULL;
40829 }
40830
40831
40832 static PyObject *_wrap_GridSizer_SetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40833 PyObject *resultobj;
40834 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40835 int arg2 ;
40836 PyObject * obj0 = 0 ;
40837 PyObject * obj1 = 0 ;
40838 char *kwnames[] = {
40839 (char *) "self",(char *) "gap", NULL
40840 };
40841
40842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) goto fail;
40843 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40844 if (SWIG_arg_fail(1)) SWIG_fail;
40845 {
40846 arg2 = (int)(SWIG_As_int(obj1));
40847 if (SWIG_arg_fail(2)) SWIG_fail;
40848 }
40849 {
40850 PyThreadState* __tstate = wxPyBeginAllowThreads();
40851 (arg1)->SetVGap(arg2);
40852
40853 wxPyEndAllowThreads(__tstate);
40854 if (PyErr_Occurred()) SWIG_fail;
40855 }
40856 Py_INCREF(Py_None); resultobj = Py_None;
40857 return resultobj;
40858 fail:
40859 return NULL;
40860 }
40861
40862
40863 static PyObject *_wrap_GridSizer_SetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40864 PyObject *resultobj;
40865 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40866 int arg2 ;
40867 PyObject * obj0 = 0 ;
40868 PyObject * obj1 = 0 ;
40869 char *kwnames[] = {
40870 (char *) "self",(char *) "gap", NULL
40871 };
40872
40873 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) goto fail;
40874 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40875 if (SWIG_arg_fail(1)) SWIG_fail;
40876 {
40877 arg2 = (int)(SWIG_As_int(obj1));
40878 if (SWIG_arg_fail(2)) SWIG_fail;
40879 }
40880 {
40881 PyThreadState* __tstate = wxPyBeginAllowThreads();
40882 (arg1)->SetHGap(arg2);
40883
40884 wxPyEndAllowThreads(__tstate);
40885 if (PyErr_Occurred()) SWIG_fail;
40886 }
40887 Py_INCREF(Py_None); resultobj = Py_None;
40888 return resultobj;
40889 fail:
40890 return NULL;
40891 }
40892
40893
40894 static PyObject *_wrap_GridSizer_GetCols(PyObject *, PyObject *args, PyObject *kwargs) {
40895 PyObject *resultobj;
40896 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40897 int result;
40898 PyObject * obj0 = 0 ;
40899 char *kwnames[] = {
40900 (char *) "self", NULL
40901 };
40902
40903 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetCols",kwnames,&obj0)) goto fail;
40904 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40905 if (SWIG_arg_fail(1)) SWIG_fail;
40906 {
40907 PyThreadState* __tstate = wxPyBeginAllowThreads();
40908 result = (int)(arg1)->GetCols();
40909
40910 wxPyEndAllowThreads(__tstate);
40911 if (PyErr_Occurred()) SWIG_fail;
40912 }
40913 {
40914 resultobj = SWIG_From_int((int)(result));
40915 }
40916 return resultobj;
40917 fail:
40918 return NULL;
40919 }
40920
40921
40922 static PyObject *_wrap_GridSizer_GetRows(PyObject *, PyObject *args, PyObject *kwargs) {
40923 PyObject *resultobj;
40924 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40925 int result;
40926 PyObject * obj0 = 0 ;
40927 char *kwnames[] = {
40928 (char *) "self", NULL
40929 };
40930
40931 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetRows",kwnames,&obj0)) goto fail;
40932 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40933 if (SWIG_arg_fail(1)) SWIG_fail;
40934 {
40935 PyThreadState* __tstate = wxPyBeginAllowThreads();
40936 result = (int)(arg1)->GetRows();
40937
40938 wxPyEndAllowThreads(__tstate);
40939 if (PyErr_Occurred()) SWIG_fail;
40940 }
40941 {
40942 resultobj = SWIG_From_int((int)(result));
40943 }
40944 return resultobj;
40945 fail:
40946 return NULL;
40947 }
40948
40949
40950 static PyObject *_wrap_GridSizer_GetVGap(PyObject *, PyObject *args, PyObject *kwargs) {
40951 PyObject *resultobj;
40952 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40953 int result;
40954 PyObject * obj0 = 0 ;
40955 char *kwnames[] = {
40956 (char *) "self", NULL
40957 };
40958
40959 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetVGap",kwnames,&obj0)) goto fail;
40960 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40961 if (SWIG_arg_fail(1)) SWIG_fail;
40962 {
40963 PyThreadState* __tstate = wxPyBeginAllowThreads();
40964 result = (int)(arg1)->GetVGap();
40965
40966 wxPyEndAllowThreads(__tstate);
40967 if (PyErr_Occurred()) SWIG_fail;
40968 }
40969 {
40970 resultobj = SWIG_From_int((int)(result));
40971 }
40972 return resultobj;
40973 fail:
40974 return NULL;
40975 }
40976
40977
40978 static PyObject *_wrap_GridSizer_GetHGap(PyObject *, PyObject *args, PyObject *kwargs) {
40979 PyObject *resultobj;
40980 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
40981 int result;
40982 PyObject * obj0 = 0 ;
40983 char *kwnames[] = {
40984 (char *) "self", NULL
40985 };
40986
40987 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridSizer_GetHGap",kwnames,&obj0)) goto fail;
40988 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridSizer, SWIG_POINTER_EXCEPTION | 0);
40989 if (SWIG_arg_fail(1)) SWIG_fail;
40990 {
40991 PyThreadState* __tstate = wxPyBeginAllowThreads();
40992 result = (int)(arg1)->GetHGap();
40993
40994 wxPyEndAllowThreads(__tstate);
40995 if (PyErr_Occurred()) SWIG_fail;
40996 }
40997 {
40998 resultobj = SWIG_From_int((int)(result));
40999 }
41000 return resultobj;
41001 fail:
41002 return NULL;
41003 }
41004
41005
41006 static PyObject * GridSizer_swigregister(PyObject *, PyObject *args) {
41007 PyObject *obj;
41008 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41009 SWIG_TypeClientData(SWIGTYPE_p_wxGridSizer, obj);
41010 Py_INCREF(obj);
41011 return Py_BuildValue((char *)"");
41012 }
41013 static PyObject *_wrap_new_FlexGridSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41014 PyObject *resultobj;
41015 int arg1 = (int) 1 ;
41016 int arg2 = (int) 0 ;
41017 int arg3 = (int) 0 ;
41018 int arg4 = (int) 0 ;
41019 wxFlexGridSizer *result;
41020 PyObject * obj0 = 0 ;
41021 PyObject * obj1 = 0 ;
41022 PyObject * obj2 = 0 ;
41023 PyObject * obj3 = 0 ;
41024 char *kwnames[] = {
41025 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
41026 };
41027
41028 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
41029 if (obj0) {
41030 {
41031 arg1 = (int)(SWIG_As_int(obj0));
41032 if (SWIG_arg_fail(1)) SWIG_fail;
41033 }
41034 }
41035 if (obj1) {
41036 {
41037 arg2 = (int)(SWIG_As_int(obj1));
41038 if (SWIG_arg_fail(2)) SWIG_fail;
41039 }
41040 }
41041 if (obj2) {
41042 {
41043 arg3 = (int)(SWIG_As_int(obj2));
41044 if (SWIG_arg_fail(3)) SWIG_fail;
41045 }
41046 }
41047 if (obj3) {
41048 {
41049 arg4 = (int)(SWIG_As_int(obj3));
41050 if (SWIG_arg_fail(4)) SWIG_fail;
41051 }
41052 }
41053 {
41054 PyThreadState* __tstate = wxPyBeginAllowThreads();
41055 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
41056
41057 wxPyEndAllowThreads(__tstate);
41058 if (PyErr_Occurred()) SWIG_fail;
41059 }
41060 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxFlexGridSizer, 1);
41061 return resultobj;
41062 fail:
41063 return NULL;
41064 }
41065
41066
41067 static PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41068 PyObject *resultobj;
41069 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41070 size_t arg2 ;
41071 int arg3 = (int) 0 ;
41072 PyObject * obj0 = 0 ;
41073 PyObject * obj1 = 0 ;
41074 PyObject * obj2 = 0 ;
41075 char *kwnames[] = {
41076 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41077 };
41078
41079 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) goto fail;
41080 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41081 if (SWIG_arg_fail(1)) SWIG_fail;
41082 {
41083 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41084 if (SWIG_arg_fail(2)) SWIG_fail;
41085 }
41086 if (obj2) {
41087 {
41088 arg3 = (int)(SWIG_As_int(obj2));
41089 if (SWIG_arg_fail(3)) SWIG_fail;
41090 }
41091 }
41092 {
41093 PyThreadState* __tstate = wxPyBeginAllowThreads();
41094 (arg1)->AddGrowableRow(arg2,arg3);
41095
41096 wxPyEndAllowThreads(__tstate);
41097 if (PyErr_Occurred()) SWIG_fail;
41098 }
41099 Py_INCREF(Py_None); resultobj = Py_None;
41100 return resultobj;
41101 fail:
41102 return NULL;
41103 }
41104
41105
41106 static PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *, PyObject *args, PyObject *kwargs) {
41107 PyObject *resultobj;
41108 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41109 size_t arg2 ;
41110 PyObject * obj0 = 0 ;
41111 PyObject * obj1 = 0 ;
41112 char *kwnames[] = {
41113 (char *) "self",(char *) "idx", NULL
41114 };
41115
41116 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) goto fail;
41117 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41118 if (SWIG_arg_fail(1)) SWIG_fail;
41119 {
41120 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41121 if (SWIG_arg_fail(2)) SWIG_fail;
41122 }
41123 {
41124 PyThreadState* __tstate = wxPyBeginAllowThreads();
41125 (arg1)->RemoveGrowableRow(arg2);
41126
41127 wxPyEndAllowThreads(__tstate);
41128 if (PyErr_Occurred()) SWIG_fail;
41129 }
41130 Py_INCREF(Py_None); resultobj = Py_None;
41131 return resultobj;
41132 fail:
41133 return NULL;
41134 }
41135
41136
41137 static PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41138 PyObject *resultobj;
41139 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41140 size_t arg2 ;
41141 int arg3 = (int) 0 ;
41142 PyObject * obj0 = 0 ;
41143 PyObject * obj1 = 0 ;
41144 PyObject * obj2 = 0 ;
41145 char *kwnames[] = {
41146 (char *) "self",(char *) "idx",(char *) "proportion", NULL
41147 };
41148
41149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) goto fail;
41150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41151 if (SWIG_arg_fail(1)) SWIG_fail;
41152 {
41153 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41154 if (SWIG_arg_fail(2)) SWIG_fail;
41155 }
41156 if (obj2) {
41157 {
41158 arg3 = (int)(SWIG_As_int(obj2));
41159 if (SWIG_arg_fail(3)) SWIG_fail;
41160 }
41161 }
41162 {
41163 PyThreadState* __tstate = wxPyBeginAllowThreads();
41164 (arg1)->AddGrowableCol(arg2,arg3);
41165
41166 wxPyEndAllowThreads(__tstate);
41167 if (PyErr_Occurred()) SWIG_fail;
41168 }
41169 Py_INCREF(Py_None); resultobj = Py_None;
41170 return resultobj;
41171 fail:
41172 return NULL;
41173 }
41174
41175
41176 static PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *, PyObject *args, PyObject *kwargs) {
41177 PyObject *resultobj;
41178 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41179 size_t arg2 ;
41180 PyObject * obj0 = 0 ;
41181 PyObject * obj1 = 0 ;
41182 char *kwnames[] = {
41183 (char *) "self",(char *) "idx", NULL
41184 };
41185
41186 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) goto fail;
41187 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41188 if (SWIG_arg_fail(1)) SWIG_fail;
41189 {
41190 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
41191 if (SWIG_arg_fail(2)) SWIG_fail;
41192 }
41193 {
41194 PyThreadState* __tstate = wxPyBeginAllowThreads();
41195 (arg1)->RemoveGrowableCol(arg2);
41196
41197 wxPyEndAllowThreads(__tstate);
41198 if (PyErr_Occurred()) SWIG_fail;
41199 }
41200 Py_INCREF(Py_None); resultobj = Py_None;
41201 return resultobj;
41202 fail:
41203 return NULL;
41204 }
41205
41206
41207 static PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41208 PyObject *resultobj;
41209 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41210 int arg2 ;
41211 PyObject * obj0 = 0 ;
41212 PyObject * obj1 = 0 ;
41213 char *kwnames[] = {
41214 (char *) "self",(char *) "direction", NULL
41215 };
41216
41217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) goto fail;
41218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41219 if (SWIG_arg_fail(1)) SWIG_fail;
41220 {
41221 arg2 = (int)(SWIG_As_int(obj1));
41222 if (SWIG_arg_fail(2)) SWIG_fail;
41223 }
41224 {
41225 PyThreadState* __tstate = wxPyBeginAllowThreads();
41226 (arg1)->SetFlexibleDirection(arg2);
41227
41228 wxPyEndAllowThreads(__tstate);
41229 if (PyErr_Occurred()) SWIG_fail;
41230 }
41231 Py_INCREF(Py_None); resultobj = Py_None;
41232 return resultobj;
41233 fail:
41234 return NULL;
41235 }
41236
41237
41238 static PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *, PyObject *args, PyObject *kwargs) {
41239 PyObject *resultobj;
41240 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41241 int result;
41242 PyObject * obj0 = 0 ;
41243 char *kwnames[] = {
41244 (char *) "self", NULL
41245 };
41246
41247 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetFlexibleDirection",kwnames,&obj0)) goto fail;
41248 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41249 if (SWIG_arg_fail(1)) SWIG_fail;
41250 {
41251 PyThreadState* __tstate = wxPyBeginAllowThreads();
41252 result = (int)(arg1)->GetFlexibleDirection();
41253
41254 wxPyEndAllowThreads(__tstate);
41255 if (PyErr_Occurred()) SWIG_fail;
41256 }
41257 {
41258 resultobj = SWIG_From_int((int)(result));
41259 }
41260 return resultobj;
41261 fail:
41262 return NULL;
41263 }
41264
41265
41266 static PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41267 PyObject *resultobj;
41268 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41269 wxFlexSizerGrowMode arg2 ;
41270 PyObject * obj0 = 0 ;
41271 PyObject * obj1 = 0 ;
41272 char *kwnames[] = {
41273 (char *) "self",(char *) "mode", NULL
41274 };
41275
41276 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) goto fail;
41277 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41278 if (SWIG_arg_fail(1)) SWIG_fail;
41279 {
41280 arg2 = (wxFlexSizerGrowMode)(SWIG_As_int(obj1));
41281 if (SWIG_arg_fail(2)) SWIG_fail;
41282 }
41283 {
41284 PyThreadState* __tstate = wxPyBeginAllowThreads();
41285 (arg1)->SetNonFlexibleGrowMode((wxFlexSizerGrowMode )arg2);
41286
41287 wxPyEndAllowThreads(__tstate);
41288 if (PyErr_Occurred()) SWIG_fail;
41289 }
41290 Py_INCREF(Py_None); resultobj = Py_None;
41291 return resultobj;
41292 fail:
41293 return NULL;
41294 }
41295
41296
41297 static PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *, PyObject *args, PyObject *kwargs) {
41298 PyObject *resultobj;
41299 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41300 wxFlexSizerGrowMode result;
41301 PyObject * obj0 = 0 ;
41302 char *kwnames[] = {
41303 (char *) "self", NULL
41304 };
41305
41306 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetNonFlexibleGrowMode",kwnames,&obj0)) goto fail;
41307 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41308 if (SWIG_arg_fail(1)) SWIG_fail;
41309 {
41310 PyThreadState* __tstate = wxPyBeginAllowThreads();
41311 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
41312
41313 wxPyEndAllowThreads(__tstate);
41314 if (PyErr_Occurred()) SWIG_fail;
41315 }
41316 resultobj = SWIG_From_int((result));
41317 return resultobj;
41318 fail:
41319 return NULL;
41320 }
41321
41322
41323 static PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *, PyObject *args, PyObject *kwargs) {
41324 PyObject *resultobj;
41325 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41326 wxArrayInt *result;
41327 PyObject * obj0 = 0 ;
41328 char *kwnames[] = {
41329 (char *) "self", NULL
41330 };
41331
41332 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetRowHeights",kwnames,&obj0)) goto fail;
41333 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41334 if (SWIG_arg_fail(1)) SWIG_fail;
41335 {
41336 PyThreadState* __tstate = wxPyBeginAllowThreads();
41337 {
41338 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
41339 result = (wxArrayInt *) &_result_ref;
41340 }
41341
41342 wxPyEndAllowThreads(__tstate);
41343 if (PyErr_Occurred()) SWIG_fail;
41344 }
41345 {
41346 resultobj = PyList_New(0);
41347 size_t idx;
41348 for (idx = 0; idx < result->GetCount(); idx += 1) {
41349 PyObject* val = PyInt_FromLong( result->Item(idx) );
41350 PyList_Append(resultobj, val);
41351 Py_DECREF(val);
41352 }
41353 }
41354 return resultobj;
41355 fail:
41356 return NULL;
41357 }
41358
41359
41360 static PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *, PyObject *args, PyObject *kwargs) {
41361 PyObject *resultobj;
41362 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
41363 wxArrayInt *result;
41364 PyObject * obj0 = 0 ;
41365 char *kwnames[] = {
41366 (char *) "self", NULL
41367 };
41368
41369 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FlexGridSizer_GetColWidths",kwnames,&obj0)) goto fail;
41370 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_EXCEPTION | 0);
41371 if (SWIG_arg_fail(1)) SWIG_fail;
41372 {
41373 PyThreadState* __tstate = wxPyBeginAllowThreads();
41374 {
41375 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
41376 result = (wxArrayInt *) &_result_ref;
41377 }
41378
41379 wxPyEndAllowThreads(__tstate);
41380 if (PyErr_Occurred()) SWIG_fail;
41381 }
41382 {
41383 resultobj = PyList_New(0);
41384 size_t idx;
41385 for (idx = 0; idx < result->GetCount(); idx += 1) {
41386 PyObject* val = PyInt_FromLong( result->Item(idx) );
41387 PyList_Append(resultobj, val);
41388 Py_DECREF(val);
41389 }
41390 }
41391 return resultobj;
41392 fail:
41393 return NULL;
41394 }
41395
41396
41397 static PyObject * FlexGridSizer_swigregister(PyObject *, PyObject *args) {
41398 PyObject *obj;
41399 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41400 SWIG_TypeClientData(SWIGTYPE_p_wxFlexGridSizer, obj);
41401 Py_INCREF(obj);
41402 return Py_BuildValue((char *)"");
41403 }
41404 static PyObject *_wrap_new_StdDialogButtonSizer(PyObject *, PyObject *args, PyObject *kwargs) {
41405 PyObject *resultobj;
41406 wxStdDialogButtonSizer *result;
41407 char *kwnames[] = {
41408 NULL
41409 };
41410
41411 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_StdDialogButtonSizer",kwnames)) goto fail;
41412 {
41413 PyThreadState* __tstate = wxPyBeginAllowThreads();
41414 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
41415
41416 wxPyEndAllowThreads(__tstate);
41417 if (PyErr_Occurred()) SWIG_fail;
41418 }
41419 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxStdDialogButtonSizer, 1);
41420 return resultobj;
41421 fail:
41422 return NULL;
41423 }
41424
41425
41426 static PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *, PyObject *args, PyObject *kwargs) {
41427 PyObject *resultobj;
41428 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41429 wxButton *arg2 = (wxButton *) 0 ;
41430 PyObject * obj0 = 0 ;
41431 PyObject * obj1 = 0 ;
41432 char *kwnames[] = {
41433 (char *) "self",(char *) "button", NULL
41434 };
41435
41436 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) goto fail;
41437 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41438 if (SWIG_arg_fail(1)) SWIG_fail;
41439 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41440 if (SWIG_arg_fail(2)) SWIG_fail;
41441 {
41442 PyThreadState* __tstate = wxPyBeginAllowThreads();
41443 (arg1)->AddButton(arg2);
41444
41445 wxPyEndAllowThreads(__tstate);
41446 if (PyErr_Occurred()) SWIG_fail;
41447 }
41448 Py_INCREF(Py_None); resultobj = Py_None;
41449 return resultobj;
41450 fail:
41451 return NULL;
41452 }
41453
41454
41455 static PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *, PyObject *args, PyObject *kwargs) {
41456 PyObject *resultobj;
41457 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41458 PyObject * obj0 = 0 ;
41459 char *kwnames[] = {
41460 (char *) "self", NULL
41461 };
41462
41463 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_Realize",kwnames,&obj0)) goto fail;
41464 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41465 if (SWIG_arg_fail(1)) SWIG_fail;
41466 {
41467 PyThreadState* __tstate = wxPyBeginAllowThreads();
41468 (arg1)->Realize();
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_StdDialogButtonSizer_SetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41481 PyObject *resultobj;
41482 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41483 wxButton *arg2 = (wxButton *) 0 ;
41484 PyObject * obj0 = 0 ;
41485 PyObject * obj1 = 0 ;
41486 char *kwnames[] = {
41487 (char *) "self",(char *) "button", NULL
41488 };
41489
41490 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) goto fail;
41491 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41492 if (SWIG_arg_fail(1)) SWIG_fail;
41493 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41494 if (SWIG_arg_fail(2)) SWIG_fail;
41495 {
41496 PyThreadState* __tstate = wxPyBeginAllowThreads();
41497 (arg1)->SetAffirmativeButton(arg2);
41498
41499 wxPyEndAllowThreads(__tstate);
41500 if (PyErr_Occurred()) SWIG_fail;
41501 }
41502 Py_INCREF(Py_None); resultobj = Py_None;
41503 return resultobj;
41504 fail:
41505 return NULL;
41506 }
41507
41508
41509 static PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41510 PyObject *resultobj;
41511 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41512 wxButton *arg2 = (wxButton *) 0 ;
41513 PyObject * obj0 = 0 ;
41514 PyObject * obj1 = 0 ;
41515 char *kwnames[] = {
41516 (char *) "self",(char *) "button", NULL
41517 };
41518
41519 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) goto fail;
41520 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41521 if (SWIG_arg_fail(1)) SWIG_fail;
41522 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41523 if (SWIG_arg_fail(2)) SWIG_fail;
41524 {
41525 PyThreadState* __tstate = wxPyBeginAllowThreads();
41526 (arg1)->SetNegativeButton(arg2);
41527
41528 wxPyEndAllowThreads(__tstate);
41529 if (PyErr_Occurred()) SWIG_fail;
41530 }
41531 Py_INCREF(Py_None); resultobj = Py_None;
41532 return resultobj;
41533 fail:
41534 return NULL;
41535 }
41536
41537
41538 static PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41539 PyObject *resultobj;
41540 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41541 wxButton *arg2 = (wxButton *) 0 ;
41542 PyObject * obj0 = 0 ;
41543 PyObject * obj1 = 0 ;
41544 char *kwnames[] = {
41545 (char *) "self",(char *) "button", NULL
41546 };
41547
41548 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) goto fail;
41549 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41550 if (SWIG_arg_fail(1)) SWIG_fail;
41551 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxButton, SWIG_POINTER_EXCEPTION | 0);
41552 if (SWIG_arg_fail(2)) SWIG_fail;
41553 {
41554 PyThreadState* __tstate = wxPyBeginAllowThreads();
41555 (arg1)->SetCancelButton(arg2);
41556
41557 wxPyEndAllowThreads(__tstate);
41558 if (PyErr_Occurred()) SWIG_fail;
41559 }
41560 Py_INCREF(Py_None); resultobj = Py_None;
41561 return resultobj;
41562 fail:
41563 return NULL;
41564 }
41565
41566
41567 static PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41568 PyObject *resultobj;
41569 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41570 wxButton *result;
41571 PyObject * obj0 = 0 ;
41572 char *kwnames[] = {
41573 (char *) "self", NULL
41574 };
41575
41576 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetAffirmativeButton",kwnames,&obj0)) goto fail;
41577 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41578 if (SWIG_arg_fail(1)) SWIG_fail;
41579 {
41580 PyThreadState* __tstate = wxPyBeginAllowThreads();
41581 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
41582
41583 wxPyEndAllowThreads(__tstate);
41584 if (PyErr_Occurred()) SWIG_fail;
41585 }
41586 {
41587 resultobj = wxPyMake_wxObject(result, 0);
41588 }
41589 return resultobj;
41590 fail:
41591 return NULL;
41592 }
41593
41594
41595 static PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *, PyObject *args, PyObject *kwargs) {
41596 PyObject *resultobj;
41597 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41598 wxButton *result;
41599 PyObject * obj0 = 0 ;
41600 char *kwnames[] = {
41601 (char *) "self", NULL
41602 };
41603
41604 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetApplyButton",kwnames,&obj0)) goto fail;
41605 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41606 if (SWIG_arg_fail(1)) SWIG_fail;
41607 {
41608 PyThreadState* __tstate = wxPyBeginAllowThreads();
41609 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
41610
41611 wxPyEndAllowThreads(__tstate);
41612 if (PyErr_Occurred()) SWIG_fail;
41613 }
41614 {
41615 resultobj = wxPyMake_wxObject(result, 0);
41616 }
41617 return resultobj;
41618 fail:
41619 return NULL;
41620 }
41621
41622
41623 static PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *, PyObject *args, PyObject *kwargs) {
41624 PyObject *resultobj;
41625 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41626 wxButton *result;
41627 PyObject * obj0 = 0 ;
41628 char *kwnames[] = {
41629 (char *) "self", NULL
41630 };
41631
41632 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetNegativeButton",kwnames,&obj0)) goto fail;
41633 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41634 if (SWIG_arg_fail(1)) SWIG_fail;
41635 {
41636 PyThreadState* __tstate = wxPyBeginAllowThreads();
41637 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
41638
41639 wxPyEndAllowThreads(__tstate);
41640 if (PyErr_Occurred()) SWIG_fail;
41641 }
41642 {
41643 resultobj = wxPyMake_wxObject(result, 0);
41644 }
41645 return resultobj;
41646 fail:
41647 return NULL;
41648 }
41649
41650
41651 static PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *, PyObject *args, PyObject *kwargs) {
41652 PyObject *resultobj;
41653 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41654 wxButton *result;
41655 PyObject * obj0 = 0 ;
41656 char *kwnames[] = {
41657 (char *) "self", NULL
41658 };
41659
41660 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetCancelButton",kwnames,&obj0)) goto fail;
41661 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41662 if (SWIG_arg_fail(1)) SWIG_fail;
41663 {
41664 PyThreadState* __tstate = wxPyBeginAllowThreads();
41665 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
41666
41667 wxPyEndAllowThreads(__tstate);
41668 if (PyErr_Occurred()) SWIG_fail;
41669 }
41670 {
41671 resultobj = wxPyMake_wxObject(result, 0);
41672 }
41673 return resultobj;
41674 fail:
41675 return NULL;
41676 }
41677
41678
41679 static PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *, PyObject *args, PyObject *kwargs) {
41680 PyObject *resultobj;
41681 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
41682 wxButton *result;
41683 PyObject * obj0 = 0 ;
41684 char *kwnames[] = {
41685 (char *) "self", NULL
41686 };
41687
41688 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:StdDialogButtonSizer_GetHelpButton",kwnames,&obj0)) goto fail;
41689 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_EXCEPTION | 0);
41690 if (SWIG_arg_fail(1)) SWIG_fail;
41691 {
41692 PyThreadState* __tstate = wxPyBeginAllowThreads();
41693 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
41694
41695 wxPyEndAllowThreads(__tstate);
41696 if (PyErr_Occurred()) SWIG_fail;
41697 }
41698 {
41699 resultobj = wxPyMake_wxObject(result, 0);
41700 }
41701 return resultobj;
41702 fail:
41703 return NULL;
41704 }
41705
41706
41707 static PyObject * StdDialogButtonSizer_swigregister(PyObject *, PyObject *args) {
41708 PyObject *obj;
41709 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
41710 SWIG_TypeClientData(SWIGTYPE_p_wxStdDialogButtonSizer, obj);
41711 Py_INCREF(obj);
41712 return Py_BuildValue((char *)"");
41713 }
41714 static PyObject *_wrap_new_GBPosition(PyObject *, PyObject *args, PyObject *kwargs) {
41715 PyObject *resultobj;
41716 int arg1 = (int) 0 ;
41717 int arg2 = (int) 0 ;
41718 wxGBPosition *result;
41719 PyObject * obj0 = 0 ;
41720 PyObject * obj1 = 0 ;
41721 char *kwnames[] = {
41722 (char *) "row",(char *) "col", NULL
41723 };
41724
41725 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) goto fail;
41726 if (obj0) {
41727 {
41728 arg1 = (int)(SWIG_As_int(obj0));
41729 if (SWIG_arg_fail(1)) SWIG_fail;
41730 }
41731 }
41732 if (obj1) {
41733 {
41734 arg2 = (int)(SWIG_As_int(obj1));
41735 if (SWIG_arg_fail(2)) SWIG_fail;
41736 }
41737 }
41738 {
41739 PyThreadState* __tstate = wxPyBeginAllowThreads();
41740 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
41741
41742 wxPyEndAllowThreads(__tstate);
41743 if (PyErr_Occurred()) SWIG_fail;
41744 }
41745 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBPosition, 1);
41746 return resultobj;
41747 fail:
41748 return NULL;
41749 }
41750
41751
41752 static PyObject *_wrap_GBPosition_GetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41753 PyObject *resultobj;
41754 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41755 int result;
41756 PyObject * obj0 = 0 ;
41757 char *kwnames[] = {
41758 (char *) "self", NULL
41759 };
41760
41761 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetRow",kwnames,&obj0)) goto fail;
41762 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41763 if (SWIG_arg_fail(1)) SWIG_fail;
41764 {
41765 PyThreadState* __tstate = wxPyBeginAllowThreads();
41766 result = (int)((wxGBPosition const *)arg1)->GetRow();
41767
41768 wxPyEndAllowThreads(__tstate);
41769 if (PyErr_Occurred()) SWIG_fail;
41770 }
41771 {
41772 resultobj = SWIG_From_int((int)(result));
41773 }
41774 return resultobj;
41775 fail:
41776 return NULL;
41777 }
41778
41779
41780 static PyObject *_wrap_GBPosition_GetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41781 PyObject *resultobj;
41782 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41783 int result;
41784 PyObject * obj0 = 0 ;
41785 char *kwnames[] = {
41786 (char *) "self", NULL
41787 };
41788
41789 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_GetCol",kwnames,&obj0)) goto fail;
41790 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41791 if (SWIG_arg_fail(1)) SWIG_fail;
41792 {
41793 PyThreadState* __tstate = wxPyBeginAllowThreads();
41794 result = (int)((wxGBPosition const *)arg1)->GetCol();
41795
41796 wxPyEndAllowThreads(__tstate);
41797 if (PyErr_Occurred()) SWIG_fail;
41798 }
41799 {
41800 resultobj = SWIG_From_int((int)(result));
41801 }
41802 return resultobj;
41803 fail:
41804 return NULL;
41805 }
41806
41807
41808 static PyObject *_wrap_GBPosition_SetRow(PyObject *, PyObject *args, PyObject *kwargs) {
41809 PyObject *resultobj;
41810 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41811 int arg2 ;
41812 PyObject * obj0 = 0 ;
41813 PyObject * obj1 = 0 ;
41814 char *kwnames[] = {
41815 (char *) "self",(char *) "row", NULL
41816 };
41817
41818 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) goto fail;
41819 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41820 if (SWIG_arg_fail(1)) SWIG_fail;
41821 {
41822 arg2 = (int)(SWIG_As_int(obj1));
41823 if (SWIG_arg_fail(2)) SWIG_fail;
41824 }
41825 {
41826 PyThreadState* __tstate = wxPyBeginAllowThreads();
41827 (arg1)->SetRow(arg2);
41828
41829 wxPyEndAllowThreads(__tstate);
41830 if (PyErr_Occurred()) SWIG_fail;
41831 }
41832 Py_INCREF(Py_None); resultobj = Py_None;
41833 return resultobj;
41834 fail:
41835 return NULL;
41836 }
41837
41838
41839 static PyObject *_wrap_GBPosition_SetCol(PyObject *, PyObject *args, PyObject *kwargs) {
41840 PyObject *resultobj;
41841 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41842 int arg2 ;
41843 PyObject * obj0 = 0 ;
41844 PyObject * obj1 = 0 ;
41845 char *kwnames[] = {
41846 (char *) "self",(char *) "col", NULL
41847 };
41848
41849 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) goto fail;
41850 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41851 if (SWIG_arg_fail(1)) SWIG_fail;
41852 {
41853 arg2 = (int)(SWIG_As_int(obj1));
41854 if (SWIG_arg_fail(2)) SWIG_fail;
41855 }
41856 {
41857 PyThreadState* __tstate = wxPyBeginAllowThreads();
41858 (arg1)->SetCol(arg2);
41859
41860 wxPyEndAllowThreads(__tstate);
41861 if (PyErr_Occurred()) SWIG_fail;
41862 }
41863 Py_INCREF(Py_None); resultobj = Py_None;
41864 return resultobj;
41865 fail:
41866 return NULL;
41867 }
41868
41869
41870 static PyObject *_wrap_GBPosition___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
41871 PyObject *resultobj;
41872 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41873 wxGBPosition *arg2 = 0 ;
41874 bool result;
41875 wxGBPosition temp2 ;
41876 PyObject * obj0 = 0 ;
41877 PyObject * obj1 = 0 ;
41878 char *kwnames[] = {
41879 (char *) "self",(char *) "other", NULL
41880 };
41881
41882 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) goto fail;
41883 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41884 if (SWIG_arg_fail(1)) SWIG_fail;
41885 {
41886 arg2 = &temp2;
41887 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41888 }
41889 {
41890 PyThreadState* __tstate = wxPyBeginAllowThreads();
41891 result = (bool)(arg1)->operator ==((wxGBPosition const &)*arg2);
41892
41893 wxPyEndAllowThreads(__tstate);
41894 if (PyErr_Occurred()) SWIG_fail;
41895 }
41896 {
41897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41898 }
41899 return resultobj;
41900 fail:
41901 return NULL;
41902 }
41903
41904
41905 static PyObject *_wrap_GBPosition___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
41906 PyObject *resultobj;
41907 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41908 wxGBPosition *arg2 = 0 ;
41909 bool result;
41910 wxGBPosition temp2 ;
41911 PyObject * obj0 = 0 ;
41912 PyObject * obj1 = 0 ;
41913 char *kwnames[] = {
41914 (char *) "self",(char *) "other", NULL
41915 };
41916
41917 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) goto fail;
41918 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41919 if (SWIG_arg_fail(1)) SWIG_fail;
41920 {
41921 arg2 = &temp2;
41922 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
41923 }
41924 {
41925 PyThreadState* __tstate = wxPyBeginAllowThreads();
41926 result = (bool)(arg1)->operator !=((wxGBPosition const &)*arg2);
41927
41928 wxPyEndAllowThreads(__tstate);
41929 if (PyErr_Occurred()) SWIG_fail;
41930 }
41931 {
41932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41933 }
41934 return resultobj;
41935 fail:
41936 return NULL;
41937 }
41938
41939
41940 static PyObject *_wrap_GBPosition_Set(PyObject *, PyObject *args, PyObject *kwargs) {
41941 PyObject *resultobj;
41942 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41943 int arg2 = (int) 0 ;
41944 int arg3 = (int) 0 ;
41945 PyObject * obj0 = 0 ;
41946 PyObject * obj1 = 0 ;
41947 PyObject * obj2 = 0 ;
41948 char *kwnames[] = {
41949 (char *) "self",(char *) "row",(char *) "col", NULL
41950 };
41951
41952 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
41953 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41954 if (SWIG_arg_fail(1)) SWIG_fail;
41955 if (obj1) {
41956 {
41957 arg2 = (int)(SWIG_As_int(obj1));
41958 if (SWIG_arg_fail(2)) SWIG_fail;
41959 }
41960 }
41961 if (obj2) {
41962 {
41963 arg3 = (int)(SWIG_As_int(obj2));
41964 if (SWIG_arg_fail(3)) SWIG_fail;
41965 }
41966 }
41967 {
41968 PyThreadState* __tstate = wxPyBeginAllowThreads();
41969 wxGBPosition_Set(arg1,arg2,arg3);
41970
41971 wxPyEndAllowThreads(__tstate);
41972 if (PyErr_Occurred()) SWIG_fail;
41973 }
41974 Py_INCREF(Py_None); resultobj = Py_None;
41975 return resultobj;
41976 fail:
41977 return NULL;
41978 }
41979
41980
41981 static PyObject *_wrap_GBPosition_Get(PyObject *, PyObject *args, PyObject *kwargs) {
41982 PyObject *resultobj;
41983 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
41984 PyObject *result;
41985 PyObject * obj0 = 0 ;
41986 char *kwnames[] = {
41987 (char *) "self", NULL
41988 };
41989
41990 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBPosition_Get",kwnames,&obj0)) goto fail;
41991 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBPosition, SWIG_POINTER_EXCEPTION | 0);
41992 if (SWIG_arg_fail(1)) SWIG_fail;
41993 {
41994 PyThreadState* __tstate = wxPyBeginAllowThreads();
41995 result = (PyObject *)wxGBPosition_Get(arg1);
41996
41997 wxPyEndAllowThreads(__tstate);
41998 if (PyErr_Occurred()) SWIG_fail;
41999 }
42000 resultobj = result;
42001 return resultobj;
42002 fail:
42003 return NULL;
42004 }
42005
42006
42007 static PyObject * GBPosition_swigregister(PyObject *, PyObject *args) {
42008 PyObject *obj;
42009 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42010 SWIG_TypeClientData(SWIGTYPE_p_wxGBPosition, obj);
42011 Py_INCREF(obj);
42012 return Py_BuildValue((char *)"");
42013 }
42014 static PyObject *_wrap_new_GBSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42015 PyObject *resultobj;
42016 int arg1 = (int) 1 ;
42017 int arg2 = (int) 1 ;
42018 wxGBSpan *result;
42019 PyObject * obj0 = 0 ;
42020 PyObject * obj1 = 0 ;
42021 char *kwnames[] = {
42022 (char *) "rowspan",(char *) "colspan", NULL
42023 };
42024
42025 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) goto fail;
42026 if (obj0) {
42027 {
42028 arg1 = (int)(SWIG_As_int(obj0));
42029 if (SWIG_arg_fail(1)) SWIG_fail;
42030 }
42031 }
42032 if (obj1) {
42033 {
42034 arg2 = (int)(SWIG_As_int(obj1));
42035 if (SWIG_arg_fail(2)) SWIG_fail;
42036 }
42037 }
42038 {
42039 PyThreadState* __tstate = wxPyBeginAllowThreads();
42040 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
42041
42042 wxPyEndAllowThreads(__tstate);
42043 if (PyErr_Occurred()) SWIG_fail;
42044 }
42045 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSpan, 1);
42046 return resultobj;
42047 fail:
42048 return NULL;
42049 }
42050
42051
42052 static PyObject *_wrap_GBSpan_GetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42053 PyObject *resultobj;
42054 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42055 int result;
42056 PyObject * obj0 = 0 ;
42057 char *kwnames[] = {
42058 (char *) "self", NULL
42059 };
42060
42061 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetRowspan",kwnames,&obj0)) goto fail;
42062 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42063 if (SWIG_arg_fail(1)) SWIG_fail;
42064 {
42065 PyThreadState* __tstate = wxPyBeginAllowThreads();
42066 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
42067
42068 wxPyEndAllowThreads(__tstate);
42069 if (PyErr_Occurred()) SWIG_fail;
42070 }
42071 {
42072 resultobj = SWIG_From_int((int)(result));
42073 }
42074 return resultobj;
42075 fail:
42076 return NULL;
42077 }
42078
42079
42080 static PyObject *_wrap_GBSpan_GetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42081 PyObject *resultobj;
42082 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42083 int result;
42084 PyObject * obj0 = 0 ;
42085 char *kwnames[] = {
42086 (char *) "self", NULL
42087 };
42088
42089 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_GetColspan",kwnames,&obj0)) goto fail;
42090 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42091 if (SWIG_arg_fail(1)) SWIG_fail;
42092 {
42093 PyThreadState* __tstate = wxPyBeginAllowThreads();
42094 result = (int)((wxGBSpan const *)arg1)->GetColspan();
42095
42096 wxPyEndAllowThreads(__tstate);
42097 if (PyErr_Occurred()) SWIG_fail;
42098 }
42099 {
42100 resultobj = SWIG_From_int((int)(result));
42101 }
42102 return resultobj;
42103 fail:
42104 return NULL;
42105 }
42106
42107
42108 static PyObject *_wrap_GBSpan_SetRowspan(PyObject *, PyObject *args, PyObject *kwargs) {
42109 PyObject *resultobj;
42110 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42111 int arg2 ;
42112 PyObject * obj0 = 0 ;
42113 PyObject * obj1 = 0 ;
42114 char *kwnames[] = {
42115 (char *) "self",(char *) "rowspan", NULL
42116 };
42117
42118 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) goto fail;
42119 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42120 if (SWIG_arg_fail(1)) SWIG_fail;
42121 {
42122 arg2 = (int)(SWIG_As_int(obj1));
42123 if (SWIG_arg_fail(2)) SWIG_fail;
42124 }
42125 {
42126 PyThreadState* __tstate = wxPyBeginAllowThreads();
42127 (arg1)->SetRowspan(arg2);
42128
42129 wxPyEndAllowThreads(__tstate);
42130 if (PyErr_Occurred()) SWIG_fail;
42131 }
42132 Py_INCREF(Py_None); resultobj = Py_None;
42133 return resultobj;
42134 fail:
42135 return NULL;
42136 }
42137
42138
42139 static PyObject *_wrap_GBSpan_SetColspan(PyObject *, PyObject *args, PyObject *kwargs) {
42140 PyObject *resultobj;
42141 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42142 int arg2 ;
42143 PyObject * obj0 = 0 ;
42144 PyObject * obj1 = 0 ;
42145 char *kwnames[] = {
42146 (char *) "self",(char *) "colspan", NULL
42147 };
42148
42149 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) goto fail;
42150 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42151 if (SWIG_arg_fail(1)) SWIG_fail;
42152 {
42153 arg2 = (int)(SWIG_As_int(obj1));
42154 if (SWIG_arg_fail(2)) SWIG_fail;
42155 }
42156 {
42157 PyThreadState* __tstate = wxPyBeginAllowThreads();
42158 (arg1)->SetColspan(arg2);
42159
42160 wxPyEndAllowThreads(__tstate);
42161 if (PyErr_Occurred()) SWIG_fail;
42162 }
42163 Py_INCREF(Py_None); resultobj = Py_None;
42164 return resultobj;
42165 fail:
42166 return NULL;
42167 }
42168
42169
42170 static PyObject *_wrap_GBSpan___eq__(PyObject *, PyObject *args, PyObject *kwargs) {
42171 PyObject *resultobj;
42172 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42173 wxGBSpan *arg2 = 0 ;
42174 bool result;
42175 wxGBSpan temp2 ;
42176 PyObject * obj0 = 0 ;
42177 PyObject * obj1 = 0 ;
42178 char *kwnames[] = {
42179 (char *) "self",(char *) "other", NULL
42180 };
42181
42182 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) goto fail;
42183 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42184 if (SWIG_arg_fail(1)) SWIG_fail;
42185 {
42186 arg2 = &temp2;
42187 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42188 }
42189 {
42190 PyThreadState* __tstate = wxPyBeginAllowThreads();
42191 result = (bool)(arg1)->operator ==((wxGBSpan const &)*arg2);
42192
42193 wxPyEndAllowThreads(__tstate);
42194 if (PyErr_Occurred()) SWIG_fail;
42195 }
42196 {
42197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42198 }
42199 return resultobj;
42200 fail:
42201 return NULL;
42202 }
42203
42204
42205 static PyObject *_wrap_GBSpan___ne__(PyObject *, PyObject *args, PyObject *kwargs) {
42206 PyObject *resultobj;
42207 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42208 wxGBSpan *arg2 = 0 ;
42209 bool result;
42210 wxGBSpan temp2 ;
42211 PyObject * obj0 = 0 ;
42212 PyObject * obj1 = 0 ;
42213 char *kwnames[] = {
42214 (char *) "self",(char *) "other", NULL
42215 };
42216
42217 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) goto fail;
42218 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42219 if (SWIG_arg_fail(1)) SWIG_fail;
42220 {
42221 arg2 = &temp2;
42222 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42223 }
42224 {
42225 PyThreadState* __tstate = wxPyBeginAllowThreads();
42226 result = (bool)(arg1)->operator !=((wxGBSpan const &)*arg2);
42227
42228 wxPyEndAllowThreads(__tstate);
42229 if (PyErr_Occurred()) SWIG_fail;
42230 }
42231 {
42232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42233 }
42234 return resultobj;
42235 fail:
42236 return NULL;
42237 }
42238
42239
42240 static PyObject *_wrap_GBSpan_Set(PyObject *, PyObject *args, PyObject *kwargs) {
42241 PyObject *resultobj;
42242 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42243 int arg2 = (int) 1 ;
42244 int arg3 = (int) 1 ;
42245 PyObject * obj0 = 0 ;
42246 PyObject * obj1 = 0 ;
42247 PyObject * obj2 = 0 ;
42248 char *kwnames[] = {
42249 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
42250 };
42251
42252 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) goto fail;
42253 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42254 if (SWIG_arg_fail(1)) SWIG_fail;
42255 if (obj1) {
42256 {
42257 arg2 = (int)(SWIG_As_int(obj1));
42258 if (SWIG_arg_fail(2)) SWIG_fail;
42259 }
42260 }
42261 if (obj2) {
42262 {
42263 arg3 = (int)(SWIG_As_int(obj2));
42264 if (SWIG_arg_fail(3)) SWIG_fail;
42265 }
42266 }
42267 {
42268 PyThreadState* __tstate = wxPyBeginAllowThreads();
42269 wxGBSpan_Set(arg1,arg2,arg3);
42270
42271 wxPyEndAllowThreads(__tstate);
42272 if (PyErr_Occurred()) SWIG_fail;
42273 }
42274 Py_INCREF(Py_None); resultobj = Py_None;
42275 return resultobj;
42276 fail:
42277 return NULL;
42278 }
42279
42280
42281 static PyObject *_wrap_GBSpan_Get(PyObject *, PyObject *args, PyObject *kwargs) {
42282 PyObject *resultobj;
42283 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
42284 PyObject *result;
42285 PyObject * obj0 = 0 ;
42286 char *kwnames[] = {
42287 (char *) "self", NULL
42288 };
42289
42290 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSpan_Get",kwnames,&obj0)) goto fail;
42291 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSpan, SWIG_POINTER_EXCEPTION | 0);
42292 if (SWIG_arg_fail(1)) SWIG_fail;
42293 {
42294 PyThreadState* __tstate = wxPyBeginAllowThreads();
42295 result = (PyObject *)wxGBSpan_Get(arg1);
42296
42297 wxPyEndAllowThreads(__tstate);
42298 if (PyErr_Occurred()) SWIG_fail;
42299 }
42300 resultobj = result;
42301 return resultobj;
42302 fail:
42303 return NULL;
42304 }
42305
42306
42307 static PyObject * GBSpan_swigregister(PyObject *, PyObject *args) {
42308 PyObject *obj;
42309 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42310 SWIG_TypeClientData(SWIGTYPE_p_wxGBSpan, obj);
42311 Py_INCREF(obj);
42312 return Py_BuildValue((char *)"");
42313 }
42314 static int _wrap_DefaultSpan_set(PyObject *) {
42315 PyErr_SetString(PyExc_TypeError,"Variable DefaultSpan is read-only.");
42316 return 1;
42317 }
42318
42319
42320 static PyObject *_wrap_DefaultSpan_get(void) {
42321 PyObject *pyobj;
42322
42323 pyobj = SWIG_NewPointerObj((void *)(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0);
42324 return pyobj;
42325 }
42326
42327
42328 static PyObject *_wrap_new_GBSizerItem(PyObject *, PyObject *args, PyObject *kwargs) {
42329 PyObject *resultobj;
42330 wxGBSizerItem *result;
42331 char *kwnames[] = {
42332 NULL
42333 };
42334
42335 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_GBSizerItem",kwnames)) goto fail;
42336 {
42337 PyThreadState* __tstate = wxPyBeginAllowThreads();
42338 result = (wxGBSizerItem *)new wxGBSizerItem();
42339
42340 wxPyEndAllowThreads(__tstate);
42341 if (PyErr_Occurred()) SWIG_fail;
42342 }
42343 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42344 return resultobj;
42345 fail:
42346 return NULL;
42347 }
42348
42349
42350 static PyObject *_wrap_new_GBSizerItemWindow(PyObject *, PyObject *args, PyObject *kwargs) {
42351 PyObject *resultobj;
42352 wxWindow *arg1 = (wxWindow *) 0 ;
42353 wxGBPosition *arg2 = 0 ;
42354 wxGBSpan *arg3 = 0 ;
42355 int arg4 ;
42356 int arg5 ;
42357 PyObject *arg6 = (PyObject *) NULL ;
42358 wxGBSizerItem *result;
42359 wxGBPosition temp2 ;
42360 wxGBSpan temp3 ;
42361 PyObject * obj0 = 0 ;
42362 PyObject * obj1 = 0 ;
42363 PyObject * obj2 = 0 ;
42364 PyObject * obj3 = 0 ;
42365 PyObject * obj4 = 0 ;
42366 PyObject * obj5 = 0 ;
42367 char *kwnames[] = {
42368 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42369 };
42370
42371 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42372 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
42373 if (SWIG_arg_fail(1)) SWIG_fail;
42374 {
42375 arg2 = &temp2;
42376 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42377 }
42378 {
42379 arg3 = &temp3;
42380 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42381 }
42382 {
42383 arg4 = (int)(SWIG_As_int(obj3));
42384 if (SWIG_arg_fail(4)) SWIG_fail;
42385 }
42386 {
42387 arg5 = (int)(SWIG_As_int(obj4));
42388 if (SWIG_arg_fail(5)) SWIG_fail;
42389 }
42390 if (obj5) {
42391 arg6 = obj5;
42392 }
42393 {
42394 PyThreadState* __tstate = wxPyBeginAllowThreads();
42395 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42396
42397 wxPyEndAllowThreads(__tstate);
42398 if (PyErr_Occurred()) SWIG_fail;
42399 }
42400 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42401 return resultobj;
42402 fail:
42403 return NULL;
42404 }
42405
42406
42407 static PyObject *_wrap_new_GBSizerItemSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42408 PyObject *resultobj;
42409 wxSizer *arg1 = (wxSizer *) 0 ;
42410 wxGBPosition *arg2 = 0 ;
42411 wxGBSpan *arg3 = 0 ;
42412 int arg4 ;
42413 int arg5 ;
42414 PyObject *arg6 = (PyObject *) NULL ;
42415 wxGBSizerItem *result;
42416 wxGBPosition temp2 ;
42417 wxGBSpan temp3 ;
42418 PyObject * obj0 = 0 ;
42419 PyObject * obj1 = 0 ;
42420 PyObject * obj2 = 0 ;
42421 PyObject * obj3 = 0 ;
42422 PyObject * obj4 = 0 ;
42423 PyObject * obj5 = 0 ;
42424 char *kwnames[] = {
42425 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42426 };
42427
42428 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
42429 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
42430 if (SWIG_arg_fail(1)) SWIG_fail;
42431 {
42432 arg2 = &temp2;
42433 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42434 }
42435 {
42436 arg3 = &temp3;
42437 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42438 }
42439 {
42440 arg4 = (int)(SWIG_As_int(obj3));
42441 if (SWIG_arg_fail(4)) SWIG_fail;
42442 }
42443 {
42444 arg5 = (int)(SWIG_As_int(obj4));
42445 if (SWIG_arg_fail(5)) SWIG_fail;
42446 }
42447 if (obj5) {
42448 arg6 = obj5;
42449 }
42450 {
42451 PyThreadState* __tstate = wxPyBeginAllowThreads();
42452 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
42453
42454 wxPyEndAllowThreads(__tstate);
42455 if (PyErr_Occurred()) SWIG_fail;
42456 }
42457 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42458 return resultobj;
42459 fail:
42460 return NULL;
42461 }
42462
42463
42464 static PyObject *_wrap_new_GBSizerItemSpacer(PyObject *, PyObject *args, PyObject *kwargs) {
42465 PyObject *resultobj;
42466 int arg1 ;
42467 int arg2 ;
42468 wxGBPosition *arg3 = 0 ;
42469 wxGBSpan *arg4 = 0 ;
42470 int arg5 ;
42471 int arg6 ;
42472 PyObject *arg7 = (PyObject *) NULL ;
42473 wxGBSizerItem *result;
42474 wxGBPosition temp3 ;
42475 wxGBSpan temp4 ;
42476 PyObject * obj0 = 0 ;
42477 PyObject * obj1 = 0 ;
42478 PyObject * obj2 = 0 ;
42479 PyObject * obj3 = 0 ;
42480 PyObject * obj4 = 0 ;
42481 PyObject * obj5 = 0 ;
42482 PyObject * obj6 = 0 ;
42483 char *kwnames[] = {
42484 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42485 };
42486
42487 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42488 {
42489 arg1 = (int)(SWIG_As_int(obj0));
42490 if (SWIG_arg_fail(1)) SWIG_fail;
42491 }
42492 {
42493 arg2 = (int)(SWIG_As_int(obj1));
42494 if (SWIG_arg_fail(2)) SWIG_fail;
42495 }
42496 {
42497 arg3 = &temp3;
42498 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42499 }
42500 {
42501 arg4 = &temp4;
42502 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42503 }
42504 {
42505 arg5 = (int)(SWIG_As_int(obj4));
42506 if (SWIG_arg_fail(5)) SWIG_fail;
42507 }
42508 {
42509 arg6 = (int)(SWIG_As_int(obj5));
42510 if (SWIG_arg_fail(6)) SWIG_fail;
42511 }
42512 if (obj6) {
42513 arg7 = obj6;
42514 }
42515 {
42516 PyThreadState* __tstate = wxPyBeginAllowThreads();
42517 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42518
42519 wxPyEndAllowThreads(__tstate);
42520 if (PyErr_Occurred()) SWIG_fail;
42521 }
42522 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 1);
42523 return resultobj;
42524 fail:
42525 return NULL;
42526 }
42527
42528
42529 static PyObject *_wrap_GBSizerItem_GetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42530 PyObject *resultobj;
42531 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42532 wxGBPosition result;
42533 PyObject * obj0 = 0 ;
42534 char *kwnames[] = {
42535 (char *) "self", NULL
42536 };
42537
42538 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetPos",kwnames,&obj0)) goto fail;
42539 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42540 if (SWIG_arg_fail(1)) SWIG_fail;
42541 {
42542 PyThreadState* __tstate = wxPyBeginAllowThreads();
42543 result = ((wxGBSizerItem const *)arg1)->GetPos();
42544
42545 wxPyEndAllowThreads(__tstate);
42546 if (PyErr_Occurred()) SWIG_fail;
42547 }
42548 {
42549 wxGBPosition * resultptr;
42550 resultptr = new wxGBPosition((wxGBPosition &)(result));
42551 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42552 }
42553 return resultobj;
42554 fail:
42555 return NULL;
42556 }
42557
42558
42559 static PyObject *_wrap_GBSizerItem_GetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42560 PyObject *resultobj;
42561 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42562 wxGBSpan result;
42563 PyObject * obj0 = 0 ;
42564 char *kwnames[] = {
42565 (char *) "self", NULL
42566 };
42567
42568 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetSpan",kwnames,&obj0)) goto fail;
42569 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42570 if (SWIG_arg_fail(1)) SWIG_fail;
42571 {
42572 PyThreadState* __tstate = wxPyBeginAllowThreads();
42573 result = ((wxGBSizerItem const *)arg1)->GetSpan();
42574
42575 wxPyEndAllowThreads(__tstate);
42576 if (PyErr_Occurred()) SWIG_fail;
42577 }
42578 {
42579 wxGBSpan * resultptr;
42580 resultptr = new wxGBSpan((wxGBSpan &)(result));
42581 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
42582 }
42583 return resultobj;
42584 fail:
42585 return NULL;
42586 }
42587
42588
42589 static PyObject *_wrap_GBSizerItem_SetPos(PyObject *, PyObject *args, PyObject *kwargs) {
42590 PyObject *resultobj;
42591 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42592 wxGBPosition *arg2 = 0 ;
42593 bool result;
42594 wxGBPosition temp2 ;
42595 PyObject * obj0 = 0 ;
42596 PyObject * obj1 = 0 ;
42597 char *kwnames[] = {
42598 (char *) "self",(char *) "pos", NULL
42599 };
42600
42601 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) goto fail;
42602 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42603 if (SWIG_arg_fail(1)) SWIG_fail;
42604 {
42605 arg2 = &temp2;
42606 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42607 }
42608 {
42609 PyThreadState* __tstate = wxPyBeginAllowThreads();
42610 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
42611
42612 wxPyEndAllowThreads(__tstate);
42613 if (PyErr_Occurred()) SWIG_fail;
42614 }
42615 {
42616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42617 }
42618 return resultobj;
42619 fail:
42620 return NULL;
42621 }
42622
42623
42624 static PyObject *_wrap_GBSizerItem_SetSpan(PyObject *, PyObject *args, PyObject *kwargs) {
42625 PyObject *resultobj;
42626 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42627 wxGBSpan *arg2 = 0 ;
42628 bool result;
42629 wxGBSpan temp2 ;
42630 PyObject * obj0 = 0 ;
42631 PyObject * obj1 = 0 ;
42632 char *kwnames[] = {
42633 (char *) "self",(char *) "span", NULL
42634 };
42635
42636 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) goto fail;
42637 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42638 if (SWIG_arg_fail(1)) SWIG_fail;
42639 {
42640 arg2 = &temp2;
42641 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
42642 }
42643 {
42644 PyThreadState* __tstate = wxPyBeginAllowThreads();
42645 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
42646
42647 wxPyEndAllowThreads(__tstate);
42648 if (PyErr_Occurred()) SWIG_fail;
42649 }
42650 {
42651 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42652 }
42653 return resultobj;
42654 fail:
42655 return NULL;
42656 }
42657
42658
42659 static PyObject *_wrap_GBSizerItem_Intersects(PyObject *, PyObject *args, PyObject *kwargs) {
42660 PyObject *resultobj;
42661 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42662 wxGBSizerItem *arg2 = 0 ;
42663 bool result;
42664 PyObject * obj0 = 0 ;
42665 PyObject * obj1 = 0 ;
42666 char *kwnames[] = {
42667 (char *) "self",(char *) "other", NULL
42668 };
42669
42670 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) goto fail;
42671 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42672 if (SWIG_arg_fail(1)) SWIG_fail;
42673 {
42674 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42675 if (SWIG_arg_fail(2)) SWIG_fail;
42676 if (arg2 == NULL) {
42677 SWIG_null_ref("wxGBSizerItem");
42678 }
42679 if (SWIG_arg_fail(2)) SWIG_fail;
42680 }
42681 {
42682 PyThreadState* __tstate = wxPyBeginAllowThreads();
42683 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
42684
42685 wxPyEndAllowThreads(__tstate);
42686 if (PyErr_Occurred()) SWIG_fail;
42687 }
42688 {
42689 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42690 }
42691 return resultobj;
42692 fail:
42693 return NULL;
42694 }
42695
42696
42697 static PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *, PyObject *args, PyObject *kwargs) {
42698 PyObject *resultobj;
42699 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42700 wxGBPosition *arg2 = 0 ;
42701 wxGBSpan *arg3 = 0 ;
42702 bool result;
42703 wxGBPosition temp2 ;
42704 wxGBSpan temp3 ;
42705 PyObject * obj0 = 0 ;
42706 PyObject * obj1 = 0 ;
42707 PyObject * obj2 = 0 ;
42708 char *kwnames[] = {
42709 (char *) "self",(char *) "pos",(char *) "span", NULL
42710 };
42711
42712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) goto fail;
42713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42714 if (SWIG_arg_fail(1)) SWIG_fail;
42715 {
42716 arg2 = &temp2;
42717 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
42718 }
42719 {
42720 arg3 = &temp3;
42721 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
42722 }
42723 {
42724 PyThreadState* __tstate = wxPyBeginAllowThreads();
42725 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
42726
42727 wxPyEndAllowThreads(__tstate);
42728 if (PyErr_Occurred()) SWIG_fail;
42729 }
42730 {
42731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42732 }
42733 return resultobj;
42734 fail:
42735 return NULL;
42736 }
42737
42738
42739 static PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *, PyObject *args, PyObject *kwargs) {
42740 PyObject *resultobj;
42741 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42742 wxGBPosition result;
42743 PyObject * obj0 = 0 ;
42744 char *kwnames[] = {
42745 (char *) "self", NULL
42746 };
42747
42748 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetEndPos",kwnames,&obj0)) goto fail;
42749 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42750 if (SWIG_arg_fail(1)) SWIG_fail;
42751 {
42752 PyThreadState* __tstate = wxPyBeginAllowThreads();
42753 result = wxGBSizerItem_GetEndPos(arg1);
42754
42755 wxPyEndAllowThreads(__tstate);
42756 if (PyErr_Occurred()) SWIG_fail;
42757 }
42758 {
42759 wxGBPosition * resultptr;
42760 resultptr = new wxGBPosition((wxGBPosition &)(result));
42761 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
42762 }
42763 return resultobj;
42764 fail:
42765 return NULL;
42766 }
42767
42768
42769 static PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42770 PyObject *resultobj;
42771 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42772 wxGridBagSizer *result;
42773 PyObject * obj0 = 0 ;
42774 char *kwnames[] = {
42775 (char *) "self", NULL
42776 };
42777
42778 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GBSizerItem_GetGBSizer",kwnames,&obj0)) goto fail;
42779 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42780 if (SWIG_arg_fail(1)) SWIG_fail;
42781 {
42782 PyThreadState* __tstate = wxPyBeginAllowThreads();
42783 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
42784
42785 wxPyEndAllowThreads(__tstate);
42786 if (PyErr_Occurred()) SWIG_fail;
42787 }
42788 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 0);
42789 return resultobj;
42790 fail:
42791 return NULL;
42792 }
42793
42794
42795 static PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42796 PyObject *resultobj;
42797 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
42798 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
42799 PyObject * obj0 = 0 ;
42800 PyObject * obj1 = 0 ;
42801 char *kwnames[] = {
42802 (char *) "self",(char *) "sizer", NULL
42803 };
42804
42805 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) goto fail;
42806 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42807 if (SWIG_arg_fail(1)) SWIG_fail;
42808 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42809 if (SWIG_arg_fail(2)) SWIG_fail;
42810 {
42811 PyThreadState* __tstate = wxPyBeginAllowThreads();
42812 (arg1)->SetGBSizer(arg2);
42813
42814 wxPyEndAllowThreads(__tstate);
42815 if (PyErr_Occurred()) SWIG_fail;
42816 }
42817 Py_INCREF(Py_None); resultobj = Py_None;
42818 return resultobj;
42819 fail:
42820 return NULL;
42821 }
42822
42823
42824 static PyObject * GBSizerItem_swigregister(PyObject *, PyObject *args) {
42825 PyObject *obj;
42826 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
42827 SWIG_TypeClientData(SWIGTYPE_p_wxGBSizerItem, obj);
42828 Py_INCREF(obj);
42829 return Py_BuildValue((char *)"");
42830 }
42831 static PyObject *_wrap_new_GridBagSizer(PyObject *, PyObject *args, PyObject *kwargs) {
42832 PyObject *resultobj;
42833 int arg1 = (int) 0 ;
42834 int arg2 = (int) 0 ;
42835 wxGridBagSizer *result;
42836 PyObject * obj0 = 0 ;
42837 PyObject * obj1 = 0 ;
42838 char *kwnames[] = {
42839 (char *) "vgap",(char *) "hgap", NULL
42840 };
42841
42842 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) goto fail;
42843 if (obj0) {
42844 {
42845 arg1 = (int)(SWIG_As_int(obj0));
42846 if (SWIG_arg_fail(1)) SWIG_fail;
42847 }
42848 }
42849 if (obj1) {
42850 {
42851 arg2 = (int)(SWIG_As_int(obj1));
42852 if (SWIG_arg_fail(2)) SWIG_fail;
42853 }
42854 }
42855 {
42856 PyThreadState* __tstate = wxPyBeginAllowThreads();
42857 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
42858
42859 wxPyEndAllowThreads(__tstate);
42860 if (PyErr_Occurred()) SWIG_fail;
42861 }
42862 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGridBagSizer, 1);
42863 return resultobj;
42864 fail:
42865 return NULL;
42866 }
42867
42868
42869 static PyObject *_wrap_GridBagSizer_Add(PyObject *, PyObject *args, PyObject *kwargs) {
42870 PyObject *resultobj;
42871 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42872 PyObject *arg2 = (PyObject *) 0 ;
42873 wxGBPosition *arg3 = 0 ;
42874 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
42875 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
42876 int arg5 = (int) 0 ;
42877 int arg6 = (int) 0 ;
42878 PyObject *arg7 = (PyObject *) NULL ;
42879 wxGBSizerItem *result;
42880 wxGBPosition temp3 ;
42881 wxGBSpan temp4 ;
42882 PyObject * obj0 = 0 ;
42883 PyObject * obj1 = 0 ;
42884 PyObject * obj2 = 0 ;
42885 PyObject * obj3 = 0 ;
42886 PyObject * obj4 = 0 ;
42887 PyObject * obj5 = 0 ;
42888 PyObject * obj6 = 0 ;
42889 char *kwnames[] = {
42890 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
42891 };
42892
42893 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) goto fail;
42894 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42895 if (SWIG_arg_fail(1)) SWIG_fail;
42896 arg2 = obj1;
42897 {
42898 arg3 = &temp3;
42899 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
42900 }
42901 if (obj3) {
42902 {
42903 arg4 = &temp4;
42904 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
42905 }
42906 }
42907 if (obj4) {
42908 {
42909 arg5 = (int)(SWIG_As_int(obj4));
42910 if (SWIG_arg_fail(5)) SWIG_fail;
42911 }
42912 }
42913 if (obj5) {
42914 {
42915 arg6 = (int)(SWIG_As_int(obj5));
42916 if (SWIG_arg_fail(6)) SWIG_fail;
42917 }
42918 }
42919 if (obj6) {
42920 arg7 = obj6;
42921 }
42922 {
42923 PyThreadState* __tstate = wxPyBeginAllowThreads();
42924 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
42925
42926 wxPyEndAllowThreads(__tstate);
42927 if (PyErr_Occurred()) SWIG_fail;
42928 }
42929 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42930 return resultobj;
42931 fail:
42932 return NULL;
42933 }
42934
42935
42936 static PyObject *_wrap_GridBagSizer_AddItem(PyObject *, PyObject *args, PyObject *kwargs) {
42937 PyObject *resultobj;
42938 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42939 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
42940 wxGBSizerItem *result;
42941 PyObject * obj0 = 0 ;
42942 PyObject * obj1 = 0 ;
42943 char *kwnames[] = {
42944 (char *) "self",(char *) "item", NULL
42945 };
42946
42947 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) goto fail;
42948 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42949 if (SWIG_arg_fail(1)) SWIG_fail;
42950 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
42951 if (SWIG_arg_fail(2)) SWIG_fail;
42952 {
42953 PyThreadState* __tstate = wxPyBeginAllowThreads();
42954 result = (wxGBSizerItem *)(arg1)->Add(arg2);
42955
42956 wxPyEndAllowThreads(__tstate);
42957 if (PyErr_Occurred()) SWIG_fail;
42958 }
42959 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
42960 return resultobj;
42961 fail:
42962 return NULL;
42963 }
42964
42965
42966 static PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
42967 PyObject *resultobj;
42968 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
42969 int arg2 ;
42970 int arg3 ;
42971 wxSize result;
42972 PyObject * obj0 = 0 ;
42973 PyObject * obj1 = 0 ;
42974 PyObject * obj2 = 0 ;
42975 char *kwnames[] = {
42976 (char *) "self",(char *) "row",(char *) "col", NULL
42977 };
42978
42979 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) goto fail;
42980 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
42981 if (SWIG_arg_fail(1)) SWIG_fail;
42982 {
42983 arg2 = (int)(SWIG_As_int(obj1));
42984 if (SWIG_arg_fail(2)) SWIG_fail;
42985 }
42986 {
42987 arg3 = (int)(SWIG_As_int(obj2));
42988 if (SWIG_arg_fail(3)) SWIG_fail;
42989 }
42990 {
42991 PyThreadState* __tstate = wxPyBeginAllowThreads();
42992 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
42993
42994 wxPyEndAllowThreads(__tstate);
42995 if (PyErr_Occurred()) SWIG_fail;
42996 }
42997 {
42998 wxSize * resultptr;
42999 resultptr = new wxSize((wxSize &)(result));
43000 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43001 }
43002 return resultobj;
43003 fail:
43004 return NULL;
43005 }
43006
43007
43008 static PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43009 PyObject *resultobj;
43010 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43011 wxSize result;
43012 PyObject * obj0 = 0 ;
43013 char *kwnames[] = {
43014 (char *) "self", NULL
43015 };
43016
43017 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GridBagSizer_GetEmptyCellSize",kwnames,&obj0)) goto fail;
43018 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43019 if (SWIG_arg_fail(1)) SWIG_fail;
43020 {
43021 PyThreadState* __tstate = wxPyBeginAllowThreads();
43022 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
43023
43024 wxPyEndAllowThreads(__tstate);
43025 if (PyErr_Occurred()) SWIG_fail;
43026 }
43027 {
43028 wxSize * resultptr;
43029 resultptr = new wxSize((wxSize &)(result));
43030 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxSize, 1);
43031 }
43032 return resultobj;
43033 fail:
43034 return NULL;
43035 }
43036
43037
43038 static PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *, PyObject *args, PyObject *kwargs) {
43039 PyObject *resultobj;
43040 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43041 wxSize *arg2 = 0 ;
43042 wxSize temp2 ;
43043 PyObject * obj0 = 0 ;
43044 PyObject * obj1 = 0 ;
43045 char *kwnames[] = {
43046 (char *) "self",(char *) "sz", NULL
43047 };
43048
43049 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) goto fail;
43050 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43051 if (SWIG_arg_fail(1)) SWIG_fail;
43052 {
43053 arg2 = &temp2;
43054 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
43055 }
43056 {
43057 PyThreadState* __tstate = wxPyBeginAllowThreads();
43058 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
43059
43060 wxPyEndAllowThreads(__tstate);
43061 if (PyErr_Occurred()) SWIG_fail;
43062 }
43063 Py_INCREF(Py_None); resultobj = Py_None;
43064 return resultobj;
43065 fail:
43066 return NULL;
43067 }
43068
43069
43070 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43071 PyObject *resultobj;
43072 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43073 wxWindow *arg2 = (wxWindow *) 0 ;
43074 wxGBPosition result;
43075 PyObject * obj0 = 0 ;
43076 PyObject * obj1 = 0 ;
43077
43078 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43079 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43080 if (SWIG_arg_fail(1)) SWIG_fail;
43081 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43082 if (SWIG_arg_fail(2)) SWIG_fail;
43083 {
43084 PyThreadState* __tstate = wxPyBeginAllowThreads();
43085 result = (arg1)->GetItemPosition(arg2);
43086
43087 wxPyEndAllowThreads(__tstate);
43088 if (PyErr_Occurred()) SWIG_fail;
43089 }
43090 {
43091 wxGBPosition * resultptr;
43092 resultptr = new wxGBPosition((wxGBPosition &)(result));
43093 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43094 }
43095 return resultobj;
43096 fail:
43097 return NULL;
43098 }
43099
43100
43101 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43102 PyObject *resultobj;
43103 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43104 wxSizer *arg2 = (wxSizer *) 0 ;
43105 wxGBPosition result;
43106 PyObject * obj0 = 0 ;
43107 PyObject * obj1 = 0 ;
43108
43109 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43110 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43111 if (SWIG_arg_fail(1)) SWIG_fail;
43112 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43113 if (SWIG_arg_fail(2)) SWIG_fail;
43114 {
43115 PyThreadState* __tstate = wxPyBeginAllowThreads();
43116 result = (arg1)->GetItemPosition(arg2);
43117
43118 wxPyEndAllowThreads(__tstate);
43119 if (PyErr_Occurred()) SWIG_fail;
43120 }
43121 {
43122 wxGBPosition * resultptr;
43123 resultptr = new wxGBPosition((wxGBPosition &)(result));
43124 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43125 }
43126 return resultobj;
43127 fail:
43128 return NULL;
43129 }
43130
43131
43132 static PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43133 PyObject *resultobj;
43134 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43135 size_t arg2 ;
43136 wxGBPosition result;
43137 PyObject * obj0 = 0 ;
43138 PyObject * obj1 = 0 ;
43139
43140 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemPosition",&obj0,&obj1)) goto fail;
43141 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43142 if (SWIG_arg_fail(1)) SWIG_fail;
43143 {
43144 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43145 if (SWIG_arg_fail(2)) SWIG_fail;
43146 }
43147 {
43148 PyThreadState* __tstate = wxPyBeginAllowThreads();
43149 result = (arg1)->GetItemPosition(arg2);
43150
43151 wxPyEndAllowThreads(__tstate);
43152 if (PyErr_Occurred()) SWIG_fail;
43153 }
43154 {
43155 wxGBPosition * resultptr;
43156 resultptr = new wxGBPosition((wxGBPosition &)(result));
43157 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBPosition, 1);
43158 }
43159 return resultobj;
43160 fail:
43161 return NULL;
43162 }
43163
43164
43165 static PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
43166 int argc;
43167 PyObject *argv[3];
43168 int ii;
43169
43170 argc = PyObject_Length(args);
43171 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43172 argv[ii] = PyTuple_GetItem(args,ii);
43173 }
43174 if (argc == 2) {
43175 int _v;
43176 {
43177 void *ptr;
43178 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43179 _v = 0;
43180 PyErr_Clear();
43181 } else {
43182 _v = 1;
43183 }
43184 }
43185 if (_v) {
43186 {
43187 void *ptr;
43188 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43189 _v = 0;
43190 PyErr_Clear();
43191 } else {
43192 _v = 1;
43193 }
43194 }
43195 if (_v) {
43196 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self,args);
43197 }
43198 }
43199 }
43200 if (argc == 2) {
43201 int _v;
43202 {
43203 void *ptr;
43204 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43205 _v = 0;
43206 PyErr_Clear();
43207 } else {
43208 _v = 1;
43209 }
43210 }
43211 if (_v) {
43212 {
43213 void *ptr;
43214 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43215 _v = 0;
43216 PyErr_Clear();
43217 } else {
43218 _v = 1;
43219 }
43220 }
43221 if (_v) {
43222 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self,args);
43223 }
43224 }
43225 }
43226 if (argc == 2) {
43227 int _v;
43228 {
43229 void *ptr;
43230 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43231 _v = 0;
43232 PyErr_Clear();
43233 } else {
43234 _v = 1;
43235 }
43236 }
43237 if (_v) {
43238 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43239 if (_v) {
43240 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self,args);
43241 }
43242 }
43243 }
43244
43245 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
43246 return NULL;
43247 }
43248
43249
43250 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *, PyObject *args) {
43251 PyObject *resultobj;
43252 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43253 wxWindow *arg2 = (wxWindow *) 0 ;
43254 wxGBPosition *arg3 = 0 ;
43255 bool result;
43256 wxGBPosition temp3 ;
43257 PyObject * obj0 = 0 ;
43258 PyObject * obj1 = 0 ;
43259 PyObject * obj2 = 0 ;
43260
43261 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43262 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43263 if (SWIG_arg_fail(1)) SWIG_fail;
43264 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43265 if (SWIG_arg_fail(2)) SWIG_fail;
43266 {
43267 arg3 = &temp3;
43268 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43269 }
43270 {
43271 PyThreadState* __tstate = wxPyBeginAllowThreads();
43272 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43273
43274 wxPyEndAllowThreads(__tstate);
43275 if (PyErr_Occurred()) SWIG_fail;
43276 }
43277 {
43278 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43279 }
43280 return resultobj;
43281 fail:
43282 return NULL;
43283 }
43284
43285
43286 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *, PyObject *args) {
43287 PyObject *resultobj;
43288 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43289 wxSizer *arg2 = (wxSizer *) 0 ;
43290 wxGBPosition *arg3 = 0 ;
43291 bool result;
43292 wxGBPosition temp3 ;
43293 PyObject * obj0 = 0 ;
43294 PyObject * obj1 = 0 ;
43295 PyObject * obj2 = 0 ;
43296
43297 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43298 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43299 if (SWIG_arg_fail(1)) SWIG_fail;
43300 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43301 if (SWIG_arg_fail(2)) SWIG_fail;
43302 {
43303 arg3 = &temp3;
43304 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43305 }
43306 {
43307 PyThreadState* __tstate = wxPyBeginAllowThreads();
43308 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43309
43310 wxPyEndAllowThreads(__tstate);
43311 if (PyErr_Occurred()) SWIG_fail;
43312 }
43313 {
43314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43315 }
43316 return resultobj;
43317 fail:
43318 return NULL;
43319 }
43320
43321
43322 static PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *, PyObject *args) {
43323 PyObject *resultobj;
43324 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43325 size_t arg2 ;
43326 wxGBPosition *arg3 = 0 ;
43327 bool result;
43328 wxGBPosition temp3 ;
43329 PyObject * obj0 = 0 ;
43330 PyObject * obj1 = 0 ;
43331 PyObject * obj2 = 0 ;
43332
43333 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemPosition",&obj0,&obj1,&obj2)) goto fail;
43334 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43335 if (SWIG_arg_fail(1)) SWIG_fail;
43336 {
43337 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43338 if (SWIG_arg_fail(2)) SWIG_fail;
43339 }
43340 {
43341 arg3 = &temp3;
43342 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
43343 }
43344 {
43345 PyThreadState* __tstate = wxPyBeginAllowThreads();
43346 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
43347
43348 wxPyEndAllowThreads(__tstate);
43349 if (PyErr_Occurred()) SWIG_fail;
43350 }
43351 {
43352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43353 }
43354 return resultobj;
43355 fail:
43356 return NULL;
43357 }
43358
43359
43360 static PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
43361 int argc;
43362 PyObject *argv[4];
43363 int ii;
43364
43365 argc = PyObject_Length(args);
43366 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43367 argv[ii] = PyTuple_GetItem(args,ii);
43368 }
43369 if (argc == 3) {
43370 int _v;
43371 {
43372 void *ptr;
43373 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43374 _v = 0;
43375 PyErr_Clear();
43376 } else {
43377 _v = 1;
43378 }
43379 }
43380 if (_v) {
43381 {
43382 void *ptr;
43383 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43384 _v = 0;
43385 PyErr_Clear();
43386 } else {
43387 _v = 1;
43388 }
43389 }
43390 if (_v) {
43391 {
43392 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43393 }
43394 if (_v) {
43395 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self,args);
43396 }
43397 }
43398 }
43399 }
43400 if (argc == 3) {
43401 int _v;
43402 {
43403 void *ptr;
43404 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43405 _v = 0;
43406 PyErr_Clear();
43407 } else {
43408 _v = 1;
43409 }
43410 }
43411 if (_v) {
43412 {
43413 void *ptr;
43414 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43415 _v = 0;
43416 PyErr_Clear();
43417 } else {
43418 _v = 1;
43419 }
43420 }
43421 if (_v) {
43422 {
43423 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43424 }
43425 if (_v) {
43426 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self,args);
43427 }
43428 }
43429 }
43430 }
43431 if (argc == 3) {
43432 int _v;
43433 {
43434 void *ptr;
43435 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43436 _v = 0;
43437 PyErr_Clear();
43438 } else {
43439 _v = 1;
43440 }
43441 }
43442 if (_v) {
43443 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43444 if (_v) {
43445 {
43446 _v = wxPySimple_typecheck(argv[2], wxT("wxGBPosition"), 2);
43447 }
43448 if (_v) {
43449 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self,args);
43450 }
43451 }
43452 }
43453 }
43454
43455 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
43456 return NULL;
43457 }
43458
43459
43460 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43461 PyObject *resultobj;
43462 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43463 wxWindow *arg2 = (wxWindow *) 0 ;
43464 wxGBSpan result;
43465 PyObject * obj0 = 0 ;
43466 PyObject * obj1 = 0 ;
43467
43468 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43469 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43470 if (SWIG_arg_fail(1)) SWIG_fail;
43471 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43472 if (SWIG_arg_fail(2)) SWIG_fail;
43473 {
43474 PyThreadState* __tstate = wxPyBeginAllowThreads();
43475 result = (arg1)->GetItemSpan(arg2);
43476
43477 wxPyEndAllowThreads(__tstate);
43478 if (PyErr_Occurred()) SWIG_fail;
43479 }
43480 {
43481 wxGBSpan * resultptr;
43482 resultptr = new wxGBSpan((wxGBSpan &)(result));
43483 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43484 }
43485 return resultobj;
43486 fail:
43487 return NULL;
43488 }
43489
43490
43491 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43492 PyObject *resultobj;
43493 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43494 wxSizer *arg2 = (wxSizer *) 0 ;
43495 wxGBSpan result;
43496 PyObject * obj0 = 0 ;
43497 PyObject * obj1 = 0 ;
43498
43499 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43500 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43501 if (SWIG_arg_fail(1)) SWIG_fail;
43502 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43503 if (SWIG_arg_fail(2)) SWIG_fail;
43504 {
43505 PyThreadState* __tstate = wxPyBeginAllowThreads();
43506 result = (arg1)->GetItemSpan(arg2);
43507
43508 wxPyEndAllowThreads(__tstate);
43509 if (PyErr_Occurred()) SWIG_fail;
43510 }
43511 {
43512 wxGBSpan * resultptr;
43513 resultptr = new wxGBSpan((wxGBSpan &)(result));
43514 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43515 }
43516 return resultobj;
43517 fail:
43518 return NULL;
43519 }
43520
43521
43522 static PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43523 PyObject *resultobj;
43524 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43525 size_t arg2 ;
43526 wxGBSpan result;
43527 PyObject * obj0 = 0 ;
43528 PyObject * obj1 = 0 ;
43529
43530 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_GetItemSpan",&obj0,&obj1)) goto fail;
43531 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43532 if (SWIG_arg_fail(1)) SWIG_fail;
43533 {
43534 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43535 if (SWIG_arg_fail(2)) SWIG_fail;
43536 }
43537 {
43538 PyThreadState* __tstate = wxPyBeginAllowThreads();
43539 result = (arg1)->GetItemSpan(arg2);
43540
43541 wxPyEndAllowThreads(__tstate);
43542 if (PyErr_Occurred()) SWIG_fail;
43543 }
43544 {
43545 wxGBSpan * resultptr;
43546 resultptr = new wxGBSpan((wxGBSpan &)(result));
43547 resultobj = SWIG_NewPointerObj((void *)(resultptr), SWIGTYPE_p_wxGBSpan, 1);
43548 }
43549 return resultobj;
43550 fail:
43551 return NULL;
43552 }
43553
43554
43555 static PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
43556 int argc;
43557 PyObject *argv[3];
43558 int ii;
43559
43560 argc = PyObject_Length(args);
43561 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43562 argv[ii] = PyTuple_GetItem(args,ii);
43563 }
43564 if (argc == 2) {
43565 int _v;
43566 {
43567 void *ptr;
43568 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43569 _v = 0;
43570 PyErr_Clear();
43571 } else {
43572 _v = 1;
43573 }
43574 }
43575 if (_v) {
43576 {
43577 void *ptr;
43578 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43579 _v = 0;
43580 PyErr_Clear();
43581 } else {
43582 _v = 1;
43583 }
43584 }
43585 if (_v) {
43586 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self,args);
43587 }
43588 }
43589 }
43590 if (argc == 2) {
43591 int _v;
43592 {
43593 void *ptr;
43594 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43595 _v = 0;
43596 PyErr_Clear();
43597 } else {
43598 _v = 1;
43599 }
43600 }
43601 if (_v) {
43602 {
43603 void *ptr;
43604 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43605 _v = 0;
43606 PyErr_Clear();
43607 } else {
43608 _v = 1;
43609 }
43610 }
43611 if (_v) {
43612 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self,args);
43613 }
43614 }
43615 }
43616 if (argc == 2) {
43617 int _v;
43618 {
43619 void *ptr;
43620 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43621 _v = 0;
43622 PyErr_Clear();
43623 } else {
43624 _v = 1;
43625 }
43626 }
43627 if (_v) {
43628 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43629 if (_v) {
43630 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self,args);
43631 }
43632 }
43633 }
43634
43635 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
43636 return NULL;
43637 }
43638
43639
43640 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *, PyObject *args) {
43641 PyObject *resultobj;
43642 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43643 wxWindow *arg2 = (wxWindow *) 0 ;
43644 wxGBSpan *arg3 = 0 ;
43645 bool result;
43646 wxGBSpan temp3 ;
43647 PyObject * obj0 = 0 ;
43648 PyObject * obj1 = 0 ;
43649 PyObject * obj2 = 0 ;
43650
43651 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43652 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43653 if (SWIG_arg_fail(1)) SWIG_fail;
43654 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43655 if (SWIG_arg_fail(2)) SWIG_fail;
43656 {
43657 arg3 = &temp3;
43658 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43659 }
43660 {
43661 PyThreadState* __tstate = wxPyBeginAllowThreads();
43662 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43663
43664 wxPyEndAllowThreads(__tstate);
43665 if (PyErr_Occurred()) SWIG_fail;
43666 }
43667 {
43668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43669 }
43670 return resultobj;
43671 fail:
43672 return NULL;
43673 }
43674
43675
43676 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *, PyObject *args) {
43677 PyObject *resultobj;
43678 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43679 wxSizer *arg2 = (wxSizer *) 0 ;
43680 wxGBSpan *arg3 = 0 ;
43681 bool result;
43682 wxGBSpan temp3 ;
43683 PyObject * obj0 = 0 ;
43684 PyObject * obj1 = 0 ;
43685 PyObject * obj2 = 0 ;
43686
43687 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43688 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43689 if (SWIG_arg_fail(1)) SWIG_fail;
43690 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43691 if (SWIG_arg_fail(2)) SWIG_fail;
43692 {
43693 arg3 = &temp3;
43694 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43695 }
43696 {
43697 PyThreadState* __tstate = wxPyBeginAllowThreads();
43698 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43699
43700 wxPyEndAllowThreads(__tstate);
43701 if (PyErr_Occurred()) SWIG_fail;
43702 }
43703 {
43704 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43705 }
43706 return resultobj;
43707 fail:
43708 return NULL;
43709 }
43710
43711
43712 static PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *, PyObject *args) {
43713 PyObject *resultobj;
43714 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43715 size_t arg2 ;
43716 wxGBSpan *arg3 = 0 ;
43717 bool result;
43718 wxGBSpan temp3 ;
43719 PyObject * obj0 = 0 ;
43720 PyObject * obj1 = 0 ;
43721 PyObject * obj2 = 0 ;
43722
43723 if(!PyArg_ParseTuple(args,(char *)"OOO:GridBagSizer_SetItemSpan",&obj0,&obj1,&obj2)) goto fail;
43724 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43725 if (SWIG_arg_fail(1)) SWIG_fail;
43726 {
43727 arg2 = (size_t)(SWIG_As_unsigned_SS_long(obj1));
43728 if (SWIG_arg_fail(2)) SWIG_fail;
43729 }
43730 {
43731 arg3 = &temp3;
43732 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
43733 }
43734 {
43735 PyThreadState* __tstate = wxPyBeginAllowThreads();
43736 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
43737
43738 wxPyEndAllowThreads(__tstate);
43739 if (PyErr_Occurred()) SWIG_fail;
43740 }
43741 {
43742 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43743 }
43744 return resultobj;
43745 fail:
43746 return NULL;
43747 }
43748
43749
43750 static PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
43751 int argc;
43752 PyObject *argv[4];
43753 int ii;
43754
43755 argc = PyObject_Length(args);
43756 for (ii = 0; (ii < argc) && (ii < 3); ii++) {
43757 argv[ii] = PyTuple_GetItem(args,ii);
43758 }
43759 if (argc == 3) {
43760 int _v;
43761 {
43762 void *ptr;
43763 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43764 _v = 0;
43765 PyErr_Clear();
43766 } else {
43767 _v = 1;
43768 }
43769 }
43770 if (_v) {
43771 {
43772 void *ptr;
43773 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43774 _v = 0;
43775 PyErr_Clear();
43776 } else {
43777 _v = 1;
43778 }
43779 }
43780 if (_v) {
43781 {
43782 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43783 }
43784 if (_v) {
43785 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self,args);
43786 }
43787 }
43788 }
43789 }
43790 if (argc == 3) {
43791 int _v;
43792 {
43793 void *ptr;
43794 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43795 _v = 0;
43796 PyErr_Clear();
43797 } else {
43798 _v = 1;
43799 }
43800 }
43801 if (_v) {
43802 {
43803 void *ptr;
43804 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43805 _v = 0;
43806 PyErr_Clear();
43807 } else {
43808 _v = 1;
43809 }
43810 }
43811 if (_v) {
43812 {
43813 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43814 }
43815 if (_v) {
43816 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self,args);
43817 }
43818 }
43819 }
43820 }
43821 if (argc == 3) {
43822 int _v;
43823 {
43824 void *ptr;
43825 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43826 _v = 0;
43827 PyErr_Clear();
43828 } else {
43829 _v = 1;
43830 }
43831 }
43832 if (_v) {
43833 _v = SWIG_Check_unsigned_SS_long(argv[1]);
43834 if (_v) {
43835 {
43836 _v = wxPySimple_typecheck(argv[2], wxT("wxGBSpan"), 2);
43837 }
43838 if (_v) {
43839 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self,args);
43840 }
43841 }
43842 }
43843 }
43844
43845 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
43846 return NULL;
43847 }
43848
43849
43850 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *, PyObject *args) {
43851 PyObject *resultobj;
43852 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43853 wxWindow *arg2 = (wxWindow *) 0 ;
43854 wxGBSizerItem *result;
43855 PyObject * obj0 = 0 ;
43856 PyObject * obj1 = 0 ;
43857
43858 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43859 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43860 if (SWIG_arg_fail(1)) SWIG_fail;
43861 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
43862 if (SWIG_arg_fail(2)) SWIG_fail;
43863 {
43864 PyThreadState* __tstate = wxPyBeginAllowThreads();
43865 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43866
43867 wxPyEndAllowThreads(__tstate);
43868 if (PyErr_Occurred()) SWIG_fail;
43869 }
43870 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43871 return resultobj;
43872 fail:
43873 return NULL;
43874 }
43875
43876
43877 static PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *, PyObject *args) {
43878 PyObject *resultobj;
43879 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43880 wxSizer *arg2 = (wxSizer *) 0 ;
43881 wxGBSizerItem *result;
43882 PyObject * obj0 = 0 ;
43883 PyObject * obj1 = 0 ;
43884
43885 if(!PyArg_ParseTuple(args,(char *)"OO:GridBagSizer_FindItem",&obj0,&obj1)) goto fail;
43886 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43887 if (SWIG_arg_fail(1)) SWIG_fail;
43888 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxSizer, SWIG_POINTER_EXCEPTION | 0);
43889 if (SWIG_arg_fail(2)) SWIG_fail;
43890 {
43891 PyThreadState* __tstate = wxPyBeginAllowThreads();
43892 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
43893
43894 wxPyEndAllowThreads(__tstate);
43895 if (PyErr_Occurred()) SWIG_fail;
43896 }
43897 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43898 return resultobj;
43899 fail:
43900 return NULL;
43901 }
43902
43903
43904 static PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
43905 int argc;
43906 PyObject *argv[3];
43907 int ii;
43908
43909 argc = PyObject_Length(args);
43910 for (ii = 0; (ii < argc) && (ii < 2); ii++) {
43911 argv[ii] = PyTuple_GetItem(args,ii);
43912 }
43913 if (argc == 2) {
43914 int _v;
43915 {
43916 void *ptr;
43917 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43918 _v = 0;
43919 PyErr_Clear();
43920 } else {
43921 _v = 1;
43922 }
43923 }
43924 if (_v) {
43925 {
43926 void *ptr;
43927 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxWindow, 0) == -1) {
43928 _v = 0;
43929 PyErr_Clear();
43930 } else {
43931 _v = 1;
43932 }
43933 }
43934 if (_v) {
43935 return _wrap_GridBagSizer_FindItem__SWIG_0(self,args);
43936 }
43937 }
43938 }
43939 if (argc == 2) {
43940 int _v;
43941 {
43942 void *ptr;
43943 if (SWIG_ConvertPtr(argv[0], &ptr, SWIGTYPE_p_wxGridBagSizer, 0) == -1) {
43944 _v = 0;
43945 PyErr_Clear();
43946 } else {
43947 _v = 1;
43948 }
43949 }
43950 if (_v) {
43951 {
43952 void *ptr;
43953 if (SWIG_ConvertPtr(argv[1], &ptr, SWIGTYPE_p_wxSizer, 0) == -1) {
43954 _v = 0;
43955 PyErr_Clear();
43956 } else {
43957 _v = 1;
43958 }
43959 }
43960 if (_v) {
43961 return _wrap_GridBagSizer_FindItem__SWIG_1(self,args);
43962 }
43963 }
43964 }
43965
43966 PyErr_SetString(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
43967 return NULL;
43968 }
43969
43970
43971 static PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *, PyObject *args, PyObject *kwargs) {
43972 PyObject *resultobj;
43973 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
43974 wxGBPosition *arg2 = 0 ;
43975 wxGBSizerItem *result;
43976 wxGBPosition temp2 ;
43977 PyObject * obj0 = 0 ;
43978 PyObject * obj1 = 0 ;
43979 char *kwnames[] = {
43980 (char *) "self",(char *) "pos", NULL
43981 };
43982
43983 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) goto fail;
43984 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
43985 if (SWIG_arg_fail(1)) SWIG_fail;
43986 {
43987 arg2 = &temp2;
43988 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
43989 }
43990 {
43991 PyThreadState* __tstate = wxPyBeginAllowThreads();
43992 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
43993
43994 wxPyEndAllowThreads(__tstate);
43995 if (PyErr_Occurred()) SWIG_fail;
43996 }
43997 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
43998 return resultobj;
43999 fail:
44000 return NULL;
44001 }
44002
44003
44004 static PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *, PyObject *args, PyObject *kwargs) {
44005 PyObject *resultobj;
44006 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44007 wxPoint *arg2 = 0 ;
44008 wxGBSizerItem *result;
44009 wxPoint temp2 ;
44010 PyObject * obj0 = 0 ;
44011 PyObject * obj1 = 0 ;
44012 char *kwnames[] = {
44013 (char *) "self",(char *) "pt", NULL
44014 };
44015
44016 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) goto fail;
44017 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44018 if (SWIG_arg_fail(1)) SWIG_fail;
44019 {
44020 arg2 = &temp2;
44021 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
44022 }
44023 {
44024 PyThreadState* __tstate = wxPyBeginAllowThreads();
44025 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
44026
44027 wxPyEndAllowThreads(__tstate);
44028 if (PyErr_Occurred()) SWIG_fail;
44029 }
44030 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxGBSizerItem, 0);
44031 return resultobj;
44032 fail:
44033 return NULL;
44034 }
44035
44036
44037 static PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *, PyObject *args, PyObject *kwargs) {
44038 PyObject *resultobj;
44039 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44040 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
44041 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
44042 bool result;
44043 PyObject * obj0 = 0 ;
44044 PyObject * obj1 = 0 ;
44045 PyObject * obj2 = 0 ;
44046 char *kwnames[] = {
44047 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
44048 };
44049
44050 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) goto fail;
44051 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44052 if (SWIG_arg_fail(1)) SWIG_fail;
44053 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44054 if (SWIG_arg_fail(2)) SWIG_fail;
44055 if (obj2) {
44056 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44057 if (SWIG_arg_fail(3)) SWIG_fail;
44058 }
44059 {
44060 PyThreadState* __tstate = wxPyBeginAllowThreads();
44061 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
44062
44063 wxPyEndAllowThreads(__tstate);
44064 if (PyErr_Occurred()) SWIG_fail;
44065 }
44066 {
44067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44068 }
44069 return resultobj;
44070 fail:
44071 return NULL;
44072 }
44073
44074
44075 static PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *, PyObject *args, PyObject *kwargs) {
44076 PyObject *resultobj;
44077 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
44078 wxGBPosition *arg2 = 0 ;
44079 wxGBSpan *arg3 = 0 ;
44080 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
44081 bool result;
44082 wxGBPosition temp2 ;
44083 wxGBSpan temp3 ;
44084 PyObject * obj0 = 0 ;
44085 PyObject * obj1 = 0 ;
44086 PyObject * obj2 = 0 ;
44087 PyObject * obj3 = 0 ;
44088 char *kwnames[] = {
44089 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
44090 };
44091
44092 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44093 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_EXCEPTION | 0);
44094 if (SWIG_arg_fail(1)) SWIG_fail;
44095 {
44096 arg2 = &temp2;
44097 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
44098 }
44099 {
44100 arg3 = &temp3;
44101 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
44102 }
44103 if (obj3) {
44104 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_EXCEPTION | 0);
44105 if (SWIG_arg_fail(4)) SWIG_fail;
44106 }
44107 {
44108 PyThreadState* __tstate = wxPyBeginAllowThreads();
44109 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
44110
44111 wxPyEndAllowThreads(__tstate);
44112 if (PyErr_Occurred()) SWIG_fail;
44113 }
44114 {
44115 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44116 }
44117 return resultobj;
44118 fail:
44119 return NULL;
44120 }
44121
44122
44123 static PyObject * GridBagSizer_swigregister(PyObject *, PyObject *args) {
44124 PyObject *obj;
44125 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44126 SWIG_TypeClientData(SWIGTYPE_p_wxGridBagSizer, obj);
44127 Py_INCREF(obj);
44128 return Py_BuildValue((char *)"");
44129 }
44130 static PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *, PyObject *args, PyObject *kwargs) {
44131 PyObject *resultobj;
44132 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44133 wxRelationship arg2 ;
44134 wxWindow *arg3 = (wxWindow *) 0 ;
44135 wxEdge arg4 ;
44136 int arg5 = (int) 0 ;
44137 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
44138 PyObject * obj0 = 0 ;
44139 PyObject * obj1 = 0 ;
44140 PyObject * obj2 = 0 ;
44141 PyObject * obj3 = 0 ;
44142 PyObject * obj4 = 0 ;
44143 PyObject * obj5 = 0 ;
44144 char *kwnames[] = {
44145 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
44146 };
44147
44148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) goto fail;
44149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44150 if (SWIG_arg_fail(1)) SWIG_fail;
44151 {
44152 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44153 if (SWIG_arg_fail(2)) SWIG_fail;
44154 }
44155 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44156 if (SWIG_arg_fail(3)) SWIG_fail;
44157 {
44158 arg4 = (wxEdge)(SWIG_As_int(obj3));
44159 if (SWIG_arg_fail(4)) SWIG_fail;
44160 }
44161 if (obj4) {
44162 {
44163 arg5 = (int)(SWIG_As_int(obj4));
44164 if (SWIG_arg_fail(5)) SWIG_fail;
44165 }
44166 }
44167 if (obj5) {
44168 {
44169 arg6 = (int)(SWIG_As_int(obj5));
44170 if (SWIG_arg_fail(6)) SWIG_fail;
44171 }
44172 }
44173 {
44174 PyThreadState* __tstate = wxPyBeginAllowThreads();
44175 (arg1)->Set((wxRelationship )arg2,arg3,(wxEdge )arg4,arg5,arg6);
44176
44177 wxPyEndAllowThreads(__tstate);
44178 if (PyErr_Occurred()) SWIG_fail;
44179 }
44180 Py_INCREF(Py_None); resultobj = Py_None;
44181 return resultobj;
44182 fail:
44183 return NULL;
44184 }
44185
44186
44187 static PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *, PyObject *args, PyObject *kwargs) {
44188 PyObject *resultobj;
44189 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44190 wxWindow *arg2 = (wxWindow *) 0 ;
44191 int arg3 = (int) 0 ;
44192 PyObject * obj0 = 0 ;
44193 PyObject * obj1 = 0 ;
44194 PyObject * obj2 = 0 ;
44195 char *kwnames[] = {
44196 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44197 };
44198
44199 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44200 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44201 if (SWIG_arg_fail(1)) SWIG_fail;
44202 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44203 if (SWIG_arg_fail(2)) SWIG_fail;
44204 if (obj2) {
44205 {
44206 arg3 = (int)(SWIG_As_int(obj2));
44207 if (SWIG_arg_fail(3)) SWIG_fail;
44208 }
44209 }
44210 {
44211 PyThreadState* __tstate = wxPyBeginAllowThreads();
44212 (arg1)->LeftOf(arg2,arg3);
44213
44214 wxPyEndAllowThreads(__tstate);
44215 if (PyErr_Occurred()) SWIG_fail;
44216 }
44217 Py_INCREF(Py_None); resultobj = Py_None;
44218 return resultobj;
44219 fail:
44220 return NULL;
44221 }
44222
44223
44224 static PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *, PyObject *args, PyObject *kwargs) {
44225 PyObject *resultobj;
44226 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44227 wxWindow *arg2 = (wxWindow *) 0 ;
44228 int arg3 = (int) 0 ;
44229 PyObject * obj0 = 0 ;
44230 PyObject * obj1 = 0 ;
44231 PyObject * obj2 = 0 ;
44232 char *kwnames[] = {
44233 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44234 };
44235
44236 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) goto fail;
44237 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44238 if (SWIG_arg_fail(1)) SWIG_fail;
44239 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44240 if (SWIG_arg_fail(2)) SWIG_fail;
44241 if (obj2) {
44242 {
44243 arg3 = (int)(SWIG_As_int(obj2));
44244 if (SWIG_arg_fail(3)) SWIG_fail;
44245 }
44246 }
44247 {
44248 PyThreadState* __tstate = wxPyBeginAllowThreads();
44249 (arg1)->RightOf(arg2,arg3);
44250
44251 wxPyEndAllowThreads(__tstate);
44252 if (PyErr_Occurred()) SWIG_fail;
44253 }
44254 Py_INCREF(Py_None); resultobj = Py_None;
44255 return resultobj;
44256 fail:
44257 return NULL;
44258 }
44259
44260
44261 static PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *, PyObject *args, PyObject *kwargs) {
44262 PyObject *resultobj;
44263 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44264 wxWindow *arg2 = (wxWindow *) 0 ;
44265 int arg3 = (int) 0 ;
44266 PyObject * obj0 = 0 ;
44267 PyObject * obj1 = 0 ;
44268 PyObject * obj2 = 0 ;
44269 char *kwnames[] = {
44270 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44271 };
44272
44273 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) goto fail;
44274 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44275 if (SWIG_arg_fail(1)) SWIG_fail;
44276 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44277 if (SWIG_arg_fail(2)) SWIG_fail;
44278 if (obj2) {
44279 {
44280 arg3 = (int)(SWIG_As_int(obj2));
44281 if (SWIG_arg_fail(3)) SWIG_fail;
44282 }
44283 }
44284 {
44285 PyThreadState* __tstate = wxPyBeginAllowThreads();
44286 (arg1)->Above(arg2,arg3);
44287
44288 wxPyEndAllowThreads(__tstate);
44289 if (PyErr_Occurred()) SWIG_fail;
44290 }
44291 Py_INCREF(Py_None); resultobj = Py_None;
44292 return resultobj;
44293 fail:
44294 return NULL;
44295 }
44296
44297
44298 static PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *, PyObject *args, PyObject *kwargs) {
44299 PyObject *resultobj;
44300 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44301 wxWindow *arg2 = (wxWindow *) 0 ;
44302 int arg3 = (int) 0 ;
44303 PyObject * obj0 = 0 ;
44304 PyObject * obj1 = 0 ;
44305 PyObject * obj2 = 0 ;
44306 char *kwnames[] = {
44307 (char *) "self",(char *) "sibling",(char *) "marg", NULL
44308 };
44309
44310 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) goto fail;
44311 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44312 if (SWIG_arg_fail(1)) SWIG_fail;
44313 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44314 if (SWIG_arg_fail(2)) SWIG_fail;
44315 if (obj2) {
44316 {
44317 arg3 = (int)(SWIG_As_int(obj2));
44318 if (SWIG_arg_fail(3)) SWIG_fail;
44319 }
44320 }
44321 {
44322 PyThreadState* __tstate = wxPyBeginAllowThreads();
44323 (arg1)->Below(arg2,arg3);
44324
44325 wxPyEndAllowThreads(__tstate);
44326 if (PyErr_Occurred()) SWIG_fail;
44327 }
44328 Py_INCREF(Py_None); resultobj = Py_None;
44329 return resultobj;
44330 fail:
44331 return NULL;
44332 }
44333
44334
44335 static PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *, PyObject *args, PyObject *kwargs) {
44336 PyObject *resultobj;
44337 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44338 wxWindow *arg2 = (wxWindow *) 0 ;
44339 wxEdge arg3 ;
44340 int arg4 = (int) 0 ;
44341 PyObject * obj0 = 0 ;
44342 PyObject * obj1 = 0 ;
44343 PyObject * obj2 = 0 ;
44344 PyObject * obj3 = 0 ;
44345 char *kwnames[] = {
44346 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
44347 };
44348
44349 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44350 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44351 if (SWIG_arg_fail(1)) SWIG_fail;
44352 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44353 if (SWIG_arg_fail(2)) SWIG_fail;
44354 {
44355 arg3 = (wxEdge)(SWIG_As_int(obj2));
44356 if (SWIG_arg_fail(3)) SWIG_fail;
44357 }
44358 if (obj3) {
44359 {
44360 arg4 = (int)(SWIG_As_int(obj3));
44361 if (SWIG_arg_fail(4)) SWIG_fail;
44362 }
44363 }
44364 {
44365 PyThreadState* __tstate = wxPyBeginAllowThreads();
44366 (arg1)->SameAs(arg2,(wxEdge )arg3,arg4);
44367
44368 wxPyEndAllowThreads(__tstate);
44369 if (PyErr_Occurred()) SWIG_fail;
44370 }
44371 Py_INCREF(Py_None); resultobj = Py_None;
44372 return resultobj;
44373 fail:
44374 return NULL;
44375 }
44376
44377
44378 static PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *, PyObject *args, PyObject *kwargs) {
44379 PyObject *resultobj;
44380 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44381 wxWindow *arg2 = (wxWindow *) 0 ;
44382 wxEdge arg3 ;
44383 int arg4 ;
44384 PyObject * obj0 = 0 ;
44385 PyObject * obj1 = 0 ;
44386 PyObject * obj2 = 0 ;
44387 PyObject * obj3 = 0 ;
44388 char *kwnames[] = {
44389 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
44390 };
44391
44392 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44393 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44394 if (SWIG_arg_fail(1)) SWIG_fail;
44395 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44396 if (SWIG_arg_fail(2)) SWIG_fail;
44397 {
44398 arg3 = (wxEdge)(SWIG_As_int(obj2));
44399 if (SWIG_arg_fail(3)) SWIG_fail;
44400 }
44401 {
44402 arg4 = (int)(SWIG_As_int(obj3));
44403 if (SWIG_arg_fail(4)) SWIG_fail;
44404 }
44405 {
44406 PyThreadState* __tstate = wxPyBeginAllowThreads();
44407 (arg1)->PercentOf(arg2,(wxEdge )arg3,arg4);
44408
44409 wxPyEndAllowThreads(__tstate);
44410 if (PyErr_Occurred()) SWIG_fail;
44411 }
44412 Py_INCREF(Py_None); resultobj = Py_None;
44413 return resultobj;
44414 fail:
44415 return NULL;
44416 }
44417
44418
44419 static PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *, PyObject *args, PyObject *kwargs) {
44420 PyObject *resultobj;
44421 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44422 int arg2 ;
44423 PyObject * obj0 = 0 ;
44424 PyObject * obj1 = 0 ;
44425 char *kwnames[] = {
44426 (char *) "self",(char *) "val", NULL
44427 };
44428
44429 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) goto fail;
44430 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44431 if (SWIG_arg_fail(1)) SWIG_fail;
44432 {
44433 arg2 = (int)(SWIG_As_int(obj1));
44434 if (SWIG_arg_fail(2)) SWIG_fail;
44435 }
44436 {
44437 PyThreadState* __tstate = wxPyBeginAllowThreads();
44438 (arg1)->Absolute(arg2);
44439
44440 wxPyEndAllowThreads(__tstate);
44441 if (PyErr_Occurred()) SWIG_fail;
44442 }
44443 Py_INCREF(Py_None); resultobj = Py_None;
44444 return resultobj;
44445 fail:
44446 return NULL;
44447 }
44448
44449
44450 static PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *, PyObject *args, PyObject *kwargs) {
44451 PyObject *resultobj;
44452 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44453 PyObject * obj0 = 0 ;
44454 char *kwnames[] = {
44455 (char *) "self", NULL
44456 };
44457
44458 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_Unconstrained",kwnames,&obj0)) goto fail;
44459 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44460 if (SWIG_arg_fail(1)) SWIG_fail;
44461 {
44462 PyThreadState* __tstate = wxPyBeginAllowThreads();
44463 (arg1)->Unconstrained();
44464
44465 wxPyEndAllowThreads(__tstate);
44466 if (PyErr_Occurred()) SWIG_fail;
44467 }
44468 Py_INCREF(Py_None); resultobj = Py_None;
44469 return resultobj;
44470 fail:
44471 return NULL;
44472 }
44473
44474
44475 static PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *, PyObject *args, PyObject *kwargs) {
44476 PyObject *resultobj;
44477 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44478 PyObject * obj0 = 0 ;
44479 char *kwnames[] = {
44480 (char *) "self", NULL
44481 };
44482
44483 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_AsIs",kwnames,&obj0)) goto fail;
44484 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44485 if (SWIG_arg_fail(1)) SWIG_fail;
44486 {
44487 PyThreadState* __tstate = wxPyBeginAllowThreads();
44488 (arg1)->AsIs();
44489
44490 wxPyEndAllowThreads(__tstate);
44491 if (PyErr_Occurred()) SWIG_fail;
44492 }
44493 Py_INCREF(Py_None); resultobj = Py_None;
44494 return resultobj;
44495 fail:
44496 return NULL;
44497 }
44498
44499
44500 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *, PyObject *args, PyObject *kwargs) {
44501 PyObject *resultobj;
44502 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44503 wxWindow *result;
44504 PyObject * obj0 = 0 ;
44505 char *kwnames[] = {
44506 (char *) "self", NULL
44507 };
44508
44509 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherWindow",kwnames,&obj0)) goto fail;
44510 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44511 if (SWIG_arg_fail(1)) SWIG_fail;
44512 {
44513 PyThreadState* __tstate = wxPyBeginAllowThreads();
44514 result = (wxWindow *)(arg1)->GetOtherWindow();
44515
44516 wxPyEndAllowThreads(__tstate);
44517 if (PyErr_Occurred()) SWIG_fail;
44518 }
44519 {
44520 resultobj = wxPyMake_wxObject(result, 0);
44521 }
44522 return resultobj;
44523 fail:
44524 return NULL;
44525 }
44526
44527
44528 static PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44529 PyObject *resultobj;
44530 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44531 wxEdge result;
44532 PyObject * obj0 = 0 ;
44533 char *kwnames[] = {
44534 (char *) "self", NULL
44535 };
44536
44537 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMyEdge",kwnames,&obj0)) goto fail;
44538 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44539 if (SWIG_arg_fail(1)) SWIG_fail;
44540 {
44541 PyThreadState* __tstate = wxPyBeginAllowThreads();
44542 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
44543
44544 wxPyEndAllowThreads(__tstate);
44545 if (PyErr_Occurred()) SWIG_fail;
44546 }
44547 resultobj = SWIG_From_int((result));
44548 return resultobj;
44549 fail:
44550 return NULL;
44551 }
44552
44553
44554 static PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44555 PyObject *resultobj;
44556 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44557 wxEdge arg2 ;
44558 PyObject * obj0 = 0 ;
44559 PyObject * obj1 = 0 ;
44560 char *kwnames[] = {
44561 (char *) "self",(char *) "which", NULL
44562 };
44563
44564 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) goto fail;
44565 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44566 if (SWIG_arg_fail(1)) SWIG_fail;
44567 {
44568 arg2 = (wxEdge)(SWIG_As_int(obj1));
44569 if (SWIG_arg_fail(2)) SWIG_fail;
44570 }
44571 {
44572 PyThreadState* __tstate = wxPyBeginAllowThreads();
44573 (arg1)->SetEdge((wxEdge )arg2);
44574
44575 wxPyEndAllowThreads(__tstate);
44576 if (PyErr_Occurred()) SWIG_fail;
44577 }
44578 Py_INCREF(Py_None); resultobj = Py_None;
44579 return resultobj;
44580 fail:
44581 return NULL;
44582 }
44583
44584
44585 static PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44586 PyObject *resultobj;
44587 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44588 int arg2 ;
44589 PyObject * obj0 = 0 ;
44590 PyObject * obj1 = 0 ;
44591 char *kwnames[] = {
44592 (char *) "self",(char *) "v", NULL
44593 };
44594
44595 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) goto fail;
44596 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44597 if (SWIG_arg_fail(1)) SWIG_fail;
44598 {
44599 arg2 = (int)(SWIG_As_int(obj1));
44600 if (SWIG_arg_fail(2)) SWIG_fail;
44601 }
44602 {
44603 PyThreadState* __tstate = wxPyBeginAllowThreads();
44604 (arg1)->SetValue(arg2);
44605
44606 wxPyEndAllowThreads(__tstate);
44607 if (PyErr_Occurred()) SWIG_fail;
44608 }
44609 Py_INCREF(Py_None); resultobj = Py_None;
44610 return resultobj;
44611 fail:
44612 return NULL;
44613 }
44614
44615
44616 static PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44617 PyObject *resultobj;
44618 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44619 int result;
44620 PyObject * obj0 = 0 ;
44621 char *kwnames[] = {
44622 (char *) "self", NULL
44623 };
44624
44625 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetMargin",kwnames,&obj0)) goto fail;
44626 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44627 if (SWIG_arg_fail(1)) SWIG_fail;
44628 {
44629 PyThreadState* __tstate = wxPyBeginAllowThreads();
44630 result = (int)(arg1)->GetMargin();
44631
44632 wxPyEndAllowThreads(__tstate);
44633 if (PyErr_Occurred()) SWIG_fail;
44634 }
44635 {
44636 resultobj = SWIG_From_int((int)(result));
44637 }
44638 return resultobj;
44639 fail:
44640 return NULL;
44641 }
44642
44643
44644 static PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *, PyObject *args, PyObject *kwargs) {
44645 PyObject *resultobj;
44646 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44647 int arg2 ;
44648 PyObject * obj0 = 0 ;
44649 PyObject * obj1 = 0 ;
44650 char *kwnames[] = {
44651 (char *) "self",(char *) "m", NULL
44652 };
44653
44654 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) goto fail;
44655 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44656 if (SWIG_arg_fail(1)) SWIG_fail;
44657 {
44658 arg2 = (int)(SWIG_As_int(obj1));
44659 if (SWIG_arg_fail(2)) SWIG_fail;
44660 }
44661 {
44662 PyThreadState* __tstate = wxPyBeginAllowThreads();
44663 (arg1)->SetMargin(arg2);
44664
44665 wxPyEndAllowThreads(__tstate);
44666 if (PyErr_Occurred()) SWIG_fail;
44667 }
44668 Py_INCREF(Py_None); resultobj = Py_None;
44669 return resultobj;
44670 fail:
44671 return NULL;
44672 }
44673
44674
44675 static PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *, PyObject *args, PyObject *kwargs) {
44676 PyObject *resultobj;
44677 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44678 int result;
44679 PyObject * obj0 = 0 ;
44680 char *kwnames[] = {
44681 (char *) "self", NULL
44682 };
44683
44684 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetValue",kwnames,&obj0)) goto fail;
44685 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44686 if (SWIG_arg_fail(1)) SWIG_fail;
44687 {
44688 PyThreadState* __tstate = wxPyBeginAllowThreads();
44689 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
44690
44691 wxPyEndAllowThreads(__tstate);
44692 if (PyErr_Occurred()) SWIG_fail;
44693 }
44694 {
44695 resultobj = SWIG_From_int((int)(result));
44696 }
44697 return resultobj;
44698 fail:
44699 return NULL;
44700 }
44701
44702
44703 static PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *, PyObject *args, PyObject *kwargs) {
44704 PyObject *resultobj;
44705 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44706 int result;
44707 PyObject * obj0 = 0 ;
44708 char *kwnames[] = {
44709 (char *) "self", NULL
44710 };
44711
44712 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetPercent",kwnames,&obj0)) goto fail;
44713 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44714 if (SWIG_arg_fail(1)) SWIG_fail;
44715 {
44716 PyThreadState* __tstate = wxPyBeginAllowThreads();
44717 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
44718
44719 wxPyEndAllowThreads(__tstate);
44720 if (PyErr_Occurred()) SWIG_fail;
44721 }
44722 {
44723 resultobj = SWIG_From_int((int)(result));
44724 }
44725 return resultobj;
44726 fail:
44727 return NULL;
44728 }
44729
44730
44731 static PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44732 PyObject *resultobj;
44733 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44734 int result;
44735 PyObject * obj0 = 0 ;
44736 char *kwnames[] = {
44737 (char *) "self", NULL
44738 };
44739
44740 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetOtherEdge",kwnames,&obj0)) goto fail;
44741 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44742 if (SWIG_arg_fail(1)) SWIG_fail;
44743 {
44744 PyThreadState* __tstate = wxPyBeginAllowThreads();
44745 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
44746
44747 wxPyEndAllowThreads(__tstate);
44748 if (PyErr_Occurred()) SWIG_fail;
44749 }
44750 {
44751 resultobj = SWIG_From_int((int)(result));
44752 }
44753 return resultobj;
44754 fail:
44755 return NULL;
44756 }
44757
44758
44759 static PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44760 PyObject *resultobj;
44761 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44762 bool result;
44763 PyObject * obj0 = 0 ;
44764 char *kwnames[] = {
44765 (char *) "self", NULL
44766 };
44767
44768 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetDone",kwnames,&obj0)) goto fail;
44769 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44770 if (SWIG_arg_fail(1)) SWIG_fail;
44771 {
44772 PyThreadState* __tstate = wxPyBeginAllowThreads();
44773 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
44774
44775 wxPyEndAllowThreads(__tstate);
44776 if (PyErr_Occurred()) SWIG_fail;
44777 }
44778 {
44779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44780 }
44781 return resultobj;
44782 fail:
44783 return NULL;
44784 }
44785
44786
44787 static PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *, PyObject *args, PyObject *kwargs) {
44788 PyObject *resultobj;
44789 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44790 bool arg2 ;
44791 PyObject * obj0 = 0 ;
44792 PyObject * obj1 = 0 ;
44793 char *kwnames[] = {
44794 (char *) "self",(char *) "d", NULL
44795 };
44796
44797 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) goto fail;
44798 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44799 if (SWIG_arg_fail(1)) SWIG_fail;
44800 {
44801 arg2 = (bool)(SWIG_As_bool(obj1));
44802 if (SWIG_arg_fail(2)) SWIG_fail;
44803 }
44804 {
44805 PyThreadState* __tstate = wxPyBeginAllowThreads();
44806 (arg1)->SetDone(arg2);
44807
44808 wxPyEndAllowThreads(__tstate);
44809 if (PyErr_Occurred()) SWIG_fail;
44810 }
44811 Py_INCREF(Py_None); resultobj = Py_None;
44812 return resultobj;
44813 fail:
44814 return NULL;
44815 }
44816
44817
44818 static PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44819 PyObject *resultobj;
44820 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44821 wxRelationship result;
44822 PyObject * obj0 = 0 ;
44823 char *kwnames[] = {
44824 (char *) "self", NULL
44825 };
44826
44827 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IndividualLayoutConstraint_GetRelationship",kwnames,&obj0)) goto fail;
44828 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44829 if (SWIG_arg_fail(1)) SWIG_fail;
44830 {
44831 PyThreadState* __tstate = wxPyBeginAllowThreads();
44832 result = (wxRelationship)(arg1)->GetRelationship();
44833
44834 wxPyEndAllowThreads(__tstate);
44835 if (PyErr_Occurred()) SWIG_fail;
44836 }
44837 resultobj = SWIG_From_int((result));
44838 return resultobj;
44839 fail:
44840 return NULL;
44841 }
44842
44843
44844 static PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *, PyObject *args, PyObject *kwargs) {
44845 PyObject *resultobj;
44846 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44847 wxRelationship arg2 ;
44848 PyObject * obj0 = 0 ;
44849 PyObject * obj1 = 0 ;
44850 char *kwnames[] = {
44851 (char *) "self",(char *) "r", NULL
44852 };
44853
44854 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) goto fail;
44855 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44856 if (SWIG_arg_fail(1)) SWIG_fail;
44857 {
44858 arg2 = (wxRelationship)(SWIG_As_int(obj1));
44859 if (SWIG_arg_fail(2)) SWIG_fail;
44860 }
44861 {
44862 PyThreadState* __tstate = wxPyBeginAllowThreads();
44863 (arg1)->SetRelationship((wxRelationship )arg2);
44864
44865 wxPyEndAllowThreads(__tstate);
44866 if (PyErr_Occurred()) SWIG_fail;
44867 }
44868 Py_INCREF(Py_None); resultobj = Py_None;
44869 return resultobj;
44870 fail:
44871 return NULL;
44872 }
44873
44874
44875 static PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *, PyObject *args, PyObject *kwargs) {
44876 PyObject *resultobj;
44877 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44878 wxWindow *arg2 = (wxWindow *) 0 ;
44879 bool result;
44880 PyObject * obj0 = 0 ;
44881 PyObject * obj1 = 0 ;
44882 char *kwnames[] = {
44883 (char *) "self",(char *) "otherW", NULL
44884 };
44885
44886 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) goto fail;
44887 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44888 if (SWIG_arg_fail(1)) SWIG_fail;
44889 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44890 if (SWIG_arg_fail(2)) SWIG_fail;
44891 {
44892 PyThreadState* __tstate = wxPyBeginAllowThreads();
44893 result = (bool)(arg1)->ResetIfWin(arg2);
44894
44895 wxPyEndAllowThreads(__tstate);
44896 if (PyErr_Occurred()) SWIG_fail;
44897 }
44898 {
44899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44900 }
44901 return resultobj;
44902 fail:
44903 return NULL;
44904 }
44905
44906
44907 static PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *, PyObject *args, PyObject *kwargs) {
44908 PyObject *resultobj;
44909 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44910 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
44911 wxWindow *arg3 = (wxWindow *) 0 ;
44912 bool result;
44913 PyObject * obj0 = 0 ;
44914 PyObject * obj1 = 0 ;
44915 PyObject * obj2 = 0 ;
44916 char *kwnames[] = {
44917 (char *) "self",(char *) "constraints",(char *) "win", NULL
44918 };
44919
44920 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) goto fail;
44921 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44922 if (SWIG_arg_fail(1)) SWIG_fail;
44923 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
44924 if (SWIG_arg_fail(2)) SWIG_fail;
44925 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44926 if (SWIG_arg_fail(3)) SWIG_fail;
44927 {
44928 PyThreadState* __tstate = wxPyBeginAllowThreads();
44929 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
44930
44931 wxPyEndAllowThreads(__tstate);
44932 if (PyErr_Occurred()) SWIG_fail;
44933 }
44934 {
44935 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44936 }
44937 return resultobj;
44938 fail:
44939 return NULL;
44940 }
44941
44942
44943 static PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *, PyObject *args, PyObject *kwargs) {
44944 PyObject *resultobj;
44945 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
44946 wxEdge arg2 ;
44947 wxWindow *arg3 = (wxWindow *) 0 ;
44948 wxWindow *arg4 = (wxWindow *) 0 ;
44949 int result;
44950 PyObject * obj0 = 0 ;
44951 PyObject * obj1 = 0 ;
44952 PyObject * obj2 = 0 ;
44953 PyObject * obj3 = 0 ;
44954 char *kwnames[] = {
44955 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
44956 };
44957
44958 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) goto fail;
44959 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_POINTER_EXCEPTION | 0);
44960 if (SWIG_arg_fail(1)) SWIG_fail;
44961 {
44962 arg2 = (wxEdge)(SWIG_As_int(obj1));
44963 if (SWIG_arg_fail(2)) SWIG_fail;
44964 }
44965 SWIG_Python_ConvertPtr(obj2, (void **)&arg3, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44966 if (SWIG_arg_fail(3)) SWIG_fail;
44967 SWIG_Python_ConvertPtr(obj3, (void **)&arg4, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
44968 if (SWIG_arg_fail(4)) SWIG_fail;
44969 {
44970 PyThreadState* __tstate = wxPyBeginAllowThreads();
44971 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge((wxEdge )arg2,arg3,arg4);
44972
44973 wxPyEndAllowThreads(__tstate);
44974 if (PyErr_Occurred()) SWIG_fail;
44975 }
44976 {
44977 resultobj = SWIG_From_int((int)(result));
44978 }
44979 return resultobj;
44980 fail:
44981 return NULL;
44982 }
44983
44984
44985 static PyObject * IndividualLayoutConstraint_swigregister(PyObject *, PyObject *args) {
44986 PyObject *obj;
44987 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
44988 SWIG_TypeClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, obj);
44989 Py_INCREF(obj);
44990 return Py_BuildValue((char *)"");
44991 }
44992 static PyObject *_wrap_LayoutConstraints_left_get(PyObject *, PyObject *args, PyObject *kwargs) {
44993 PyObject *resultobj;
44994 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
44995 wxIndividualLayoutConstraint *result;
44996 PyObject * obj0 = 0 ;
44997 char *kwnames[] = {
44998 (char *) "self", NULL
44999 };
45000
45001 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_left_get",kwnames,&obj0)) goto fail;
45002 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45003 if (SWIG_arg_fail(1)) SWIG_fail;
45004 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
45005
45006 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45007 return resultobj;
45008 fail:
45009 return NULL;
45010 }
45011
45012
45013 static PyObject *_wrap_LayoutConstraints_top_get(PyObject *, PyObject *args, PyObject *kwargs) {
45014 PyObject *resultobj;
45015 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45016 wxIndividualLayoutConstraint *result;
45017 PyObject * obj0 = 0 ;
45018 char *kwnames[] = {
45019 (char *) "self", NULL
45020 };
45021
45022 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_top_get",kwnames,&obj0)) goto fail;
45023 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45024 if (SWIG_arg_fail(1)) SWIG_fail;
45025 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
45026
45027 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45028 return resultobj;
45029 fail:
45030 return NULL;
45031 }
45032
45033
45034 static PyObject *_wrap_LayoutConstraints_right_get(PyObject *, PyObject *args, PyObject *kwargs) {
45035 PyObject *resultobj;
45036 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45037 wxIndividualLayoutConstraint *result;
45038 PyObject * obj0 = 0 ;
45039 char *kwnames[] = {
45040 (char *) "self", NULL
45041 };
45042
45043 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_right_get",kwnames,&obj0)) goto fail;
45044 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45045 if (SWIG_arg_fail(1)) SWIG_fail;
45046 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
45047
45048 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45049 return resultobj;
45050 fail:
45051 return NULL;
45052 }
45053
45054
45055 static PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *, PyObject *args, PyObject *kwargs) {
45056 PyObject *resultobj;
45057 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45058 wxIndividualLayoutConstraint *result;
45059 PyObject * obj0 = 0 ;
45060 char *kwnames[] = {
45061 (char *) "self", NULL
45062 };
45063
45064 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_bottom_get",kwnames,&obj0)) goto fail;
45065 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45066 if (SWIG_arg_fail(1)) SWIG_fail;
45067 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
45068
45069 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45070 return resultobj;
45071 fail:
45072 return NULL;
45073 }
45074
45075
45076 static PyObject *_wrap_LayoutConstraints_width_get(PyObject *, PyObject *args, PyObject *kwargs) {
45077 PyObject *resultobj;
45078 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45079 wxIndividualLayoutConstraint *result;
45080 PyObject * obj0 = 0 ;
45081 char *kwnames[] = {
45082 (char *) "self", NULL
45083 };
45084
45085 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_width_get",kwnames,&obj0)) goto fail;
45086 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45087 if (SWIG_arg_fail(1)) SWIG_fail;
45088 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
45089
45090 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45091 return resultobj;
45092 fail:
45093 return NULL;
45094 }
45095
45096
45097 static PyObject *_wrap_LayoutConstraints_height_get(PyObject *, PyObject *args, PyObject *kwargs) {
45098 PyObject *resultobj;
45099 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45100 wxIndividualLayoutConstraint *result;
45101 PyObject * obj0 = 0 ;
45102 char *kwnames[] = {
45103 (char *) "self", NULL
45104 };
45105
45106 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_height_get",kwnames,&obj0)) goto fail;
45107 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45108 if (SWIG_arg_fail(1)) SWIG_fail;
45109 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
45110
45111 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45112 return resultobj;
45113 fail:
45114 return NULL;
45115 }
45116
45117
45118 static PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *, PyObject *args, PyObject *kwargs) {
45119 PyObject *resultobj;
45120 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45121 wxIndividualLayoutConstraint *result;
45122 PyObject * obj0 = 0 ;
45123 char *kwnames[] = {
45124 (char *) "self", NULL
45125 };
45126
45127 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreX_get",kwnames,&obj0)) goto fail;
45128 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45129 if (SWIG_arg_fail(1)) SWIG_fail;
45130 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
45131
45132 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45133 return resultobj;
45134 fail:
45135 return NULL;
45136 }
45137
45138
45139 static PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *, PyObject *args, PyObject *kwargs) {
45140 PyObject *resultobj;
45141 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45142 wxIndividualLayoutConstraint *result;
45143 PyObject * obj0 = 0 ;
45144 char *kwnames[] = {
45145 (char *) "self", NULL
45146 };
45147
45148 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_centreY_get",kwnames,&obj0)) goto fail;
45149 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45150 if (SWIG_arg_fail(1)) SWIG_fail;
45151 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
45152
45153 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0);
45154 return resultobj;
45155 fail:
45156 return NULL;
45157 }
45158
45159
45160 static PyObject *_wrap_new_LayoutConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45161 PyObject *resultobj;
45162 wxLayoutConstraints *result;
45163 char *kwnames[] = {
45164 NULL
45165 };
45166
45167 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)":new_LayoutConstraints",kwnames)) goto fail;
45168 {
45169 PyThreadState* __tstate = wxPyBeginAllowThreads();
45170 result = (wxLayoutConstraints *)new wxLayoutConstraints();
45171
45172 wxPyEndAllowThreads(__tstate);
45173 if (PyErr_Occurred()) SWIG_fail;
45174 }
45175 resultobj = SWIG_NewPointerObj((void*)(result), SWIGTYPE_p_wxLayoutConstraints, 1);
45176 return resultobj;
45177 fail:
45178 return NULL;
45179 }
45180
45181
45182 static PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *, PyObject *args, PyObject *kwargs) {
45183 PyObject *resultobj;
45184 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45185 wxWindow *arg2 = (wxWindow *) 0 ;
45186 int *arg3 = (int *) 0 ;
45187 bool result;
45188 int temp3 ;
45189 int res3 = 0 ;
45190 PyObject * obj0 = 0 ;
45191 PyObject * obj1 = 0 ;
45192 char *kwnames[] = {
45193 (char *) "self",(char *) "win", NULL
45194 };
45195
45196 arg3 = &temp3; res3 = SWIG_NEWOBJ;
45197 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) goto fail;
45198 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45199 if (SWIG_arg_fail(1)) SWIG_fail;
45200 SWIG_Python_ConvertPtr(obj1, (void **)&arg2, SWIGTYPE_p_wxWindow, SWIG_POINTER_EXCEPTION | 0);
45201 if (SWIG_arg_fail(2)) SWIG_fail;
45202 {
45203 PyThreadState* __tstate = wxPyBeginAllowThreads();
45204 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
45205
45206 wxPyEndAllowThreads(__tstate);
45207 if (PyErr_Occurred()) SWIG_fail;
45208 }
45209 {
45210 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45211 }
45212 resultobj = t_output_helper(resultobj, ((res3 == SWIG_NEWOBJ) ?
45213 SWIG_From_int((*arg3)) : SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, 0)));
45214 return resultobj;
45215 fail:
45216 return NULL;
45217 }
45218
45219
45220 static PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *, PyObject *args, PyObject *kwargs) {
45221 PyObject *resultobj;
45222 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
45223 bool result;
45224 PyObject * obj0 = 0 ;
45225 char *kwnames[] = {
45226 (char *) "self", NULL
45227 };
45228
45229 if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LayoutConstraints_AreSatisfied",kwnames,&obj0)) goto fail;
45230 SWIG_Python_ConvertPtr(obj0, (void **)&arg1, SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_EXCEPTION | 0);
45231 if (SWIG_arg_fail(1)) SWIG_fail;
45232 {
45233 PyThreadState* __tstate = wxPyBeginAllowThreads();
45234 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
45235
45236 wxPyEndAllowThreads(__tstate);
45237 if (PyErr_Occurred()) SWIG_fail;
45238 }
45239 {
45240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45241 }
45242 return resultobj;
45243 fail:
45244 return NULL;
45245 }
45246
45247
45248 static PyObject * LayoutConstraints_swigregister(PyObject *, PyObject *args) {
45249 PyObject *obj;
45250 if (!PyArg_ParseTuple(args,(char*)"O", &obj)) return NULL;
45251 SWIG_TypeClientData(SWIGTYPE_p_wxLayoutConstraints, obj);
45252 Py_INCREF(obj);
45253 return Py_BuildValue((char *)"");
45254 }
45255 static PyMethodDef SwigMethods[] = {
45256 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
45257 { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS, NULL},
45258 { (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45259 { (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45260 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
45261 { (char *)"Size_width_set", (PyCFunction) _wrap_Size_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45262 { (char *)"Size_width_get", (PyCFunction) _wrap_Size_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45263 { (char *)"Size_height_set", (PyCFunction) _wrap_Size_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45264 { (char *)"Size_height_get", (PyCFunction) _wrap_Size_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45265 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45266 { (char *)"delete_Size", (PyCFunction) _wrap_delete_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45267 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45268 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45269 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45270 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45271 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
45272 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
45273 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45274 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45275 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45276 { (char *)"Size_GetWidth", (PyCFunction) _wrap_Size_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45277 { (char *)"Size_GetHeight", (PyCFunction) _wrap_Size_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45278 { (char *)"Size_IsFullySpecified", (PyCFunction) _wrap_Size_IsFullySpecified, METH_VARARGS | METH_KEYWORDS, NULL},
45279 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
45280 { (char *)"Size_Get", (PyCFunction) _wrap_Size_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45281 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
45282 { (char *)"RealPoint_x_set", (PyCFunction) _wrap_RealPoint_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45283 { (char *)"RealPoint_x_get", (PyCFunction) _wrap_RealPoint_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45284 { (char *)"RealPoint_y_set", (PyCFunction) _wrap_RealPoint_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45285 { (char *)"RealPoint_y_get", (PyCFunction) _wrap_RealPoint_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45286 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45287 { (char *)"delete_RealPoint", (PyCFunction) _wrap_delete_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45288 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45289 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45290 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45291 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45292 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45293 { (char *)"RealPoint_Get", (PyCFunction) _wrap_RealPoint_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45294 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
45295 { (char *)"Point_x_set", (PyCFunction) _wrap_Point_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45296 { (char *)"Point_x_get", (PyCFunction) _wrap_Point_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45297 { (char *)"Point_y_set", (PyCFunction) _wrap_Point_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45298 { (char *)"Point_y_get", (PyCFunction) _wrap_Point_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45299 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45300 { (char *)"delete_Point", (PyCFunction) _wrap_delete_Point, METH_VARARGS | METH_KEYWORDS, NULL},
45301 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45302 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45303 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45304 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
45305 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45306 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45307 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45308 { (char *)"Point_Get", (PyCFunction) _wrap_Point_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45309 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
45310 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45311 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
45312 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
45313 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
45314 { (char *)"delete_Rect", (PyCFunction) _wrap_delete_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
45315 { (char *)"Rect_GetX", (PyCFunction) _wrap_Rect_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45316 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
45317 { (char *)"Rect_GetY", (PyCFunction) _wrap_Rect_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45318 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
45319 { (char *)"Rect_GetWidth", (PyCFunction) _wrap_Rect_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45320 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45321 { (char *)"Rect_GetHeight", (PyCFunction) _wrap_Rect_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45322 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45323 { (char *)"Rect_GetPosition", (PyCFunction) _wrap_Rect_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45324 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45325 { (char *)"Rect_GetSize", (PyCFunction) _wrap_Rect_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45326 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45327 { (char *)"Rect_IsEmpty", (PyCFunction) _wrap_Rect_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
45328 { (char *)"Rect_GetTopLeft", (PyCFunction) _wrap_Rect_GetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45329 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45330 { (char *)"Rect_GetBottomRight", (PyCFunction) _wrap_Rect_GetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45331 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
45332 { (char *)"Rect_GetLeft", (PyCFunction) _wrap_Rect_GetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45333 { (char *)"Rect_GetTop", (PyCFunction) _wrap_Rect_GetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45334 { (char *)"Rect_GetBottom", (PyCFunction) _wrap_Rect_GetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45335 { (char *)"Rect_GetRight", (PyCFunction) _wrap_Rect_GetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45336 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
45337 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
45338 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
45339 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
45340 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
45341 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
45342 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
45343 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
45344 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
45345 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
45346 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
45347 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45348 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45349 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45350 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
45351 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
45352 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
45353 { (char *)"Rect_x_set", (PyCFunction) _wrap_Rect_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45354 { (char *)"Rect_x_get", (PyCFunction) _wrap_Rect_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45355 { (char *)"Rect_y_set", (PyCFunction) _wrap_Rect_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45356 { (char *)"Rect_y_get", (PyCFunction) _wrap_Rect_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45357 { (char *)"Rect_width_set", (PyCFunction) _wrap_Rect_width_set, METH_VARARGS | METH_KEYWORDS, NULL},
45358 { (char *)"Rect_width_get", (PyCFunction) _wrap_Rect_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
45359 { (char *)"Rect_height_set", (PyCFunction) _wrap_Rect_height_set, METH_VARARGS | METH_KEYWORDS, NULL},
45360 { (char *)"Rect_height_get", (PyCFunction) _wrap_Rect_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
45361 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45362 { (char *)"Rect_Get", (PyCFunction) _wrap_Rect_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45363 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
45364 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
45365 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
45366 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
45367 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
45368 { (char *)"Point2D_GetFloor", (PyCFunction) _wrap_Point2D_GetFloor, METH_VARARGS | METH_KEYWORDS, NULL},
45369 { (char *)"Point2D_GetRounded", (PyCFunction) _wrap_Point2D_GetRounded, METH_VARARGS | METH_KEYWORDS, NULL},
45370 { (char *)"Point2D_GetVectorLength", (PyCFunction) _wrap_Point2D_GetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45371 { (char *)"Point2D_GetVectorAngle", (PyCFunction) _wrap_Point2D_GetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45372 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
45373 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
45374 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
45375 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
45376 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45377 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
45378 { (char *)"Point2D___neg__", (PyCFunction) _wrap_Point2D___neg__, METH_VARARGS | METH_KEYWORDS, NULL},
45379 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
45380 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
45381 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
45382 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
45383 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
45384 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
45385 { (char *)"Point2D_x_set", (PyCFunction) _wrap_Point2D_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45386 { (char *)"Point2D_x_get", (PyCFunction) _wrap_Point2D_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45387 { (char *)"Point2D_y_set", (PyCFunction) _wrap_Point2D_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45388 { (char *)"Point2D_y_get", (PyCFunction) _wrap_Point2D_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45389 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45390 { (char *)"Point2D_Get", (PyCFunction) _wrap_Point2D_Get, METH_VARARGS | METH_KEYWORDS, NULL},
45391 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
45392 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45393 { (char *)"delete_InputStream", (PyCFunction) _wrap_delete_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
45394 { (char *)"InputStream_close", (PyCFunction) _wrap_InputStream_close, METH_VARARGS | METH_KEYWORDS, NULL},
45395 { (char *)"InputStream_flush", (PyCFunction) _wrap_InputStream_flush, METH_VARARGS | METH_KEYWORDS, NULL},
45396 { (char *)"InputStream_eof", (PyCFunction) _wrap_InputStream_eof, METH_VARARGS | METH_KEYWORDS, NULL},
45397 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
45398 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
45399 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
45400 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
45401 { (char *)"InputStream_tell", (PyCFunction) _wrap_InputStream_tell, METH_VARARGS | METH_KEYWORDS, NULL},
45402 { (char *)"InputStream_Peek", (PyCFunction) _wrap_InputStream_Peek, METH_VARARGS | METH_KEYWORDS, NULL},
45403 { (char *)"InputStream_GetC", (PyCFunction) _wrap_InputStream_GetC, METH_VARARGS | METH_KEYWORDS, NULL},
45404 { (char *)"InputStream_LastRead", (PyCFunction) _wrap_InputStream_LastRead, METH_VARARGS | METH_KEYWORDS, NULL},
45405 { (char *)"InputStream_CanRead", (PyCFunction) _wrap_InputStream_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45406 { (char *)"InputStream_Eof", (PyCFunction) _wrap_InputStream_Eof, METH_VARARGS | METH_KEYWORDS, NULL},
45407 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
45408 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
45409 { (char *)"InputStream_TellI", (PyCFunction) _wrap_InputStream_TellI, METH_VARARGS | METH_KEYWORDS, NULL},
45410 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
45411 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
45412 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
45413 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45414 { (char *)"delete_FSFile", (PyCFunction) _wrap_delete_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
45415 { (char *)"FSFile_GetStream", (PyCFunction) _wrap_FSFile_GetStream, METH_VARARGS | METH_KEYWORDS, NULL},
45416 { (char *)"FSFile_GetMimeType", (PyCFunction) _wrap_FSFile_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45417 { (char *)"FSFile_GetLocation", (PyCFunction) _wrap_FSFile_GetLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45418 { (char *)"FSFile_GetAnchor", (PyCFunction) _wrap_FSFile_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45419 { (char *)"FSFile_GetModificationTime", (PyCFunction) _wrap_FSFile_GetModificationTime, METH_VARARGS | METH_KEYWORDS, NULL},
45420 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
45421 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
45422 { (char *)"new_FileSystemHandler", (PyCFunction) _wrap_new_FileSystemHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45423 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45424 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45425 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45426 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45427 { (char *)"FileSystemHandler_FindNext", (PyCFunction) _wrap_FileSystemHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45428 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
45429 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45430 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
45431 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
45432 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
45433 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
45434 { (char *)"new_FileSystem", (PyCFunction) _wrap_new_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45435 { (char *)"delete_FileSystem", (PyCFunction) _wrap_delete_FileSystem, METH_VARARGS | METH_KEYWORDS, NULL},
45436 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
45437 { (char *)"FileSystem_GetPath", (PyCFunction) _wrap_FileSystem_GetPath, METH_VARARGS | METH_KEYWORDS, NULL},
45438 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45439 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45440 { (char *)"FileSystem_FindNext", (PyCFunction) _wrap_FileSystem_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45441 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45442 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction) _wrap_FileSystem_CleanUpHandlers, METH_VARARGS | METH_KEYWORDS, NULL},
45443 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
45444 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
45445 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
45446 { (char *)"new_InternetFSHandler", (PyCFunction) _wrap_new_InternetFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45447 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45448 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45449 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
45450 { (char *)"new_ZipFSHandler", (PyCFunction) _wrap_new_ZipFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45451 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45452 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45453 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45454 { (char *)"ZipFSHandler_FindNext", (PyCFunction) _wrap_ZipFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45455 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
45456 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
45457 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45458 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
45459 { (char *)"new_MemoryFSHandler", (PyCFunction) _wrap_new_MemoryFSHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45460 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45461 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
45462 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
45463 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
45464 { (char *)"MemoryFSHandler_FindNext", (PyCFunction) _wrap_MemoryFSHandler_FindNext, METH_VARARGS | METH_KEYWORDS, NULL},
45465 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
45466 { (char *)"ImageHandler_GetName", (PyCFunction) _wrap_ImageHandler_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45467 { (char *)"ImageHandler_GetExtension", (PyCFunction) _wrap_ImageHandler_GetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45468 { (char *)"ImageHandler_GetType", (PyCFunction) _wrap_ImageHandler_GetType, METH_VARARGS | METH_KEYWORDS, NULL},
45469 { (char *)"ImageHandler_GetMimeType", (PyCFunction) _wrap_ImageHandler_GetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45470 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45471 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45472 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
45473 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
45474 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
45475 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
45476 { (char *)"new_ImageHistogram", (PyCFunction) _wrap_new_ImageHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45477 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45478 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45479 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
45480 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45481 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
45482 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
45483 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45484 { (char *)"delete_Image", (PyCFunction) _wrap_delete_Image, METH_VARARGS | METH_KEYWORDS, NULL},
45485 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
45486 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
45487 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
45488 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
45489 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45490 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
45491 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45492 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45493 { (char *)"Image_Destroy", (PyCFunction) _wrap_Image_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45494 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
45495 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
45496 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
45497 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
45498 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
45499 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
45500 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
45501 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45502 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45503 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45504 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45505 { (char *)"Image_HasAlpha", (PyCFunction) _wrap_Image_HasAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45506 { (char *)"Image_InitAlpha", (PyCFunction) _wrap_Image_InitAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45507 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
45508 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
45509 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
45510 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
45511 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
45512 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
45513 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
45514 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
45515 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45516 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
45517 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
45518 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45519 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
45520 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
45521 { (char *)"Image_Ok", (PyCFunction) _wrap_Image_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45522 { (char *)"Image_GetWidth", (PyCFunction) _wrap_Image_GetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
45523 { (char *)"Image_GetHeight", (PyCFunction) _wrap_Image_GetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
45524 { (char *)"Image_GetSize", (PyCFunction) _wrap_Image_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45525 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
45526 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
45527 { (char *)"Image_Copy", (PyCFunction) _wrap_Image_Copy, METH_VARARGS | METH_KEYWORDS, NULL},
45528 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
45529 { (char *)"Image_GetData", (PyCFunction) _wrap_Image_GetData, METH_VARARGS | METH_KEYWORDS, NULL},
45530 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
45531 { (char *)"Image_GetDataBuffer", (PyCFunction) _wrap_Image_GetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45532 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45533 { (char *)"Image_GetAlphaData", (PyCFunction) _wrap_Image_GetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45534 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
45535 { (char *)"Image_GetAlphaBuffer", (PyCFunction) _wrap_Image_GetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45536 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
45537 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45538 { (char *)"Image_GetOrFindMaskColour", (PyCFunction) _wrap_Image_GetOrFindMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
45539 { (char *)"Image_GetMaskRed", (PyCFunction) _wrap_Image_GetMaskRed, METH_VARARGS | METH_KEYWORDS, NULL},
45540 { (char *)"Image_GetMaskGreen", (PyCFunction) _wrap_Image_GetMaskGreen, METH_VARARGS | METH_KEYWORDS, NULL},
45541 { (char *)"Image_GetMaskBlue", (PyCFunction) _wrap_Image_GetMaskBlue, METH_VARARGS | METH_KEYWORDS, NULL},
45542 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
45543 { (char *)"Image_HasMask", (PyCFunction) _wrap_Image_HasMask, METH_VARARGS | METH_KEYWORDS, NULL},
45544 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
45545 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
45546 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
45547 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
45548 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
45549 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45550 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45551 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
45552 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
45553 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
45554 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
45555 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
45556 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45557 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45558 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45559 { (char *)"Image_GetImageExtWildcard", (PyCFunction) _wrap_Image_GetImageExtWildcard, METH_VARARGS | METH_KEYWORDS, NULL},
45560 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45561 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
45562 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
45563 { (char *)"new_BMPHandler", (PyCFunction) _wrap_new_BMPHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45564 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
45565 { (char *)"new_ICOHandler", (PyCFunction) _wrap_new_ICOHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45566 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
45567 { (char *)"new_CURHandler", (PyCFunction) _wrap_new_CURHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45568 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
45569 { (char *)"new_ANIHandler", (PyCFunction) _wrap_new_ANIHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45570 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
45571 { (char *)"new_PNGHandler", (PyCFunction) _wrap_new_PNGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45572 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
45573 { (char *)"new_GIFHandler", (PyCFunction) _wrap_new_GIFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45574 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
45575 { (char *)"new_PCXHandler", (PyCFunction) _wrap_new_PCXHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45576 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
45577 { (char *)"new_JPEGHandler", (PyCFunction) _wrap_new_JPEGHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45578 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
45579 { (char *)"new_PNMHandler", (PyCFunction) _wrap_new_PNMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45580 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
45581 { (char *)"new_XPMHandler", (PyCFunction) _wrap_new_XPMHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45582 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
45583 { (char *)"new_TIFFHandler", (PyCFunction) _wrap_new_TIFFHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45584 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
45585 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
45586 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
45587 { (char *)"new_EvtHandler", (PyCFunction) _wrap_new_EvtHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45588 { (char *)"EvtHandler_GetNextHandler", (PyCFunction) _wrap_EvtHandler_GetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45589 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction) _wrap_EvtHandler_GetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45590 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45591 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
45592 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_GetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45593 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45594 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45595 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45596 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction) _wrap_EvtHandler_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45597 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
45598 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
45599 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45600 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
45601 { (char *)"NewEventType", (PyCFunction) _wrap_NewEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45602 { (char *)"delete_Event", (PyCFunction) _wrap_delete_Event, METH_VARARGS | METH_KEYWORDS, NULL},
45603 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45604 { (char *)"Event_GetEventType", (PyCFunction) _wrap_Event_GetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
45605 { (char *)"Event_GetEventObject", (PyCFunction) _wrap_Event_GetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45606 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
45607 { (char *)"Event_GetTimestamp", (PyCFunction) _wrap_Event_GetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45608 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
45609 { (char *)"Event_GetId", (PyCFunction) _wrap_Event_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45610 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45611 { (char *)"Event_IsCommandEvent", (PyCFunction) _wrap_Event_IsCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45612 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
45613 { (char *)"Event_GetSkipped", (PyCFunction) _wrap_Event_GetSkipped, METH_VARARGS | METH_KEYWORDS, NULL},
45614 { (char *)"Event_ShouldPropagate", (PyCFunction) _wrap_Event_ShouldPropagate, METH_VARARGS | METH_KEYWORDS, NULL},
45615 { (char *)"Event_StopPropagation", (PyCFunction) _wrap_Event_StopPropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45616 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
45617 { (char *)"Event_Clone", (PyCFunction) _wrap_Event_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45618 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
45619 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45620 { (char *)"delete_PropagationDisabler", (PyCFunction) _wrap_delete_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
45621 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
45622 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45623 { (char *)"delete_PropagateOnce", (PyCFunction) _wrap_delete_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
45624 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
45625 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45626 { (char *)"CommandEvent_GetSelection", (PyCFunction) _wrap_CommandEvent_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45627 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
45628 { (char *)"CommandEvent_GetString", (PyCFunction) _wrap_CommandEvent_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
45629 { (char *)"CommandEvent_IsChecked", (PyCFunction) _wrap_CommandEvent_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45630 { (char *)"CommandEvent_IsSelection", (PyCFunction) _wrap_CommandEvent_IsSelection, METH_VARARGS | METH_KEYWORDS, NULL},
45631 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45632 { (char *)"CommandEvent_GetExtraLong", (PyCFunction) _wrap_CommandEvent_GetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
45633 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45634 { (char *)"CommandEvent_GetInt", (PyCFunction) _wrap_CommandEvent_GetInt, METH_VARARGS | METH_KEYWORDS, NULL},
45635 { (char *)"CommandEvent_Clone", (PyCFunction) _wrap_CommandEvent_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
45636 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
45637 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45638 { (char *)"NotifyEvent_Veto", (PyCFunction) _wrap_NotifyEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45639 { (char *)"NotifyEvent_Allow", (PyCFunction) _wrap_NotifyEvent_Allow, METH_VARARGS | METH_KEYWORDS, NULL},
45640 { (char *)"NotifyEvent_IsAllowed", (PyCFunction) _wrap_NotifyEvent_IsAllowed, METH_VARARGS | METH_KEYWORDS, NULL},
45641 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
45642 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45643 { (char *)"ScrollEvent_GetOrientation", (PyCFunction) _wrap_ScrollEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45644 { (char *)"ScrollEvent_GetPosition", (PyCFunction) _wrap_ScrollEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45645 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45646 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45647 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
45648 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45649 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction) _wrap_ScrollWinEvent_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45650 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction) _wrap_ScrollWinEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45651 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
45652 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45653 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
45654 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45655 { (char *)"MouseEvent_IsButton", (PyCFunction) _wrap_MouseEvent_IsButton, METH_VARARGS | METH_KEYWORDS, NULL},
45656 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
45657 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45658 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
45659 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
45660 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45661 { (char *)"MouseEvent_GetButton", (PyCFunction) _wrap_MouseEvent_GetButton, METH_VARARGS | METH_KEYWORDS, NULL},
45662 { (char *)"MouseEvent_ControlDown", (PyCFunction) _wrap_MouseEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45663 { (char *)"MouseEvent_MetaDown", (PyCFunction) _wrap_MouseEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45664 { (char *)"MouseEvent_AltDown", (PyCFunction) _wrap_MouseEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45665 { (char *)"MouseEvent_ShiftDown", (PyCFunction) _wrap_MouseEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45666 { (char *)"MouseEvent_CmdDown", (PyCFunction) _wrap_MouseEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45667 { (char *)"MouseEvent_LeftDown", (PyCFunction) _wrap_MouseEvent_LeftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45668 { (char *)"MouseEvent_MiddleDown", (PyCFunction) _wrap_MouseEvent_MiddleDown, METH_VARARGS | METH_KEYWORDS, NULL},
45669 { (char *)"MouseEvent_RightDown", (PyCFunction) _wrap_MouseEvent_RightDown, METH_VARARGS | METH_KEYWORDS, NULL},
45670 { (char *)"MouseEvent_LeftUp", (PyCFunction) _wrap_MouseEvent_LeftUp, METH_VARARGS | METH_KEYWORDS, NULL},
45671 { (char *)"MouseEvent_MiddleUp", (PyCFunction) _wrap_MouseEvent_MiddleUp, METH_VARARGS | METH_KEYWORDS, NULL},
45672 { (char *)"MouseEvent_RightUp", (PyCFunction) _wrap_MouseEvent_RightUp, METH_VARARGS | METH_KEYWORDS, NULL},
45673 { (char *)"MouseEvent_LeftDClick", (PyCFunction) _wrap_MouseEvent_LeftDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45674 { (char *)"MouseEvent_MiddleDClick", (PyCFunction) _wrap_MouseEvent_MiddleDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45675 { (char *)"MouseEvent_RightDClick", (PyCFunction) _wrap_MouseEvent_RightDClick, METH_VARARGS | METH_KEYWORDS, NULL},
45676 { (char *)"MouseEvent_LeftIsDown", (PyCFunction) _wrap_MouseEvent_LeftIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45677 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction) _wrap_MouseEvent_MiddleIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45678 { (char *)"MouseEvent_RightIsDown", (PyCFunction) _wrap_MouseEvent_RightIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
45679 { (char *)"MouseEvent_Dragging", (PyCFunction) _wrap_MouseEvent_Dragging, METH_VARARGS | METH_KEYWORDS, NULL},
45680 { (char *)"MouseEvent_Moving", (PyCFunction) _wrap_MouseEvent_Moving, METH_VARARGS | METH_KEYWORDS, NULL},
45681 { (char *)"MouseEvent_Entering", (PyCFunction) _wrap_MouseEvent_Entering, METH_VARARGS | METH_KEYWORDS, NULL},
45682 { (char *)"MouseEvent_Leaving", (PyCFunction) _wrap_MouseEvent_Leaving, METH_VARARGS | METH_KEYWORDS, NULL},
45683 { (char *)"MouseEvent_GetPosition", (PyCFunction) _wrap_MouseEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45684 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction) _wrap_MouseEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45685 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45686 { (char *)"MouseEvent_GetX", (PyCFunction) _wrap_MouseEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45687 { (char *)"MouseEvent_GetY", (PyCFunction) _wrap_MouseEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45688 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction) _wrap_MouseEvent_GetWheelRotation, METH_VARARGS | METH_KEYWORDS, NULL},
45689 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction) _wrap_MouseEvent_GetWheelDelta, METH_VARARGS | METH_KEYWORDS, NULL},
45690 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction) _wrap_MouseEvent_GetLinesPerAction, METH_VARARGS | METH_KEYWORDS, NULL},
45691 { (char *)"MouseEvent_IsPageScroll", (PyCFunction) _wrap_MouseEvent_IsPageScroll, METH_VARARGS | METH_KEYWORDS, NULL},
45692 { (char *)"MouseEvent_m_x_set", (PyCFunction) _wrap_MouseEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45693 { (char *)"MouseEvent_m_x_get", (PyCFunction) _wrap_MouseEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45694 { (char *)"MouseEvent_m_y_set", (PyCFunction) _wrap_MouseEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45695 { (char *)"MouseEvent_m_y_get", (PyCFunction) _wrap_MouseEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45696 { (char *)"MouseEvent_m_leftDown_set", (PyCFunction) _wrap_MouseEvent_m_leftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45697 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction) _wrap_MouseEvent_m_leftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45698 { (char *)"MouseEvent_m_middleDown_set", (PyCFunction) _wrap_MouseEvent_m_middleDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45699 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction) _wrap_MouseEvent_m_middleDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45700 { (char *)"MouseEvent_m_rightDown_set", (PyCFunction) _wrap_MouseEvent_m_rightDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45701 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction) _wrap_MouseEvent_m_rightDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45702 { (char *)"MouseEvent_m_controlDown_set", (PyCFunction) _wrap_MouseEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45703 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction) _wrap_MouseEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45704 { (char *)"MouseEvent_m_shiftDown_set", (PyCFunction) _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45705 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction) _wrap_MouseEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45706 { (char *)"MouseEvent_m_altDown_set", (PyCFunction) _wrap_MouseEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45707 { (char *)"MouseEvent_m_altDown_get", (PyCFunction) _wrap_MouseEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45708 { (char *)"MouseEvent_m_metaDown_set", (PyCFunction) _wrap_MouseEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45709 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction) _wrap_MouseEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45710 { (char *)"MouseEvent_m_wheelRotation_set", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS | METH_KEYWORDS, NULL},
45711 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction) _wrap_MouseEvent_m_wheelRotation_get, METH_VARARGS | METH_KEYWORDS, NULL},
45712 { (char *)"MouseEvent_m_wheelDelta_set", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS | METH_KEYWORDS, NULL},
45713 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction) _wrap_MouseEvent_m_wheelDelta_get, METH_VARARGS | METH_KEYWORDS, NULL},
45714 { (char *)"MouseEvent_m_linesPerAction_set", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS | METH_KEYWORDS, NULL},
45715 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction) _wrap_MouseEvent_m_linesPerAction_get, METH_VARARGS | METH_KEYWORDS, NULL},
45716 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
45717 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45718 { (char *)"SetCursorEvent_GetX", (PyCFunction) _wrap_SetCursorEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45719 { (char *)"SetCursorEvent_GetY", (PyCFunction) _wrap_SetCursorEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45720 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45721 { (char *)"SetCursorEvent_GetCursor", (PyCFunction) _wrap_SetCursorEvent_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45722 { (char *)"SetCursorEvent_HasCursor", (PyCFunction) _wrap_SetCursorEvent_HasCursor, METH_VARARGS | METH_KEYWORDS, NULL},
45723 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
45724 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45725 { (char *)"KeyEvent_ControlDown", (PyCFunction) _wrap_KeyEvent_ControlDown, METH_VARARGS | METH_KEYWORDS, NULL},
45726 { (char *)"KeyEvent_MetaDown", (PyCFunction) _wrap_KeyEvent_MetaDown, METH_VARARGS | METH_KEYWORDS, NULL},
45727 { (char *)"KeyEvent_AltDown", (PyCFunction) _wrap_KeyEvent_AltDown, METH_VARARGS | METH_KEYWORDS, NULL},
45728 { (char *)"KeyEvent_ShiftDown", (PyCFunction) _wrap_KeyEvent_ShiftDown, METH_VARARGS | METH_KEYWORDS, NULL},
45729 { (char *)"KeyEvent_CmdDown", (PyCFunction) _wrap_KeyEvent_CmdDown, METH_VARARGS | METH_KEYWORDS, NULL},
45730 { (char *)"KeyEvent_HasModifiers", (PyCFunction) _wrap_KeyEvent_HasModifiers, METH_VARARGS | METH_KEYWORDS, NULL},
45731 { (char *)"KeyEvent_GetKeyCode", (PyCFunction) _wrap_KeyEvent_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45732 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction) _wrap_KeyEvent_GetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
45733 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction) _wrap_KeyEvent_GetRawKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45734 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction) _wrap_KeyEvent_GetRawKeyFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45735 { (char *)"KeyEvent_GetPosition", (PyCFunction) _wrap_KeyEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45736 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction) _wrap_KeyEvent_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
45737 { (char *)"KeyEvent_GetX", (PyCFunction) _wrap_KeyEvent_GetX, METH_VARARGS | METH_KEYWORDS, NULL},
45738 { (char *)"KeyEvent_GetY", (PyCFunction) _wrap_KeyEvent_GetY, METH_VARARGS | METH_KEYWORDS, NULL},
45739 { (char *)"KeyEvent_m_x_set", (PyCFunction) _wrap_KeyEvent_m_x_set, METH_VARARGS | METH_KEYWORDS, NULL},
45740 { (char *)"KeyEvent_m_x_get", (PyCFunction) _wrap_KeyEvent_m_x_get, METH_VARARGS | METH_KEYWORDS, NULL},
45741 { (char *)"KeyEvent_m_y_set", (PyCFunction) _wrap_KeyEvent_m_y_set, METH_VARARGS | METH_KEYWORDS, NULL},
45742 { (char *)"KeyEvent_m_y_get", (PyCFunction) _wrap_KeyEvent_m_y_get, METH_VARARGS | METH_KEYWORDS, NULL},
45743 { (char *)"KeyEvent_m_keyCode_set", (PyCFunction) _wrap_KeyEvent_m_keyCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45744 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction) _wrap_KeyEvent_m_keyCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45745 { (char *)"KeyEvent_m_controlDown_set", (PyCFunction) _wrap_KeyEvent_m_controlDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45746 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction) _wrap_KeyEvent_m_controlDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45747 { (char *)"KeyEvent_m_shiftDown_set", (PyCFunction) _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45748 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction) _wrap_KeyEvent_m_shiftDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45749 { (char *)"KeyEvent_m_altDown_set", (PyCFunction) _wrap_KeyEvent_m_altDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45750 { (char *)"KeyEvent_m_altDown_get", (PyCFunction) _wrap_KeyEvent_m_altDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45751 { (char *)"KeyEvent_m_metaDown_set", (PyCFunction) _wrap_KeyEvent_m_metaDown_set, METH_VARARGS | METH_KEYWORDS, NULL},
45752 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction) _wrap_KeyEvent_m_metaDown_get, METH_VARARGS | METH_KEYWORDS, NULL},
45753 { (char *)"KeyEvent_m_scanCode_set", (PyCFunction) _wrap_KeyEvent_m_scanCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45754 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction) _wrap_KeyEvent_m_scanCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45755 { (char *)"KeyEvent_m_rawCode_set", (PyCFunction) _wrap_KeyEvent_m_rawCode_set, METH_VARARGS | METH_KEYWORDS, NULL},
45756 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction) _wrap_KeyEvent_m_rawCode_get, METH_VARARGS | METH_KEYWORDS, NULL},
45757 { (char *)"KeyEvent_m_rawFlags_set", (PyCFunction) _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS | METH_KEYWORDS, NULL},
45758 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction) _wrap_KeyEvent_m_rawFlags_get, METH_VARARGS | METH_KEYWORDS, NULL},
45759 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
45760 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45761 { (char *)"SizeEvent_GetSize", (PyCFunction) _wrap_SizeEvent_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45762 { (char *)"SizeEvent_GetRect", (PyCFunction) _wrap_SizeEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45763 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45764 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
45765 { (char *)"SizeEvent_m_size_set", (PyCFunction) _wrap_SizeEvent_m_size_set, METH_VARARGS | METH_KEYWORDS, NULL},
45766 { (char *)"SizeEvent_m_size_get", (PyCFunction) _wrap_SizeEvent_m_size_get, METH_VARARGS | METH_KEYWORDS, NULL},
45767 { (char *)"SizeEvent_m_rect_set", (PyCFunction) _wrap_SizeEvent_m_rect_set, METH_VARARGS | METH_KEYWORDS, NULL},
45768 { (char *)"SizeEvent_m_rect_get", (PyCFunction) _wrap_SizeEvent_m_rect_get, METH_VARARGS | METH_KEYWORDS, NULL},
45769 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
45770 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45771 { (char *)"MoveEvent_GetPosition", (PyCFunction) _wrap_MoveEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45772 { (char *)"MoveEvent_GetRect", (PyCFunction) _wrap_MoveEvent_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45773 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
45774 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45775 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
45776 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45777 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
45778 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45779 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
45780 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45781 { (char *)"EraseEvent_GetDC", (PyCFunction) _wrap_EraseEvent_GetDC, METH_VARARGS | METH_KEYWORDS, NULL},
45782 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
45783 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45784 { (char *)"FocusEvent_GetWindow", (PyCFunction) _wrap_FocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45785 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45786 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
45787 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45788 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction) _wrap_ChildFocusEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45789 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
45790 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45791 { (char *)"ActivateEvent_GetActive", (PyCFunction) _wrap_ActivateEvent_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45792 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
45793 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45794 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
45795 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45796 { (char *)"MenuEvent_GetMenuId", (PyCFunction) _wrap_MenuEvent_GetMenuId, METH_VARARGS | METH_KEYWORDS, NULL},
45797 { (char *)"MenuEvent_IsPopup", (PyCFunction) _wrap_MenuEvent_IsPopup, METH_VARARGS | METH_KEYWORDS, NULL},
45798 { (char *)"MenuEvent_GetMenu", (PyCFunction) _wrap_MenuEvent_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
45799 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
45800 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45801 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45802 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction) _wrap_CloseEvent_GetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
45803 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
45804 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45805 { (char *)"CloseEvent_CanVeto", (PyCFunction) _wrap_CloseEvent_CanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45806 { (char *)"CloseEvent_GetVeto", (PyCFunction) _wrap_CloseEvent_GetVeto, METH_VARARGS | METH_KEYWORDS, NULL},
45807 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
45808 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45809 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45810 { (char *)"ShowEvent_GetShow", (PyCFunction) _wrap_ShowEvent_GetShow, METH_VARARGS | METH_KEYWORDS, NULL},
45811 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
45812 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45813 { (char *)"IconizeEvent_Iconized", (PyCFunction) _wrap_IconizeEvent_Iconized, METH_VARARGS | METH_KEYWORDS, NULL},
45814 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
45815 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45816 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
45817 { (char *)"DropFilesEvent_GetPosition", (PyCFunction) _wrap_DropFilesEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45818 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction) _wrap_DropFilesEvent_GetNumberOfFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45819 { (char *)"DropFilesEvent_GetFiles", (PyCFunction) _wrap_DropFilesEvent_GetFiles, METH_VARARGS | METH_KEYWORDS, NULL},
45820 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
45821 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45822 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45823 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45824 { (char *)"UpdateUIEvent_GetText", (PyCFunction) _wrap_UpdateUIEvent_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
45825 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction) _wrap_UpdateUIEvent_GetSetText, METH_VARARGS | METH_KEYWORDS, NULL},
45826 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction) _wrap_UpdateUIEvent_GetSetChecked, METH_VARARGS | METH_KEYWORDS, NULL},
45827 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction) _wrap_UpdateUIEvent_GetSetEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
45828 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
45829 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
45830 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
45831 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45832 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_GetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
45833 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
45834 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction) _wrap_UpdateUIEvent_ResetUpdateTime, METH_VARARGS | METH_KEYWORDS, NULL},
45835 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45836 { (char *)"UpdateUIEvent_GetMode", (PyCFunction) _wrap_UpdateUIEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45837 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
45838 { (char *)"new_SysColourChangedEvent", (PyCFunction) _wrap_new_SysColourChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45839 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
45840 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45841 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction) _wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45842 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
45843 { (char *)"new_DisplayChangedEvent", (PyCFunction) _wrap_new_DisplayChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45844 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
45845 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45846 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45847 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_GetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45848 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
45849 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45850 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45851 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
45852 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
45853 { (char *)"new_NavigationKeyEvent", (PyCFunction) _wrap_new_NavigationKeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45854 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction) _wrap_NavigationKeyEvent_GetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45855 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
45856 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_IsWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45857 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
45858 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction) _wrap_NavigationKeyEvent_IsFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45859 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
45860 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45861 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_GetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45862 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
45863 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
45864 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45865 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction) _wrap_WindowCreateEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45866 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
45867 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45868 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction) _wrap_WindowDestroyEvent_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45869 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
45870 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45871 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction) _wrap_ContextMenuEvent_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45872 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
45873 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
45874 { (char *)"new_IdleEvent", (PyCFunction) _wrap_new_IdleEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45875 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
45876 { (char *)"IdleEvent_MoreRequested", (PyCFunction) _wrap_IdleEvent_MoreRequested, METH_VARARGS | METH_KEYWORDS, NULL},
45877 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45878 { (char *)"IdleEvent_GetMode", (PyCFunction) _wrap_IdleEvent_GetMode, METH_VARARGS | METH_KEYWORDS, NULL},
45879 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
45880 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
45881 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45882 { (char *)"delete_PyEvent", (PyCFunction) _wrap_delete_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45883 { (char *)"PyEvent_SetSelf", (PyCFunction) _wrap_PyEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45884 { (char *)"PyEvent_GetSelf", (PyCFunction) _wrap_PyEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45885 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
45886 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45887 { (char *)"delete_PyCommandEvent", (PyCFunction) _wrap_delete_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45888 { (char *)"PyCommandEvent_SetSelf", (PyCFunction) _wrap_PyCommandEvent_SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45889 { (char *)"PyCommandEvent_GetSelf", (PyCFunction) _wrap_PyCommandEvent_GetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
45890 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
45891 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45892 { (char *)"DateEvent_GetDate", (PyCFunction) _wrap_DateEvent_GetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45893 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
45894 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
45895 { (char *)"new_PyApp", (PyCFunction) _wrap_new_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45896 { (char *)"delete_PyApp", (PyCFunction) _wrap_delete_PyApp, METH_VARARGS | METH_KEYWORDS, NULL},
45897 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
45898 { (char *)"PyApp_GetAppName", (PyCFunction) _wrap_PyApp_GetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45899 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
45900 { (char *)"PyApp_GetClassName", (PyCFunction) _wrap_PyApp_GetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45901 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
45902 { (char *)"PyApp_GetVendorName", (PyCFunction) _wrap_PyApp_GetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45903 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
45904 { (char *)"PyApp_GetTraits", (PyCFunction) _wrap_PyApp_GetTraits, METH_VARARGS | METH_KEYWORDS, NULL},
45905 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction) _wrap_PyApp_ProcessPendingEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45906 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45907 { (char *)"PyApp_WakeUpIdle", (PyCFunction) _wrap_PyApp_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45908 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction) _wrap_PyApp_IsMainLoopRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45909 { (char *)"PyApp_MainLoop", (PyCFunction) _wrap_PyApp_MainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45910 { (char *)"PyApp_Exit", (PyCFunction) _wrap_PyApp_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45911 { (char *)"PyApp_ExitMainLoop", (PyCFunction) _wrap_PyApp_ExitMainLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45912 { (char *)"PyApp_Pending", (PyCFunction) _wrap_PyApp_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45913 { (char *)"PyApp_Dispatch", (PyCFunction) _wrap_PyApp_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45914 { (char *)"PyApp_ProcessIdle", (PyCFunction) _wrap_PyApp_ProcessIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45915 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
45916 { (char *)"PyApp_IsActive", (PyCFunction) _wrap_PyApp_IsActive, METH_VARARGS | METH_KEYWORDS, NULL},
45917 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45918 { (char *)"PyApp_GetTopWindow", (PyCFunction) _wrap_PyApp_GetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45919 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45920 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_GetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
45921 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45922 { (char *)"PyApp_GetUseBestVisual", (PyCFunction) _wrap_PyApp_GetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
45923 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45924 { (char *)"PyApp_GetPrintMode", (PyCFunction) _wrap_PyApp_GetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
45925 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45926 { (char *)"PyApp_GetAssertMode", (PyCFunction) _wrap_PyApp_GetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
45927 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45928 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_GetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45929 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_GetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45930 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_GetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45931 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_GetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45932 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
45933 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45934 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45935 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
45936 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
45937 { (char *)"PyApp__BootstrapApp", (PyCFunction) _wrap_PyApp__BootstrapApp, METH_VARARGS | METH_KEYWORDS, NULL},
45938 { (char *)"PyApp_GetComCtl32Version", (PyCFunction) _wrap_PyApp_GetComCtl32Version, METH_VARARGS | METH_KEYWORDS, NULL},
45939 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
45940 { (char *)"Exit", (PyCFunction) _wrap_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45941 { (char *)"Yield", (PyCFunction) _wrap_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
45942 { (char *)"YieldIfNeeded", (PyCFunction) _wrap_YieldIfNeeded, METH_VARARGS | METH_KEYWORDS, NULL},
45943 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
45944 { (char *)"WakeUpIdle", (PyCFunction) _wrap_WakeUpIdle, METH_VARARGS | METH_KEYWORDS, NULL},
45945 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
45946 { (char *)"App_CleanUp", (PyCFunction) _wrap_App_CleanUp, METH_VARARGS | METH_KEYWORDS, NULL},
45947 { (char *)"GetApp", (PyCFunction) _wrap_GetApp, METH_VARARGS | METH_KEYWORDS, NULL},
45948 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45949 { (char *)"GetDefaultPyEncoding", (PyCFunction) _wrap_GetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
45950 { (char *)"new_EventLoop", (PyCFunction) _wrap_new_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45951 { (char *)"delete_EventLoop", (PyCFunction) _wrap_delete_EventLoop, METH_VARARGS | METH_KEYWORDS, NULL},
45952 { (char *)"EventLoop_Run", (PyCFunction) _wrap_EventLoop_Run, METH_VARARGS | METH_KEYWORDS, NULL},
45953 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
45954 { (char *)"EventLoop_Pending", (PyCFunction) _wrap_EventLoop_Pending, METH_VARARGS | METH_KEYWORDS, NULL},
45955 { (char *)"EventLoop_Dispatch", (PyCFunction) _wrap_EventLoop_Dispatch, METH_VARARGS | METH_KEYWORDS, NULL},
45956 { (char *)"EventLoop_IsRunning", (PyCFunction) _wrap_EventLoop_IsRunning, METH_VARARGS | METH_KEYWORDS, NULL},
45957 { (char *)"EventLoop_GetActive", (PyCFunction) _wrap_EventLoop_GetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45958 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
45959 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
45960 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45961 { (char *)"delete_AcceleratorEntry", (PyCFunction) _wrap_delete_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
45962 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
45963 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction) _wrap_AcceleratorEntry_GetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
45964 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction) _wrap_AcceleratorEntry_GetKeyCode, METH_VARARGS | METH_KEYWORDS, NULL},
45965 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction) _wrap_AcceleratorEntry_GetCommand, METH_VARARGS | METH_KEYWORDS, NULL},
45966 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
45967 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45968 { (char *)"delete_AcceleratorTable", (PyCFunction) _wrap_delete_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
45969 { (char *)"AcceleratorTable_Ok", (PyCFunction) _wrap_AcceleratorTable_Ok, METH_VARARGS | METH_KEYWORDS, NULL},
45970 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
45971 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
45972 { (char *)"new_VisualAttributes", (PyCFunction) _wrap_new_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45973 { (char *)"delete_VisualAttributes", (PyCFunction) _wrap_delete_VisualAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
45974 { (char *)"VisualAttributes_font_set", (PyCFunction) _wrap_VisualAttributes_font_set, METH_VARARGS | METH_KEYWORDS, NULL},
45975 { (char *)"VisualAttributes_font_get", (PyCFunction) _wrap_VisualAttributes_font_get, METH_VARARGS | METH_KEYWORDS, NULL},
45976 { (char *)"VisualAttributes_colFg_set", (PyCFunction) _wrap_VisualAttributes_colFg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45977 { (char *)"VisualAttributes_colFg_get", (PyCFunction) _wrap_VisualAttributes_colFg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45978 { (char *)"VisualAttributes_colBg_set", (PyCFunction) _wrap_VisualAttributes_colBg_set, METH_VARARGS | METH_KEYWORDS, NULL},
45979 { (char *)"VisualAttributes_colBg_get", (PyCFunction) _wrap_VisualAttributes_colBg_get, METH_VARARGS | METH_KEYWORDS, NULL},
45980 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
45981 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
45982 { (char *)"new_PreWindow", (PyCFunction) _wrap_new_PreWindow, METH_VARARGS | METH_KEYWORDS, NULL},
45983 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
45984 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
45985 { (char *)"Window_Destroy", (PyCFunction) _wrap_Window_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
45986 { (char *)"Window_DestroyChildren", (PyCFunction) _wrap_Window_DestroyChildren, METH_VARARGS | METH_KEYWORDS, NULL},
45987 { (char *)"Window_IsBeingDeleted", (PyCFunction) _wrap_Window_IsBeingDeleted, METH_VARARGS | METH_KEYWORDS, NULL},
45988 { (char *)"Window_SetTitle", (PyCFunction) _wrap_Window_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45989 { (char *)"Window_GetTitle", (PyCFunction) _wrap_Window_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
45990 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45991 { (char *)"Window_GetLabel", (PyCFunction) _wrap_Window_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
45992 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
45993 { (char *)"Window_GetName", (PyCFunction) _wrap_Window_GetName, METH_VARARGS | METH_KEYWORDS, NULL},
45994 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45995 { (char *)"Window_GetWindowVariant", (PyCFunction) _wrap_Window_GetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
45996 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
45997 { (char *)"Window_GetId", (PyCFunction) _wrap_Window_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
45998 { (char *)"Window_NewControlId", (PyCFunction) _wrap_Window_NewControlId, METH_VARARGS | METH_KEYWORDS, NULL},
45999 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46000 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
46001 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46002 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
46003 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46004 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46005 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
46006 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
46007 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46008 { (char *)"Window_Raise", (PyCFunction) _wrap_Window_Raise, METH_VARARGS | METH_KEYWORDS, NULL},
46009 { (char *)"Window_Lower", (PyCFunction) _wrap_Window_Lower, METH_VARARGS | METH_KEYWORDS, NULL},
46010 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46011 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46012 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46013 { (char *)"Window_GetPosition", (PyCFunction) _wrap_Window_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46014 { (char *)"Window_GetPositionTuple", (PyCFunction) _wrap_Window_GetPositionTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46015 { (char *)"Window_GetSize", (PyCFunction) _wrap_Window_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46016 { (char *)"Window_GetSizeTuple", (PyCFunction) _wrap_Window_GetSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46017 { (char *)"Window_GetRect", (PyCFunction) _wrap_Window_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46018 { (char *)"Window_GetClientSize", (PyCFunction) _wrap_Window_GetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
46019 { (char *)"Window_GetClientSizeTuple", (PyCFunction) _wrap_Window_GetClientSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46020 { (char *)"Window_GetClientAreaOrigin", (PyCFunction) _wrap_Window_GetClientAreaOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
46021 { (char *)"Window_GetClientRect", (PyCFunction) _wrap_Window_GetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46022 { (char *)"Window_GetBestSize", (PyCFunction) _wrap_Window_GetBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46023 { (char *)"Window_GetBestSizeTuple", (PyCFunction) _wrap_Window_GetBestSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46024 { (char *)"Window_InvalidateBestSize", (PyCFunction) _wrap_Window_InvalidateBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46025 { (char *)"Window_GetBestFittingSize", (PyCFunction) _wrap_Window_GetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
46026 { (char *)"Window_GetAdjustedBestSize", (PyCFunction) _wrap_Window_GetAdjustedBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
46027 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
46028 { (char *)"Window_CenterOnScreen", (PyCFunction) _wrap_Window_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46029 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
46030 { (char *)"Window_Fit", (PyCFunction) _wrap_Window_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46031 { (char *)"Window_FitInside", (PyCFunction) _wrap_Window_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46032 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46033 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46034 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46035 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
46036 { (char *)"Window_GetMaxSize", (PyCFunction) _wrap_Window_GetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46037 { (char *)"Window_GetMinSize", (PyCFunction) _wrap_Window_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46038 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46039 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
46040 { (char *)"Window_GetMinWidth", (PyCFunction) _wrap_Window_GetMinWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46041 { (char *)"Window_GetMinHeight", (PyCFunction) _wrap_Window_GetMinHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46042 { (char *)"Window_GetMaxWidth", (PyCFunction) _wrap_Window_GetMaxWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46043 { (char *)"Window_GetMaxHeight", (PyCFunction) _wrap_Window_GetMaxHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46044 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46045 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
46046 { (char *)"Window_GetVirtualSize", (PyCFunction) _wrap_Window_GetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46047 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction) _wrap_Window_GetVirtualSizeTuple, METH_VARARGS | METH_KEYWORDS, NULL},
46048 { (char *)"Window_GetBestVirtualSize", (PyCFunction) _wrap_Window_GetBestVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
46049 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46050 { (char *)"Window_Hide", (PyCFunction) _wrap_Window_Hide, METH_VARARGS | METH_KEYWORDS, NULL},
46051 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46052 { (char *)"Window_Disable", (PyCFunction) _wrap_Window_Disable, METH_VARARGS | METH_KEYWORDS, NULL},
46053 { (char *)"Window_IsShown", (PyCFunction) _wrap_Window_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46054 { (char *)"Window_IsEnabled", (PyCFunction) _wrap_Window_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46055 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46056 { (char *)"Window_GetWindowStyleFlag", (PyCFunction) _wrap_Window_GetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46057 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46058 { (char *)"Window_IsRetained", (PyCFunction) _wrap_Window_IsRetained, METH_VARARGS | METH_KEYWORDS, NULL},
46059 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46060 { (char *)"Window_GetExtraStyle", (PyCFunction) _wrap_Window_GetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46061 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
46062 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46063 { (char *)"Window_GetThemeEnabled", (PyCFunction) _wrap_Window_GetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46064 { (char *)"Window_SetFocus", (PyCFunction) _wrap_Window_SetFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46065 { (char *)"Window_SetFocusFromKbd", (PyCFunction) _wrap_Window_SetFocusFromKbd, METH_VARARGS | METH_KEYWORDS, NULL},
46066 { (char *)"Window_FindFocus", (PyCFunction) _wrap_Window_FindFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46067 { (char *)"Window_AcceptsFocus", (PyCFunction) _wrap_Window_AcceptsFocus, METH_VARARGS | METH_KEYWORDS, NULL},
46068 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction) _wrap_Window_AcceptsFocusFromKeyboard, METH_VARARGS | METH_KEYWORDS, NULL},
46069 { (char *)"Window_GetDefaultItem", (PyCFunction) _wrap_Window_GetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46070 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46071 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
46072 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
46073 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46074 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
46075 { (char *)"Window_GetChildren", (PyCFunction) _wrap_Window_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46076 { (char *)"Window_GetParent", (PyCFunction) _wrap_Window_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46077 { (char *)"Window_GetGrandParent", (PyCFunction) _wrap_Window_GetGrandParent, METH_VARARGS | METH_KEYWORDS, NULL},
46078 { (char *)"Window_IsTopLevel", (PyCFunction) _wrap_Window_IsTopLevel, METH_VARARGS | METH_KEYWORDS, NULL},
46079 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
46080 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
46081 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
46082 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46083 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46084 { (char *)"Window_GetEventHandler", (PyCFunction) _wrap_Window_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46085 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46086 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46087 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46088 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46089 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46090 { (char *)"Window_GetValidator", (PyCFunction) _wrap_Window_GetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46091 { (char *)"Window_Validate", (PyCFunction) _wrap_Window_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46092 { (char *)"Window_TransferDataToWindow", (PyCFunction) _wrap_Window_TransferDataToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46093 { (char *)"Window_TransferDataFromWindow", (PyCFunction) _wrap_Window_TransferDataFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46094 { (char *)"Window_InitDialog", (PyCFunction) _wrap_Window_InitDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46095 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46096 { (char *)"Window_GetAcceleratorTable", (PyCFunction) _wrap_Window_GetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
46097 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46098 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
46099 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46100 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
46101 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
46102 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
46103 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46104 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
46105 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
46106 { (char *)"Window_CaptureMouse", (PyCFunction) _wrap_Window_CaptureMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46107 { (char *)"Window_ReleaseMouse", (PyCFunction) _wrap_Window_ReleaseMouse, METH_VARARGS | METH_KEYWORDS, NULL},
46108 { (char *)"Window_GetCapture", (PyCFunction) _wrap_Window_GetCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46109 { (char *)"Window_HasCapture", (PyCFunction) _wrap_Window_HasCapture, METH_VARARGS | METH_KEYWORDS, NULL},
46110 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
46111 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
46112 { (char *)"Window_Update", (PyCFunction) _wrap_Window_Update, METH_VARARGS | METH_KEYWORDS, NULL},
46113 { (char *)"Window_ClearBackground", (PyCFunction) _wrap_Window_ClearBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46114 { (char *)"Window_Freeze", (PyCFunction) _wrap_Window_Freeze, METH_VARARGS | METH_KEYWORDS, NULL},
46115 { (char *)"Window_Thaw", (PyCFunction) _wrap_Window_Thaw, METH_VARARGS | METH_KEYWORDS, NULL},
46116 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
46117 { (char *)"Window_GetUpdateRegion", (PyCFunction) _wrap_Window_GetUpdateRegion, METH_VARARGS | METH_KEYWORDS, NULL},
46118 { (char *)"Window_GetUpdateClientRect", (PyCFunction) _wrap_Window_GetUpdateClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
46119 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
46120 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46121 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
46122 { (char *)"Window_GetDefaultAttributes", (PyCFunction) _wrap_Window_GetDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46123 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46124 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46125 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46126 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46127 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46128 { (char *)"Window_GetBackgroundColour", (PyCFunction) _wrap_Window_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46129 { (char *)"Window_GetForegroundColour", (PyCFunction) _wrap_Window_GetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46130 { (char *)"Window_InheritsBackgroundColour", (PyCFunction) _wrap_Window_InheritsBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46131 { (char *)"Window_UseBgCol", (PyCFunction) _wrap_Window_UseBgCol, METH_VARARGS | METH_KEYWORDS, NULL},
46132 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46133 { (char *)"Window_GetBackgroundStyle", (PyCFunction) _wrap_Window_GetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46134 { (char *)"Window_HasTransparentBackground", (PyCFunction) _wrap_Window_HasTransparentBackground, METH_VARARGS | METH_KEYWORDS, NULL},
46135 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46136 { (char *)"Window_GetCursor", (PyCFunction) _wrap_Window_GetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
46137 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46138 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
46139 { (char *)"Window_GetFont", (PyCFunction) _wrap_Window_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46140 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46141 { (char *)"Window_GetCaret", (PyCFunction) _wrap_Window_GetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
46142 { (char *)"Window_GetCharHeight", (PyCFunction) _wrap_Window_GetCharHeight, METH_VARARGS | METH_KEYWORDS, NULL},
46143 { (char *)"Window_GetCharWidth", (PyCFunction) _wrap_Window_GetCharWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46144 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46145 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
46146 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
46147 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
46148 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
46149 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
46150 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
46151 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
46152 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
46153 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
46154 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
46155 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46156 { (char *)"Window_GetHandle", (PyCFunction) _wrap_Window_GetHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46157 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46158 { (char *)"Window_DissociateHandle", (PyCFunction) _wrap_Window_DissociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
46159 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46160 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
46161 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46162 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
46163 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
46164 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
46165 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46166 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
46167 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
46168 { (char *)"Window_LineUp", (PyCFunction) _wrap_Window_LineUp, METH_VARARGS | METH_KEYWORDS, NULL},
46169 { (char *)"Window_LineDown", (PyCFunction) _wrap_Window_LineDown, METH_VARARGS | METH_KEYWORDS, NULL},
46170 { (char *)"Window_PageUp", (PyCFunction) _wrap_Window_PageUp, METH_VARARGS | METH_KEYWORDS, NULL},
46171 { (char *)"Window_PageDown", (PyCFunction) _wrap_Window_PageDown, METH_VARARGS | METH_KEYWORDS, NULL},
46172 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46173 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
46174 { (char *)"Window_GetHelpText", (PyCFunction) _wrap_Window_GetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
46175 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
46176 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46177 { (char *)"Window_GetToolTip", (PyCFunction) _wrap_Window_GetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
46178 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46179 { (char *)"Window_GetDropTarget", (PyCFunction) _wrap_Window_GetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
46180 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46181 { (char *)"Window_GetConstraints", (PyCFunction) _wrap_Window_GetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46182 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46183 { (char *)"Window_GetAutoLayout", (PyCFunction) _wrap_Window_GetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
46184 { (char *)"Window_Layout", (PyCFunction) _wrap_Window_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46185 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46186 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
46187 { (char *)"Window_GetSizer", (PyCFunction) _wrap_Window_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46188 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46189 { (char *)"Window_GetContainingSizer", (PyCFunction) _wrap_Window_GetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46190 { (char *)"Window_InheritAttributes", (PyCFunction) _wrap_Window_InheritAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46191 { (char *)"Window_ShouldInheritColours", (PyCFunction) _wrap_Window_ShouldInheritColours, METH_VARARGS | METH_KEYWORDS, NULL},
46192 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
46193 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
46194 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
46195 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46196 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
46197 { (char *)"new_Validator", (PyCFunction) _wrap_new_Validator, METH_VARARGS | METH_KEYWORDS, NULL},
46198 { (char *)"Validator_Clone", (PyCFunction) _wrap_Validator_Clone, METH_VARARGS | METH_KEYWORDS, NULL},
46199 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
46200 { (char *)"Validator_TransferToWindow", (PyCFunction) _wrap_Validator_TransferToWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46201 { (char *)"Validator_TransferFromWindow", (PyCFunction) _wrap_Validator_TransferFromWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46202 { (char *)"Validator_GetWindow", (PyCFunction) _wrap_Validator_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46203 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46204 { (char *)"Validator_IsSilent", (PyCFunction) _wrap_Validator_IsSilent, METH_VARARGS | METH_KEYWORDS, NULL},
46205 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
46206 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
46207 { (char *)"new_PyValidator", (PyCFunction) _wrap_new_PyValidator, METH_VARARGS | METH_KEYWORDS, NULL},
46208 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46209 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
46210 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
46211 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46212 { (char *)"Menu_AppendSeparator", (PyCFunction) _wrap_Menu_AppendSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46213 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46214 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46215 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46216 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
46217 { (char *)"Menu_Break", (PyCFunction) _wrap_Menu_Break, METH_VARARGS | METH_KEYWORDS, NULL},
46218 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46219 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46220 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46221 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46222 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46223 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46224 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46225 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46226 { (char *)"Menu_PrependSeparator", (PyCFunction) _wrap_Menu_PrependSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46227 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
46228 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
46229 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46230 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46231 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
46232 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46233 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
46234 { (char *)"Menu_Destroy", (PyCFunction) _wrap_Menu_Destroy, METH_VARARGS | METH_KEYWORDS, NULL},
46235 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
46236 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
46237 { (char *)"Menu_GetMenuItemCount", (PyCFunction) _wrap_Menu_GetMenuItemCount, METH_VARARGS | METH_KEYWORDS, NULL},
46238 { (char *)"Menu_GetMenuItems", (PyCFunction) _wrap_Menu_GetMenuItems, METH_VARARGS | METH_KEYWORDS, NULL},
46239 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
46240 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46241 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46242 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46243 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46244 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46245 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46246 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46247 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46248 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46249 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46250 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46251 { (char *)"Menu_GetTitle", (PyCFunction) _wrap_Menu_GetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
46252 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46253 { (char *)"Menu_GetEventHandler", (PyCFunction) _wrap_Menu_GetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
46254 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46255 { (char *)"Menu_GetInvokingWindow", (PyCFunction) _wrap_Menu_GetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46256 { (char *)"Menu_GetStyle", (PyCFunction) _wrap_Menu_GetStyle, METH_VARARGS | METH_KEYWORDS, NULL},
46257 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
46258 { (char *)"Menu_GetMenuBar", (PyCFunction) _wrap_Menu_GetMenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46259 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46260 { (char *)"Menu_Detach", (PyCFunction) _wrap_Menu_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46261 { (char *)"Menu_IsAttached", (PyCFunction) _wrap_Menu_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46262 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46263 { (char *)"Menu_GetParent", (PyCFunction) _wrap_Menu_GetParent, METH_VARARGS | METH_KEYWORDS, NULL},
46264 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
46265 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
46266 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46267 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46268 { (char *)"MenuBar_GetMenuCount", (PyCFunction) _wrap_MenuBar_GetMenuCount, METH_VARARGS | METH_KEYWORDS, NULL},
46269 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46270 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
46271 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46272 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
46273 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
46274 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46275 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
46276 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46277 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
46278 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46279 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46280 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46281 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46282 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46283 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46284 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46285 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46286 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
46287 { (char *)"MenuBar_GetFrame", (PyCFunction) _wrap_MenuBar_GetFrame, METH_VARARGS | METH_KEYWORDS, NULL},
46288 { (char *)"MenuBar_IsAttached", (PyCFunction) _wrap_MenuBar_IsAttached, METH_VARARGS | METH_KEYWORDS, NULL},
46289 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
46290 { (char *)"MenuBar_Detach", (PyCFunction) _wrap_MenuBar_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46291 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
46292 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
46293 { (char *)"MenuItem_GetMenu", (PyCFunction) _wrap_MenuItem_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46294 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46295 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
46296 { (char *)"MenuItem_GetId", (PyCFunction) _wrap_MenuItem_GetId, METH_VARARGS | METH_KEYWORDS, NULL},
46297 { (char *)"MenuItem_IsSeparator", (PyCFunction) _wrap_MenuItem_IsSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
46298 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
46299 { (char *)"MenuItem_GetLabel", (PyCFunction) _wrap_MenuItem_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46300 { (char *)"MenuItem_GetText", (PyCFunction) _wrap_MenuItem_GetText, METH_VARARGS | METH_KEYWORDS, NULL},
46301 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
46302 { (char *)"MenuItem_GetKind", (PyCFunction) _wrap_MenuItem_GetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46303 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
46304 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46305 { (char *)"MenuItem_IsCheckable", (PyCFunction) _wrap_MenuItem_IsCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
46306 { (char *)"MenuItem_IsSubMenu", (PyCFunction) _wrap_MenuItem_IsSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46307 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46308 { (char *)"MenuItem_GetSubMenu", (PyCFunction) _wrap_MenuItem_GetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
46309 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
46310 { (char *)"MenuItem_IsEnabled", (PyCFunction) _wrap_MenuItem_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
46311 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
46312 { (char *)"MenuItem_IsChecked", (PyCFunction) _wrap_MenuItem_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
46313 { (char *)"MenuItem_Toggle", (PyCFunction) _wrap_MenuItem_Toggle, METH_VARARGS | METH_KEYWORDS, NULL},
46314 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46315 { (char *)"MenuItem_GetHelp", (PyCFunction) _wrap_MenuItem_GetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
46316 { (char *)"MenuItem_GetAccel", (PyCFunction) _wrap_MenuItem_GetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46317 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
46318 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46319 { (char *)"MenuItem_GetFont", (PyCFunction) _wrap_MenuItem_GetFont, METH_VARARGS | METH_KEYWORDS, NULL},
46320 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46321 { (char *)"MenuItem_GetTextColour", (PyCFunction) _wrap_MenuItem_GetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
46322 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46323 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction) _wrap_MenuItem_GetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
46324 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
46325 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46326 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction) _wrap_MenuItem_GetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46327 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46328 { (char *)"MenuItem_GetMarginWidth", (PyCFunction) _wrap_MenuItem_GetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46329 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction) _wrap_MenuItem_GetDefaultMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
46330 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction) _wrap_MenuItem_IsOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46331 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46332 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction) _wrap_MenuItem_ResetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
46333 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46334 { (char *)"MenuItem_GetBitmap", (PyCFunction) _wrap_MenuItem_GetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
46335 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
46336 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
46337 { (char *)"new_PreControl", (PyCFunction) _wrap_new_PreControl, METH_VARARGS | METH_KEYWORDS, NULL},
46338 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
46339 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
46340 { (char *)"Control_GetLabel", (PyCFunction) _wrap_Control_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46341 { (char *)"Control_SetLabel", (PyCFunction) _wrap_Control_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
46342 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
46343 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
46344 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
46345 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
46346 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46347 { (char *)"ItemContainer_Clear", (PyCFunction) _wrap_ItemContainer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46348 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
46349 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46350 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
46351 { (char *)"ItemContainer_GetCount", (PyCFunction) _wrap_ItemContainer_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
46352 { (char *)"ItemContainer_IsEmpty", (PyCFunction) _wrap_ItemContainer_IsEmpty, METH_VARARGS | METH_KEYWORDS, NULL},
46353 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
46354 { (char *)"ItemContainer_GetStrings", (PyCFunction) _wrap_ItemContainer_GetStrings, METH_VARARGS | METH_KEYWORDS, NULL},
46355 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
46356 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
46357 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46358 { (char *)"ItemContainer_GetSelection", (PyCFunction) _wrap_ItemContainer_GetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46359 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46360 { (char *)"ItemContainer_GetStringSelection", (PyCFunction) _wrap_ItemContainer_GetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
46361 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
46362 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
46363 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
46364 { (char *)"new_SizerItem", (PyCFunction) _wrap_new_SizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46365 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46366 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46367 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46368 { (char *)"SizerItem_DeleteWindows", (PyCFunction) _wrap_SizerItem_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46369 { (char *)"SizerItem_DetachSizer", (PyCFunction) _wrap_SizerItem_DetachSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46370 { (char *)"SizerItem_GetSize", (PyCFunction) _wrap_SizerItem_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46371 { (char *)"SizerItem_CalcMin", (PyCFunction) _wrap_SizerItem_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46372 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46373 { (char *)"SizerItem_GetMinSize", (PyCFunction) _wrap_SizerItem_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46374 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction) _wrap_SizerItem_GetMinSizeWithBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46375 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
46376 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
46377 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
46378 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46379 { (char *)"SizerItem_GetRatio", (PyCFunction) _wrap_SizerItem_GetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
46380 { (char *)"SizerItem_GetRect", (PyCFunction) _wrap_SizerItem_GetRect, METH_VARARGS | METH_KEYWORDS, NULL},
46381 { (char *)"SizerItem_IsWindow", (PyCFunction) _wrap_SizerItem_IsWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46382 { (char *)"SizerItem_IsSizer", (PyCFunction) _wrap_SizerItem_IsSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46383 { (char *)"SizerItem_IsSpacer", (PyCFunction) _wrap_SizerItem_IsSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46384 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46385 { (char *)"SizerItem_GetProportion", (PyCFunction) _wrap_SizerItem_GetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
46386 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46387 { (char *)"SizerItem_GetFlag", (PyCFunction) _wrap_SizerItem_GetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
46388 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46389 { (char *)"SizerItem_GetBorder", (PyCFunction) _wrap_SizerItem_GetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
46390 { (char *)"SizerItem_GetWindow", (PyCFunction) _wrap_SizerItem_GetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46391 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46392 { (char *)"SizerItem_GetSizer", (PyCFunction) _wrap_SizerItem_GetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46393 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46394 { (char *)"SizerItem_GetSpacer", (PyCFunction) _wrap_SizerItem_GetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46395 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46396 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46397 { (char *)"SizerItem_IsShown", (PyCFunction) _wrap_SizerItem_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46398 { (char *)"SizerItem_GetPosition", (PyCFunction) _wrap_SizerItem_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46399 { (char *)"SizerItem_GetUserData", (PyCFunction) _wrap_SizerItem_GetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
46400 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
46401 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46402 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46403 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
46404 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
46405 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
46406 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
46407 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
46408 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46409 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46410 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
46411 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
46412 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
46413 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46414 { (char *)"Sizer_GetSize", (PyCFunction) _wrap_Sizer_GetSize, METH_VARARGS | METH_KEYWORDS, NULL},
46415 { (char *)"Sizer_GetPosition", (PyCFunction) _wrap_Sizer_GetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46416 { (char *)"Sizer_GetMinSize", (PyCFunction) _wrap_Sizer_GetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
46417 { (char *)"Sizer_RecalcSizes", (PyCFunction) _wrap_Sizer_RecalcSizes, METH_VARARGS | METH_KEYWORDS, NULL},
46418 { (char *)"Sizer_CalcMin", (PyCFunction) _wrap_Sizer_CalcMin, METH_VARARGS | METH_KEYWORDS, NULL},
46419 { (char *)"Sizer_Layout", (PyCFunction) _wrap_Sizer_Layout, METH_VARARGS | METH_KEYWORDS, NULL},
46420 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
46421 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
46422 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46423 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
46424 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
46425 { (char *)"Sizer_DeleteWindows", (PyCFunction) _wrap_Sizer_DeleteWindows, METH_VARARGS | METH_KEYWORDS, NULL},
46426 { (char *)"Sizer_GetChildren", (PyCFunction) _wrap_Sizer_GetChildren, METH_VARARGS | METH_KEYWORDS, NULL},
46427 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
46428 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
46429 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
46430 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
46431 { (char *)"new_PySizer", (PyCFunction) _wrap_new_PySizer, METH_VARARGS | METH_KEYWORDS, NULL},
46432 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
46433 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
46434 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46435 { (char *)"BoxSizer_GetOrientation", (PyCFunction) _wrap_BoxSizer_GetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46436 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
46437 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
46438 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46439 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction) _wrap_StaticBoxSizer_GetStaticBox, METH_VARARGS | METH_KEYWORDS, NULL},
46440 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
46441 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46442 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46443 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46444 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46445 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46446 { (char *)"GridSizer_GetCols", (PyCFunction) _wrap_GridSizer_GetCols, METH_VARARGS | METH_KEYWORDS, NULL},
46447 { (char *)"GridSizer_GetRows", (PyCFunction) _wrap_GridSizer_GetRows, METH_VARARGS | METH_KEYWORDS, NULL},
46448 { (char *)"GridSizer_GetVGap", (PyCFunction) _wrap_GridSizer_GetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
46449 { (char *)"GridSizer_GetHGap", (PyCFunction) _wrap_GridSizer_GetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
46450 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
46451 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46452 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46453 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
46454 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46455 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
46456 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46457 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_GetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
46458 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46459 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
46460 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction) _wrap_FlexGridSizer_GetRowHeights, METH_VARARGS | METH_KEYWORDS, NULL},
46461 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction) _wrap_FlexGridSizer_GetColWidths, METH_VARARGS | METH_KEYWORDS, NULL},
46462 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
46463 { (char *)"new_StdDialogButtonSizer", (PyCFunction) _wrap_new_StdDialogButtonSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46464 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
46465 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction) _wrap_StdDialogButtonSizer_Realize, METH_VARARGS | METH_KEYWORDS, NULL},
46466 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46467 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46468 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46469 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46470 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetApplyButton, METH_VARARGS | METH_KEYWORDS, NULL},
46471 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
46472 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
46473 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction) _wrap_StdDialogButtonSizer_GetHelpButton, METH_VARARGS | METH_KEYWORDS, NULL},
46474 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
46475 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46476 { (char *)"GBPosition_GetRow", (PyCFunction) _wrap_GBPosition_GetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46477 { (char *)"GBPosition_GetCol", (PyCFunction) _wrap_GBPosition_GetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46478 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
46479 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
46480 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46481 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46482 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46483 { (char *)"GBPosition_Get", (PyCFunction) _wrap_GBPosition_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46484 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
46485 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46486 { (char *)"GBSpan_GetRowspan", (PyCFunction) _wrap_GBSpan_GetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46487 { (char *)"GBSpan_GetColspan", (PyCFunction) _wrap_GBSpan_GetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46488 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
46489 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
46490 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
46491 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
46492 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46493 { (char *)"GBSpan_Get", (PyCFunction) _wrap_GBSpan_Get, METH_VARARGS | METH_KEYWORDS, NULL},
46494 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
46495 { (char *)"new_GBSizerItem", (PyCFunction) _wrap_new_GBSizerItem, METH_VARARGS | METH_KEYWORDS, NULL},
46496 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46497 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46498 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
46499 { (char *)"GBSizerItem_GetPos", (PyCFunction) _wrap_GBSizerItem_GetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46500 { (char *)"GBSizerItem_GetSpan", (PyCFunction) _wrap_GBSizerItem_GetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46501 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
46502 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
46503 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
46504 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
46505 { (char *)"GBSizerItem_GetEndPos", (PyCFunction) _wrap_GBSizerItem_GetEndPos, METH_VARARGS | METH_KEYWORDS, NULL},
46506 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction) _wrap_GBSizerItem_GetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46507 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46508 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
46509 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
46510 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
46511 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
46512 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46513 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_GetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46514 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
46515 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
46516 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
46517 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
46518 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
46519 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
46520 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
46521 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
46522 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
46523 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
46524 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
46525 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
46526 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
46527 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
46528 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
46529 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
46530 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
46531 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
46532 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
46533 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction) _wrap_IndividualLayoutConstraint_Unconstrained, METH_VARARGS | METH_KEYWORDS, NULL},
46534 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction) _wrap_IndividualLayoutConstraint_AsIs, METH_VARARGS | METH_KEYWORDS, NULL},
46535 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherWindow, METH_VARARGS | METH_KEYWORDS, NULL},
46536 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMyEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46537 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46538 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46539 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_GetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46540 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
46541 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_GetValue, METH_VARARGS | METH_KEYWORDS, NULL},
46542 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction) _wrap_IndividualLayoutConstraint_GetPercent, METH_VARARGS | METH_KEYWORDS, NULL},
46543 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetOtherEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46544 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_GetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46545 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
46546 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_GetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46547 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
46548 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
46549 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
46550 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
46551 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
46552 { (char *)"LayoutConstraints_left_get", (PyCFunction) _wrap_LayoutConstraints_left_get, METH_VARARGS | METH_KEYWORDS, NULL},
46553 { (char *)"LayoutConstraints_top_get", (PyCFunction) _wrap_LayoutConstraints_top_get, METH_VARARGS | METH_KEYWORDS, NULL},
46554 { (char *)"LayoutConstraints_right_get", (PyCFunction) _wrap_LayoutConstraints_right_get, METH_VARARGS | METH_KEYWORDS, NULL},
46555 { (char *)"LayoutConstraints_bottom_get", (PyCFunction) _wrap_LayoutConstraints_bottom_get, METH_VARARGS | METH_KEYWORDS, NULL},
46556 { (char *)"LayoutConstraints_width_get", (PyCFunction) _wrap_LayoutConstraints_width_get, METH_VARARGS | METH_KEYWORDS, NULL},
46557 { (char *)"LayoutConstraints_height_get", (PyCFunction) _wrap_LayoutConstraints_height_get, METH_VARARGS | METH_KEYWORDS, NULL},
46558 { (char *)"LayoutConstraints_centreX_get", (PyCFunction) _wrap_LayoutConstraints_centreX_get, METH_VARARGS | METH_KEYWORDS, NULL},
46559 { (char *)"LayoutConstraints_centreY_get", (PyCFunction) _wrap_LayoutConstraints_centreY_get, METH_VARARGS | METH_KEYWORDS, NULL},
46560 { (char *)"new_LayoutConstraints", (PyCFunction) _wrap_new_LayoutConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46561 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
46562 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction) _wrap_LayoutConstraints_AreSatisfied, METH_VARARGS | METH_KEYWORDS, NULL},
46563 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
46564 { NULL, NULL, 0, NULL }
46565 };
46566
46567
46568 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
46569
46570 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
46571 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
46572 }
46573 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
46574 return (void *)((wxSizer *) ((wxBoxSizer *) x));
46575 }
46576 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
46577 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
46578 }
46579 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
46580 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46581 }
46582 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
46583 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46584 }
46585 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
46586 return (void *)((wxSizer *) ((wxGridSizer *) x));
46587 }
46588 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
46589 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
46590 }
46591 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
46592 return (void *)((wxSizer *) ((wxPySizer *) x));
46593 }
46594 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
46595 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
46596 }
46597 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
46598 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46599 }
46600 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
46601 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
46602 }
46603 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
46604 return (void *)((wxEvent *) ((wxMenuEvent *) x));
46605 }
46606 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
46607 return (void *)((wxEvent *) ((wxCloseEvent *) x));
46608 }
46609 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
46610 return (void *)((wxEvent *) ((wxMouseEvent *) x));
46611 }
46612 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
46613 return (void *)((wxEvent *) ((wxEraseEvent *) x));
46614 }
46615 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
46616 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
46617 }
46618 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
46619 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
46620 }
46621 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
46622 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
46623 }
46624 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
46625 return (void *)((wxEvent *) ((wxPyEvent *) x));
46626 }
46627 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
46628 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
46629 }
46630 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
46631 return (void *)((wxEvent *) ((wxIdleEvent *) x));
46632 }
46633 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
46634 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
46635 }
46636 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
46637 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
46638 }
46639 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
46640 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
46641 }
46642 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
46643 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
46644 }
46645 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
46646 return (void *)((wxEvent *) ((wxActivateEvent *) x));
46647 }
46648 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
46649 return (void *)((wxEvent *) ((wxSizeEvent *) x));
46650 }
46651 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
46652 return (void *)((wxEvent *) ((wxMoveEvent *) x));
46653 }
46654 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
46655 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
46656 }
46657 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
46658 return (void *)((wxEvent *) ((wxPaintEvent *) x));
46659 }
46660 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
46661 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
46662 }
46663 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
46664 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
46665 }
46666 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
46667 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
46668 }
46669 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
46670 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
46671 }
46672 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
46673 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46674 }
46675 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
46676 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
46677 }
46678 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
46679 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
46680 }
46681 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
46682 return (void *)((wxEvent *) ((wxFocusEvent *) x));
46683 }
46684 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
46685 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
46686 }
46687 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
46688 return (void *)((wxEvent *) ((wxShowEvent *) x));
46689 }
46690 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
46691 return (void *)((wxEvent *) ((wxCommandEvent *) x));
46692 }
46693 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
46694 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
46695 }
46696 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
46697 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46698 }
46699 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
46700 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
46701 }
46702 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
46703 return (void *)((wxEvent *) ((wxKeyEvent *) x));
46704 }
46705 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
46706 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
46707 }
46708 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
46709 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
46710 }
46711 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
46712 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
46713 }
46714 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
46715 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
46716 }
46717 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
46718 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
46719 }
46720 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
46721 return (void *)((wxControl *) ((wxControlWithItems *) x));
46722 }
46723 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
46724 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
46725 }
46726 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
46727 return (void *)((wxEvtHandler *) ((wxWindow *) x));
46728 }
46729 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
46730 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
46731 }
46732 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
46733 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
46734 }
46735 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
46736 return (void *)((wxEvtHandler *) ((wxValidator *) x));
46737 }
46738 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
46739 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
46740 }
46741 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
46742 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
46743 }
46744 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
46745 return (void *)((wxEvtHandler *) ((wxMenu *) x));
46746 }
46747 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
46748 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
46749 }
46750 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
46751 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
46752 }
46753 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
46754 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
46755 }
46756 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
46757 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
46758 }
46759 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
46760 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
46761 }
46762 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
46763 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46764 }
46765 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
46766 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
46767 }
46768 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
46769 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
46770 }
46771 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
46772 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46773 }
46774 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
46775 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46776 }
46777 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
46778 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
46779 }
46780 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
46781 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
46782 }
46783 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
46784 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
46785 }
46786 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
46787 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
46788 }
46789 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
46790 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
46791 }
46792 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
46793 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
46794 }
46795 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
46796 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
46797 }
46798 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
46799 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
46800 }
46801 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
46802 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
46803 }
46804 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
46805 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
46806 }
46807 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
46808 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
46809 }
46810 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
46811 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
46812 }
46813 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
46814 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
46815 }
46816 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
46817 return (void *)((wxObject *) ((wxSizerItem *) x));
46818 }
46819 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
46820 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
46821 }
46822 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
46823 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
46824 }
46825 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
46826 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
46827 }
46828 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
46829 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
46830 }
46831 static void *_p_wxSizerTo_p_wxObject(void *x) {
46832 return (void *)((wxObject *) ((wxSizer *) x));
46833 }
46834 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
46835 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
46836 }
46837 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
46838 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
46839 }
46840 static void *_p_wxEventTo_p_wxObject(void *x) {
46841 return (void *)((wxObject *) ((wxEvent *) x));
46842 }
46843 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
46844 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
46845 }
46846 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
46847 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
46848 }
46849 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
46850 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
46851 }
46852 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
46853 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
46854 }
46855 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
46856 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
46857 }
46858 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
46859 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
46860 }
46861 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
46862 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
46863 }
46864 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
46865 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
46866 }
46867 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
46868 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
46869 }
46870 static void *_p_wxControlTo_p_wxObject(void *x) {
46871 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
46872 }
46873 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
46874 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
46875 }
46876 static void *_p_wxFSFileTo_p_wxObject(void *x) {
46877 return (void *)((wxObject *) ((wxFSFile *) x));
46878 }
46879 static void *_p_wxPySizerTo_p_wxObject(void *x) {
46880 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
46881 }
46882 static void *_p_wxPyEventTo_p_wxObject(void *x) {
46883 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
46884 }
46885 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
46886 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
46887 }
46888 static void *_p_wxShowEventTo_p_wxObject(void *x) {
46889 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
46890 }
46891 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
46892 return (void *)((wxObject *) ((wxMenuItem *) x));
46893 }
46894 static void *_p_wxDateEventTo_p_wxObject(void *x) {
46895 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
46896 }
46897 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
46898 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
46899 }
46900 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
46901 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
46902 }
46903 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
46904 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
46905 }
46906 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
46907 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
46908 }
46909 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
46910 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
46911 }
46912 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
46913 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
46914 }
46915 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
46916 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
46917 }
46918 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
46919 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
46920 }
46921 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
46922 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
46923 }
46924 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
46925 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
46926 }
46927 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
46928 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
46929 }
46930 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
46931 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
46932 }
46933 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
46934 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
46935 }
46936 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
46937 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
46938 }
46939 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
46940 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
46941 }
46942 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
46943 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
46944 }
46945 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
46946 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
46947 }
46948 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
46949 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
46950 }
46951 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
46952 return (void *)((wxObject *) ((wxImageHandler *) x));
46953 }
46954 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
46955 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
46956 }
46957 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
46958 return (void *)((wxObject *) ((wxEvtHandler *) x));
46959 }
46960 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
46961 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
46962 }
46963 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
46964 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
46965 }
46966 static void *_p_wxImageTo_p_wxObject(void *x) {
46967 return (void *)((wxObject *) ((wxImage *) x));
46968 }
46969 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
46970 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
46971 }
46972 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
46973 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
46974 }
46975 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
46976 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
46977 }
46978 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
46979 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
46980 }
46981 static void *_p_wxWindowTo_p_wxObject(void *x) {
46982 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
46983 }
46984 static void *_p_wxMenuTo_p_wxObject(void *x) {
46985 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
46986 }
46987 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
46988 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
46989 }
46990 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
46991 return (void *)((wxObject *) ((wxFileSystem *) x));
46992 }
46993 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
46994 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
46995 }
46996 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
46997 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
46998 }
46999 static void *_p_wxPyAppTo_p_wxObject(void *x) {
47000 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
47001 }
47002 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
47003 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
47004 }
47005 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
47006 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
47007 }
47008 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
47009 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
47010 }
47011 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
47012 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
47013 }
47014 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
47015 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
47016 }
47017 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
47018 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
47019 }
47020 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
47021 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
47022 }
47023 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
47024 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
47025 }
47026 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
47027 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
47028 }
47029 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
47030 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
47031 }
47032 static void *_p_wxValidatorTo_p_wxObject(void *x) {
47033 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
47034 }
47035 static void *_p_wxControlTo_p_wxWindow(void *x) {
47036 return (void *)((wxWindow *) ((wxControl *) x));
47037 }
47038 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
47039 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
47040 }
47041 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
47042 return (void *)((wxWindow *) ((wxMenuBar *) x));
47043 }
47044 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
47045 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
47046 }
47047 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
47048 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
47049 }
47050 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
47051 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
47052 }
47053 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
47054 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
47055 }
47056 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
47057 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
47058 }
47059 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
47060 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
47061 }
47062 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
47063 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
47064 }
47065 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
47066 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
47067 }
47068 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
47069 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
47070 }
47071 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
47072 return (void *)((wxValidator *) ((wxPyValidator *) x));
47073 }
47074 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}};
47075 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}};
47076 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}};
47077 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}};
47078 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}};
47079 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}};
47080 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}};
47081 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}};
47082 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}};
47083 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}};
47084 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}};
47085 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}};
47086 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}};
47087 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}};
47088 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}};
47089 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}};
47090 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}};
47091 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}};
47092 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}};
47093 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}};
47094 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}};
47095 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}};
47096 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}};
47097 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}};
47098 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}};
47099 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}};
47100 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}};
47101 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}};
47102 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}};
47103 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}};
47104 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}};
47105 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}};
47106 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}};
47107 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}};
47108 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}};
47109 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}};
47110 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}};
47111 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}};
47112 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}};
47113 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}};
47114 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}};
47115 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}};
47116 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}};
47117 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}};
47118 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}};
47119 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}};
47120 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}};
47121 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}};
47122 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}};
47123 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}};
47124 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}};
47125 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}};
47126 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}};
47127 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}};
47128 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}};
47129 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}};
47130 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}};
47131 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}};
47132 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}};
47133 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}};
47134 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}};
47135 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}};
47136 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}};
47137 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}};
47138 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}};
47139 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}};
47140 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}};
47141 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}};
47142 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}};
47143 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}};
47144 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}};
47145 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}};
47146 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}};
47147 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}};
47148 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}};
47149 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}};
47150 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}};
47151 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}};
47152 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}};
47153 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}};
47154 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}};
47155 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}};
47156 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}};
47157 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}};
47158 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}};
47159 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}};
47160 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}};
47161 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}};
47162 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}};
47163 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}};
47164 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}};
47165 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}};
47166 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}};
47167 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}};
47168 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}};
47169 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}};
47170 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}};
47171 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}};
47172 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}};
47173 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}};
47174 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}};
47175 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}};
47176 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}};
47177 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}};
47178 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}};
47179 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}};
47180 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}};
47181 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}};
47182 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}};
47183 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}};
47184 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}};
47185 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}};
47186 static swig_type_info _swigt__p_unsigned_char[] = {{"_p_unsigned_char", 0, "unsigned char *", 0, 0, 0, 0},{"_p_unsigned_char", 0, 0, 0, 0, 0, 0},{0, 0, 0, 0, 0, 0, 0}};
47187 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}};
47188 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}};
47189 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}};
47190 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}};
47191 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}};
47192 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}};
47193 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}};
47194 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}};
47195 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}};
47196 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}};
47197 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}};
47198 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}};
47199 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}};
47200 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}};
47201 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}};
47202
47203 static swig_type_info *swig_types_initial[] = {
47204 _swigt__p_wxLayoutConstraints,
47205 _swigt__p_wxRealPoint,
47206 _swigt__p_wxSizerItem,
47207 _swigt__p_wxGBSizerItem,
47208 _swigt__p_wxScrollEvent,
47209 _swigt__p_wxEventLoop,
47210 _swigt__p_wxIndividualLayoutConstraint,
47211 _swigt__p_wxSizer,
47212 _swigt__p_wxBoxSizer,
47213 _swigt__p_wxStaticBoxSizer,
47214 _swigt__p_wxGridBagSizer,
47215 _swigt__p_wxAcceleratorEntry,
47216 _swigt__p_wxUpdateUIEvent,
47217 _swigt__p_wxEvent,
47218 _swigt__p_buffer,
47219 _swigt__p_wxMenu,
47220 _swigt__p_wxGridSizer,
47221 _swigt__p_wxFlexGridSizer,
47222 _swigt__p_wxInitDialogEvent,
47223 _swigt__p_wxItemContainer,
47224 _swigt__p_wxNcPaintEvent,
47225 _swigt__p_wxPaintEvent,
47226 _swigt__p_wxSysColourChangedEvent,
47227 _swigt__p_wxMouseCaptureChangedEvent,
47228 _swigt__p_wxDisplayChangedEvent,
47229 _swigt__p_wxPaletteChangedEvent,
47230 _swigt__p_wxControl,
47231 _swigt__p_wxFont,
47232 _swigt__p_wxMenuBarBase,
47233 _swigt__p_wxSetCursorEvent,
47234 _swigt__p_wxFSFile,
47235 _swigt__p_wxCaret,
47236 _swigt__ptrdiff_t,
47237 _swigt__std__ptrdiff_t,
47238 _swigt__p_wxRegion,
47239 _swigt__p_wxPoint2D,
47240 _swigt__p_int,
47241 _swigt__p_wxSize,
47242 _swigt__p_wxDC,
47243 _swigt__p_wxPySizer,
47244 _swigt__p_wxVisualAttributes,
47245 _swigt__p_wxNotifyEvent,
47246 _swigt__p_wxPyEvent,
47247 _swigt__p_wxPropagationDisabler,
47248 _swigt__p_form_ops_t,
47249 _swigt__p_wxAppTraits,
47250 _swigt__p_wxArrayString,
47251 _swigt__p_wxShowEvent,
47252 _swigt__p_wxToolTip,
47253 _swigt__p_wxMoveEvent,
47254 _swigt__p_wxSizeEvent,
47255 _swigt__p_wxActivateEvent,
47256 _swigt__p_wxIconizeEvent,
47257 _swigt__p_wxMaximizeEvent,
47258 _swigt__p_wxQueryNewPaletteEvent,
47259 _swigt__p_wxWindowCreateEvent,
47260 _swigt__p_wxIdleEvent,
47261 _swigt__p_wxDateEvent,
47262 _swigt__p_wxMenuItem,
47263 _swigt__p_wxStaticBox,
47264 _swigt__p_long,
47265 _swigt__p_wxDuplexMode,
47266 _swigt__p_wxTIFFHandler,
47267 _swigt__p_wxXPMHandler,
47268 _swigt__p_wxPNMHandler,
47269 _swigt__p_wxJPEGHandler,
47270 _swigt__p_wxPCXHandler,
47271 _swigt__p_wxGIFHandler,
47272 _swigt__p_wxPNGHandler,
47273 _swigt__p_wxANIHandler,
47274 _swigt__p_wxMemoryFSHandler,
47275 _swigt__p_wxZipFSHandler,
47276 _swigt__p_wxInternetFSHandler,
47277 _swigt__p_wxPyFileSystemHandler,
47278 _swigt__p_wxEvtHandler,
47279 _swigt__p_wxCURHandler,
47280 _swigt__p_wxICOHandler,
47281 _swigt__p_wxBMPHandler,
47282 _swigt__p_wxImageHandler,
47283 _swigt__p_wxFileSystemHandler,
47284 _swigt__p_wxRect,
47285 _swigt__p_wxButton,
47286 _swigt__p_wxGBSpan,
47287 _swigt__p_wxPropagateOnce,
47288 _swigt__p_wxAcceleratorTable,
47289 _swigt__p_wxStdDialogButtonSizer,
47290 _swigt__p_char,
47291 _swigt__p_wxGBPosition,
47292 _swigt__p_wxImage,
47293 _swigt__p_wxFrame,
47294 _swigt__p_wxScrollWinEvent,
47295 _swigt__p_wxPaperSize,
47296 _swigt__p_wxImageHistogram,
47297 _swigt__p_wxPoint,
47298 _swigt__p_wxCursor,
47299 _swigt__p_wxObject,
47300 _swigt__p_wxInputStream,
47301 _swigt__p_wxOutputStream,
47302 _swigt__p_wxPyInputStream,
47303 _swigt__p_wxDateTime,
47304 _swigt__p_wxKeyEvent,
47305 _swigt__p_wxNavigationKeyEvent,
47306 _swigt__p_wxWindowDestroyEvent,
47307 _swigt__p_unsigned_long,
47308 _swigt__p_wxWindow,
47309 _swigt__p_wxMenuBar,
47310 _swigt__p_wxFileSystem,
47311 _swigt__p_wxBitmap,
47312 _swigt__unsigned_int,
47313 _swigt__p_unsigned_int,
47314 _swigt__p_wxMenuEvent,
47315 _swigt__p_wxContextMenuEvent,
47316 _swigt__p_unsigned_char,
47317 _swigt__p_wxEraseEvent,
47318 _swigt__p_wxMouseEvent,
47319 _swigt__p_wxCloseEvent,
47320 _swigt__p_wxPyApp,
47321 _swigt__p_wxCommandEvent,
47322 _swigt__p_wxPyCommandEvent,
47323 _swigt__p_wxPyDropTarget,
47324 _swigt__p_wxQuantize,
47325 _swigt__p_wxFocusEvent,
47326 _swigt__p_wxChildFocusEvent,
47327 _swigt__p_wxDropFilesEvent,
47328 _swigt__p_wxControlWithItems,
47329 _swigt__p_wxColour,
47330 _swigt__p_wxValidator,
47331 _swigt__p_wxPyValidator,
47332 0
47333 };
47334
47335
47336 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
47337
47338 static swig_const_info swig_const_table[] = {
47339 {0, 0, 0, 0.0, 0, 0}};
47340
47341 #ifdef __cplusplus
47342 }
47343 #endif
47344
47345
47346 #ifdef __cplusplus
47347 extern "C" {
47348 #endif
47349
47350 /* Python-specific SWIG API */
47351 #define SWIG_newvarlink() SWIG_Python_newvarlink()
47352 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
47353 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
47354
47355 /* -----------------------------------------------------------------------------
47356 * global variable support code.
47357 * ----------------------------------------------------------------------------- */
47358
47359 typedef struct swig_globalvar {
47360 char *name; /* Name of global variable */
47361 PyObject *(*get_attr)(); /* Return the current value */
47362 int (*set_attr)(PyObject *); /* Set the value */
47363 struct swig_globalvar *next;
47364 } swig_globalvar;
47365
47366 typedef struct swig_varlinkobject {
47367 PyObject_HEAD
47368 swig_globalvar *vars;
47369 } swig_varlinkobject;
47370
47371 static PyObject *
47372 swig_varlink_repr(swig_varlinkobject *v) {
47373 v = v;
47374 return PyString_FromString("<Swig global variables>");
47375 }
47376
47377 static int
47378 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int flags) {
47379 swig_globalvar *var;
47380 flags = flags;
47381 fprintf(fp,"Swig global variables { ");
47382 for (var = v->vars; var; var=var->next) {
47383 fprintf(fp,"%s", var->name);
47384 if (var->next) fprintf(fp,", ");
47385 }
47386 fprintf(fp," }\n");
47387 return 0;
47388 }
47389
47390 static PyObject *
47391 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
47392 swig_globalvar *var = v->vars;
47393 while (var) {
47394 if (strcmp(var->name,n) == 0) {
47395 return (*var->get_attr)();
47396 }
47397 var = var->next;
47398 }
47399 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47400 return NULL;
47401 }
47402
47403 static int
47404 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
47405 swig_globalvar *var = v->vars;
47406 while (var) {
47407 if (strcmp(var->name,n) == 0) {
47408 return (*var->set_attr)(p);
47409 }
47410 var = var->next;
47411 }
47412 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
47413 return 1;
47414 }
47415
47416 static PyTypeObject varlinktype = {
47417 PyObject_HEAD_INIT(0)
47418 0, /* Number of items in variable part (ob_size) */
47419 (char *)"swigvarlink", /* Type name (tp_name) */
47420 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
47421 0, /* Itemsize (tp_itemsize) */
47422 0, /* Deallocator (tp_dealloc) */
47423 (printfunc) swig_varlink_print, /* Print (tp_print) */
47424 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
47425 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
47426 0, /* tp_compare */
47427 (reprfunc) swig_varlink_repr, /* tp_repr */
47428 0, /* tp_as_number */
47429 0, /* tp_as_sequence */
47430 0, /* tp_as_mapping */
47431 0, /* tp_hash */
47432 0, /* tp_call */
47433 0, /* tp_str */
47434 0, /* tp_getattro */
47435 0, /* tp_setattro */
47436 0, /* tp_as_buffer */
47437 0, /* tp_flags */
47438 0, /* tp_doc */
47439 #if PY_VERSION_HEX >= 0x02000000
47440 0, /* tp_traverse */
47441 0, /* tp_clear */
47442 #endif
47443 #if PY_VERSION_HEX >= 0x02010000
47444 0, /* tp_richcompare */
47445 0, /* tp_weaklistoffset */
47446 #endif
47447 #if PY_VERSION_HEX >= 0x02020000
47448 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
47449 #endif
47450 #if PY_VERSION_HEX >= 0x02030000
47451 0, /* tp_del */
47452 #endif
47453 #ifdef COUNT_ALLOCS
47454 0,0,0,0 /* tp_alloc -> tp_next */
47455 #endif
47456 };
47457
47458 /* Create a variable linking object for use later */
47459 static PyObject *
47460 SWIG_Python_newvarlink(void) {
47461 swig_varlinkobject *result = 0;
47462 result = PyMem_NEW(swig_varlinkobject,1);
47463 varlinktype.ob_type = &PyType_Type; /* Patch varlinktype into a PyType */
47464 result->ob_type = &varlinktype;
47465 result->vars = 0;
47466 result->ob_refcnt = 0;
47467 Py_XINCREF((PyObject *) result);
47468 return ((PyObject*) result);
47469 }
47470
47471 static void
47472 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
47473 swig_varlinkobject *v;
47474 swig_globalvar *gv;
47475 v= (swig_varlinkobject *) p;
47476 gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
47477 gv->name = (char *) malloc(strlen(name)+1);
47478 strcpy(gv->name,name);
47479 gv->get_attr = get_attr;
47480 gv->set_attr = set_attr;
47481 gv->next = v->vars;
47482 v->vars = gv;
47483 }
47484
47485 /* -----------------------------------------------------------------------------
47486 * constants/methods manipulation
47487 * ----------------------------------------------------------------------------- */
47488
47489 /* Install Constants */
47490 static void
47491 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
47492 PyObject *obj = 0;
47493 size_t i;
47494 for (i = 0; constants[i].type; i++) {
47495 switch(constants[i].type) {
47496 case SWIG_PY_INT:
47497 obj = PyInt_FromLong(constants[i].lvalue);
47498 break;
47499 case SWIG_PY_FLOAT:
47500 obj = PyFloat_FromDouble(constants[i].dvalue);
47501 break;
47502 case SWIG_PY_STRING:
47503 if (constants[i].pvalue) {
47504 obj = PyString_FromString((char *) constants[i].pvalue);
47505 } else {
47506 Py_INCREF(Py_None);
47507 obj = Py_None;
47508 }
47509 break;
47510 case SWIG_PY_POINTER:
47511 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
47512 break;
47513 case SWIG_PY_BINARY:
47514 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
47515 break;
47516 default:
47517 obj = 0;
47518 break;
47519 }
47520 if (obj) {
47521 PyDict_SetItemString(d,constants[i].name,obj);
47522 Py_DECREF(obj);
47523 }
47524 }
47525 }
47526
47527 /* -----------------------------------------------------------------------------*/
47528 /* Fix SwigMethods to carry the callback ptrs when needed */
47529 /* -----------------------------------------------------------------------------*/
47530
47531 static void
47532 SWIG_Python_FixMethods(PyMethodDef *methods,
47533 swig_const_info *const_table,
47534 swig_type_info **types,
47535 swig_type_info **types_initial) {
47536 size_t i;
47537 for (i = 0; methods[i].ml_name; ++i) {
47538 char *c = methods[i].ml_doc;
47539 if (c && (c = strstr(c, "swig_ptr: "))) {
47540 int j;
47541 swig_const_info *ci = 0;
47542 char *name = c + 10;
47543 for (j = 0; const_table[j].type; j++) {
47544 if (strncmp(const_table[j].name, name,
47545 strlen(const_table[j].name)) == 0) {
47546 ci = &(const_table[j]);
47547 break;
47548 }
47549 }
47550 if (ci) {
47551 size_t shift = (ci->ptype) - types;
47552 swig_type_info *ty = types_initial[shift];
47553 size_t ldoc = (c - methods[i].ml_doc);
47554 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
47555 char *ndoc = (char*)malloc(ldoc + lptr + 10);
47556 char *buff = ndoc;
47557 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue: (void *)(ci->lvalue);
47558 strncpy(buff, methods[i].ml_doc, ldoc);
47559 buff += ldoc;
47560 strncpy(buff, "swig_ptr: ", 10);
47561 buff += 10;
47562 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
47563 methods[i].ml_doc = ndoc;
47564 }
47565 }
47566 }
47567 }
47568
47569 /* -----------------------------------------------------------------------------*
47570 * Initialize type list
47571 * -----------------------------------------------------------------------------*/
47572
47573 #if PY_MAJOR_VERSION < 2
47574 /* PyModule_AddObject function was introduced in Python 2.0. The following function
47575 is copied out of Python/modsupport.c in python version 2.3.4 */
47576 static int
47577 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
47578 {
47579 PyObject *dict;
47580 if (!PyModule_Check(m)) {
47581 PyErr_SetString(PyExc_TypeError,
47582 "PyModule_AddObject() needs module as first arg");
47583 return -1;
47584 }
47585 if (!o) {
47586 PyErr_SetString(PyExc_TypeError,
47587 "PyModule_AddObject() needs non-NULL value");
47588 return -1;
47589 }
47590
47591 dict = PyModule_GetDict(m);
47592 if (dict == NULL) {
47593 /* Internal error -- modules must have a dict! */
47594 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
47595 PyModule_GetName(m));
47596 return -1;
47597 }
47598 if (PyDict_SetItemString(dict, name, o))
47599 return -1;
47600 Py_DECREF(o);
47601 return 0;
47602 }
47603 #endif
47604
47605 static swig_type_info **
47606 SWIG_Python_SetTypeListHandle(swig_type_info **type_list_handle) {
47607 static PyMethodDef swig_empty_runtime_method_table[] = {
47608 {
47609 NULL, NULL, 0, NULL
47610 }
47611 };/* Sentinel */
47612
47613 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
47614 swig_empty_runtime_method_table);
47615 PyObject *pointer = PyCObject_FromVoidPtr((void *) type_list_handle, NULL);
47616 if (pointer && module) {
47617 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
47618 }
47619 return type_list_handle;
47620 }
47621
47622 static swig_type_info **
47623 SWIG_Python_LookupTypePointer(swig_type_info **type_list_handle) {
47624 swig_type_info **type_pointer;
47625
47626 /* first check if module already created */
47627 type_pointer = SWIG_Python_GetTypeListHandle();
47628 if (type_pointer) {
47629 return type_pointer;
47630 } else {
47631 /* create a new module and variable */
47632 return SWIG_Python_SetTypeListHandle(type_list_handle);
47633 }
47634 }
47635
47636 #ifdef __cplusplus
47637 }
47638 #endif
47639
47640 /* -----------------------------------------------------------------------------*
47641 * Partial Init method
47642 * -----------------------------------------------------------------------------*/
47643
47644 #ifdef SWIG_LINK_RUNTIME
47645 #ifdef __cplusplus
47646 extern "C"
47647 #endif
47648 SWIGEXPORT(void *) SWIG_ReturnGlobalTypeList(void *);
47649 #endif
47650
47651 #ifdef __cplusplus
47652 extern "C"
47653 #endif
47654 SWIGEXPORT(void) SWIG_init(void) {
47655 static PyObject *SWIG_globals = 0;
47656 static int typeinit = 0;
47657 PyObject *m, *d;
47658 int i;
47659 if (!SWIG_globals) SWIG_globals = SWIG_newvarlink();
47660
47661 /* Fix SwigMethods to carry the callback ptrs when needed */
47662 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_types_initial);
47663
47664 m = Py_InitModule((char *) SWIG_name, SwigMethods);
47665 d = PyModule_GetDict(m);
47666
47667 if (!typeinit) {
47668 #ifdef SWIG_LINK_RUNTIME
47669 swig_type_list_handle = (swig_type_info **) SWIG_ReturnGlobalTypeList(swig_type_list_handle);
47670 #else
47671 # ifndef SWIG_STATIC_RUNTIME
47672 swig_type_list_handle = SWIG_Python_LookupTypePointer(swig_type_list_handle);
47673 # endif
47674 #endif
47675 for (i = 0; swig_types_initial[i]; i++) {
47676 swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
47677 }
47678 typeinit = 1;
47679 }
47680 SWIG_InstallConstants(d,swig_const_table);
47681
47682
47683 #ifndef wxPyUSE_EXPORT
47684 // Make our API structure a CObject so other modules can import it
47685 // from this module.
47686 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
47687 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
47688 Py_XDECREF(cobj);
47689 #endif
47690
47691 {
47692 PyDict_SetItemString(d,"NOT_FOUND", SWIG_From_int((int)(wxNOT_FOUND)));
47693 }
47694 {
47695 PyDict_SetItemString(d,"VSCROLL", SWIG_From_int((int)(wxVSCROLL)));
47696 }
47697 {
47698 PyDict_SetItemString(d,"HSCROLL", SWIG_From_int((int)(wxHSCROLL)));
47699 }
47700 {
47701 PyDict_SetItemString(d,"CAPTION", SWIG_From_int((int)(wxCAPTION)));
47702 }
47703 {
47704 PyDict_SetItemString(d,"DOUBLE_BORDER", SWIG_From_int((int)(wxDOUBLE_BORDER)));
47705 }
47706 {
47707 PyDict_SetItemString(d,"SUNKEN_BORDER", SWIG_From_int((int)(wxSUNKEN_BORDER)));
47708 }
47709 {
47710 PyDict_SetItemString(d,"RAISED_BORDER", SWIG_From_int((int)(wxRAISED_BORDER)));
47711 }
47712 {
47713 PyDict_SetItemString(d,"BORDER", SWIG_From_int((int)(wxBORDER)));
47714 }
47715 {
47716 PyDict_SetItemString(d,"SIMPLE_BORDER", SWIG_From_int((int)(wxSIMPLE_BORDER)));
47717 }
47718 {
47719 PyDict_SetItemString(d,"STATIC_BORDER", SWIG_From_int((int)(wxSTATIC_BORDER)));
47720 }
47721 {
47722 PyDict_SetItemString(d,"TRANSPARENT_WINDOW", SWIG_From_int((int)(wxTRANSPARENT_WINDOW)));
47723 }
47724 {
47725 PyDict_SetItemString(d,"NO_BORDER", SWIG_From_int((int)(wxNO_BORDER)));
47726 }
47727 {
47728 PyDict_SetItemString(d,"DEFAULT_CONTROL_BORDER", SWIG_From_int((int)(wxDEFAULT_CONTROL_BORDER)));
47729 }
47730 {
47731 PyDict_SetItemString(d,"TAB_TRAVERSAL", SWIG_From_int((int)(wxTAB_TRAVERSAL)));
47732 }
47733 {
47734 PyDict_SetItemString(d,"WANTS_CHARS", SWIG_From_int((int)(wxWANTS_CHARS)));
47735 }
47736 {
47737 PyDict_SetItemString(d,"POPUP_WINDOW", SWIG_From_int((int)(wxPOPUP_WINDOW)));
47738 }
47739 {
47740 PyDict_SetItemString(d,"CENTER_FRAME", SWIG_From_int((int)(wxCENTER_FRAME)));
47741 }
47742 {
47743 PyDict_SetItemString(d,"CENTRE_ON_SCREEN", SWIG_From_int((int)(wxCENTRE_ON_SCREEN)));
47744 }
47745 {
47746 PyDict_SetItemString(d,"CENTER_ON_SCREEN", SWIG_From_int((int)(wxCENTER_ON_SCREEN)));
47747 }
47748 {
47749 PyDict_SetItemString(d,"CLIP_CHILDREN", SWIG_From_int((int)(wxCLIP_CHILDREN)));
47750 }
47751 {
47752 PyDict_SetItemString(d,"CLIP_SIBLINGS", SWIG_From_int((int)(wxCLIP_SIBLINGS)));
47753 }
47754 {
47755 PyDict_SetItemString(d,"ALWAYS_SHOW_SB", SWIG_From_int((int)(wxALWAYS_SHOW_SB)));
47756 }
47757 {
47758 PyDict_SetItemString(d,"RETAINED", SWIG_From_int((int)(wxRETAINED)));
47759 }
47760 {
47761 PyDict_SetItemString(d,"BACKINGSTORE", SWIG_From_int((int)(wxBACKINGSTORE)));
47762 }
47763 {
47764 PyDict_SetItemString(d,"COLOURED", SWIG_From_int((int)(wxCOLOURED)));
47765 }
47766 {
47767 PyDict_SetItemString(d,"FIXED_LENGTH", SWIG_From_int((int)(wxFIXED_LENGTH)));
47768 }
47769 {
47770 PyDict_SetItemString(d,"LB_NEEDED_SB", SWIG_From_int((int)(wxLB_NEEDED_SB)));
47771 }
47772 {
47773 PyDict_SetItemString(d,"LB_ALWAYS_SB", SWIG_From_int((int)(wxLB_ALWAYS_SB)));
47774 }
47775 {
47776 PyDict_SetItemString(d,"LB_SORT", SWIG_From_int((int)(wxLB_SORT)));
47777 }
47778 {
47779 PyDict_SetItemString(d,"LB_SINGLE", SWIG_From_int((int)(wxLB_SINGLE)));
47780 }
47781 {
47782 PyDict_SetItemString(d,"LB_MULTIPLE", SWIG_From_int((int)(wxLB_MULTIPLE)));
47783 }
47784 {
47785 PyDict_SetItemString(d,"LB_EXTENDED", SWIG_From_int((int)(wxLB_EXTENDED)));
47786 }
47787 {
47788 PyDict_SetItemString(d,"LB_OWNERDRAW", SWIG_From_int((int)(wxLB_OWNERDRAW)));
47789 }
47790 {
47791 PyDict_SetItemString(d,"LB_HSCROLL", SWIG_From_int((int)(wxLB_HSCROLL)));
47792 }
47793 {
47794 PyDict_SetItemString(d,"PROCESS_ENTER", SWIG_From_int((int)(wxPROCESS_ENTER)));
47795 }
47796 {
47797 PyDict_SetItemString(d,"PASSWORD", SWIG_From_int((int)(wxPASSWORD)));
47798 }
47799 {
47800 PyDict_SetItemString(d,"CB_SIMPLE", SWIG_From_int((int)(wxCB_SIMPLE)));
47801 }
47802 {
47803 PyDict_SetItemString(d,"CB_DROPDOWN", SWIG_From_int((int)(wxCB_DROPDOWN)));
47804 }
47805 {
47806 PyDict_SetItemString(d,"CB_SORT", SWIG_From_int((int)(wxCB_SORT)));
47807 }
47808 {
47809 PyDict_SetItemString(d,"CB_READONLY", SWIG_From_int((int)(wxCB_READONLY)));
47810 }
47811 {
47812 PyDict_SetItemString(d,"RA_HORIZONTAL", SWIG_From_int((int)(wxRA_HORIZONTAL)));
47813 }
47814 {
47815 PyDict_SetItemString(d,"RA_VERTICAL", SWIG_From_int((int)(wxRA_VERTICAL)));
47816 }
47817 {
47818 PyDict_SetItemString(d,"RA_SPECIFY_ROWS", SWIG_From_int((int)(wxRA_SPECIFY_ROWS)));
47819 }
47820 {
47821 PyDict_SetItemString(d,"RA_SPECIFY_COLS", SWIG_From_int((int)(wxRA_SPECIFY_COLS)));
47822 }
47823 {
47824 PyDict_SetItemString(d,"RA_USE_CHECKBOX", SWIG_From_int((int)(wxRA_USE_CHECKBOX)));
47825 }
47826 {
47827 PyDict_SetItemString(d,"RB_GROUP", SWIG_From_int((int)(wxRB_GROUP)));
47828 }
47829 {
47830 PyDict_SetItemString(d,"RB_SINGLE", SWIG_From_int((int)(wxRB_SINGLE)));
47831 }
47832 {
47833 PyDict_SetItemString(d,"SB_HORIZONTAL", SWIG_From_int((int)(wxSB_HORIZONTAL)));
47834 }
47835 {
47836 PyDict_SetItemString(d,"SB_VERTICAL", SWIG_From_int((int)(wxSB_VERTICAL)));
47837 }
47838 {
47839 PyDict_SetItemString(d,"RB_USE_CHECKBOX", SWIG_From_int((int)(wxRB_USE_CHECKBOX)));
47840 }
47841 {
47842 PyDict_SetItemString(d,"ST_SIZEGRIP", SWIG_From_int((int)(wxST_SIZEGRIP)));
47843 }
47844 {
47845 PyDict_SetItemString(d,"ST_NO_AUTORESIZE", SWIG_From_int((int)(wxST_NO_AUTORESIZE)));
47846 }
47847 {
47848 PyDict_SetItemString(d,"FLOOD_SURFACE", SWIG_From_int((int)(wxFLOOD_SURFACE)));
47849 }
47850 {
47851 PyDict_SetItemString(d,"FLOOD_BORDER", SWIG_From_int((int)(wxFLOOD_BORDER)));
47852 }
47853 {
47854 PyDict_SetItemString(d,"ODDEVEN_RULE", SWIG_From_int((int)(wxODDEVEN_RULE)));
47855 }
47856 {
47857 PyDict_SetItemString(d,"WINDING_RULE", SWIG_From_int((int)(wxWINDING_RULE)));
47858 }
47859 {
47860 PyDict_SetItemString(d,"TOOL_TOP", SWIG_From_int((int)(wxTOOL_TOP)));
47861 }
47862 {
47863 PyDict_SetItemString(d,"TOOL_BOTTOM", SWIG_From_int((int)(wxTOOL_BOTTOM)));
47864 }
47865 {
47866 PyDict_SetItemString(d,"TOOL_LEFT", SWIG_From_int((int)(wxTOOL_LEFT)));
47867 }
47868 {
47869 PyDict_SetItemString(d,"TOOL_RIGHT", SWIG_From_int((int)(wxTOOL_RIGHT)));
47870 }
47871 {
47872 PyDict_SetItemString(d,"OK", SWIG_From_int((int)(wxOK)));
47873 }
47874 {
47875 PyDict_SetItemString(d,"YES_NO", SWIG_From_int((int)(wxYES_NO)));
47876 }
47877 {
47878 PyDict_SetItemString(d,"CANCEL", SWIG_From_int((int)(wxCANCEL)));
47879 }
47880 {
47881 PyDict_SetItemString(d,"YES", SWIG_From_int((int)(wxYES)));
47882 }
47883 {
47884 PyDict_SetItemString(d,"NO", SWIG_From_int((int)(wxNO)));
47885 }
47886 {
47887 PyDict_SetItemString(d,"NO_DEFAULT", SWIG_From_int((int)(wxNO_DEFAULT)));
47888 }
47889 {
47890 PyDict_SetItemString(d,"YES_DEFAULT", SWIG_From_int((int)(wxYES_DEFAULT)));
47891 }
47892 {
47893 PyDict_SetItemString(d,"ICON_EXCLAMATION", SWIG_From_int((int)(wxICON_EXCLAMATION)));
47894 }
47895 {
47896 PyDict_SetItemString(d,"ICON_HAND", SWIG_From_int((int)(wxICON_HAND)));
47897 }
47898 {
47899 PyDict_SetItemString(d,"ICON_QUESTION", SWIG_From_int((int)(wxICON_QUESTION)));
47900 }
47901 {
47902 PyDict_SetItemString(d,"ICON_INFORMATION", SWIG_From_int((int)(wxICON_INFORMATION)));
47903 }
47904 {
47905 PyDict_SetItemString(d,"ICON_STOP", SWIG_From_int((int)(wxICON_STOP)));
47906 }
47907 {
47908 PyDict_SetItemString(d,"ICON_ASTERISK", SWIG_From_int((int)(wxICON_ASTERISK)));
47909 }
47910 {
47911 PyDict_SetItemString(d,"ICON_MASK", SWIG_From_int((int)(wxICON_MASK)));
47912 }
47913 {
47914 PyDict_SetItemString(d,"ICON_WARNING", SWIG_From_int((int)(wxICON_WARNING)));
47915 }
47916 {
47917 PyDict_SetItemString(d,"ICON_ERROR", SWIG_From_int((int)(wxICON_ERROR)));
47918 }
47919 {
47920 PyDict_SetItemString(d,"FORWARD", SWIG_From_int((int)(wxFORWARD)));
47921 }
47922 {
47923 PyDict_SetItemString(d,"BACKWARD", SWIG_From_int((int)(wxBACKWARD)));
47924 }
47925 {
47926 PyDict_SetItemString(d,"RESET", SWIG_From_int((int)(wxRESET)));
47927 }
47928 {
47929 PyDict_SetItemString(d,"HELP", SWIG_From_int((int)(wxHELP)));
47930 }
47931 {
47932 PyDict_SetItemString(d,"MORE", SWIG_From_int((int)(wxMORE)));
47933 }
47934 {
47935 PyDict_SetItemString(d,"SETUP", SWIG_From_int((int)(wxSETUP)));
47936 }
47937 {
47938 PyDict_SetItemString(d,"SIZE_AUTO_WIDTH", SWIG_From_int((int)(wxSIZE_AUTO_WIDTH)));
47939 }
47940 {
47941 PyDict_SetItemString(d,"SIZE_AUTO_HEIGHT", SWIG_From_int((int)(wxSIZE_AUTO_HEIGHT)));
47942 }
47943 {
47944 PyDict_SetItemString(d,"SIZE_AUTO", SWIG_From_int((int)(wxSIZE_AUTO)));
47945 }
47946 {
47947 PyDict_SetItemString(d,"SIZE_USE_EXISTING", SWIG_From_int((int)(wxSIZE_USE_EXISTING)));
47948 }
47949 {
47950 PyDict_SetItemString(d,"SIZE_ALLOW_MINUS_ONE", SWIG_From_int((int)(wxSIZE_ALLOW_MINUS_ONE)));
47951 }
47952 {
47953 PyDict_SetItemString(d,"PORTRAIT", SWIG_From_int((int)(wxPORTRAIT)));
47954 }
47955 {
47956 PyDict_SetItemString(d,"LANDSCAPE", SWIG_From_int((int)(wxLANDSCAPE)));
47957 }
47958 {
47959 PyDict_SetItemString(d,"PRINT_QUALITY_HIGH", SWIG_From_int((int)(wxPRINT_QUALITY_HIGH)));
47960 }
47961 {
47962 PyDict_SetItemString(d,"PRINT_QUALITY_MEDIUM", SWIG_From_int((int)(wxPRINT_QUALITY_MEDIUM)));
47963 }
47964 {
47965 PyDict_SetItemString(d,"PRINT_QUALITY_LOW", SWIG_From_int((int)(wxPRINT_QUALITY_LOW)));
47966 }
47967 {
47968 PyDict_SetItemString(d,"PRINT_QUALITY_DRAFT", SWIG_From_int((int)(wxPRINT_QUALITY_DRAFT)));
47969 }
47970 {
47971 PyDict_SetItemString(d,"ID_ANY", SWIG_From_int((int)(wxID_ANY)));
47972 }
47973 {
47974 PyDict_SetItemString(d,"ID_SEPARATOR", SWIG_From_int((int)(wxID_SEPARATOR)));
47975 }
47976 {
47977 PyDict_SetItemString(d,"ID_LOWEST", SWIG_From_int((int)(wxID_LOWEST)));
47978 }
47979 {
47980 PyDict_SetItemString(d,"ID_OPEN", SWIG_From_int((int)(wxID_OPEN)));
47981 }
47982 {
47983 PyDict_SetItemString(d,"ID_CLOSE", SWIG_From_int((int)(wxID_CLOSE)));
47984 }
47985 {
47986 PyDict_SetItemString(d,"ID_NEW", SWIG_From_int((int)(wxID_NEW)));
47987 }
47988 {
47989 PyDict_SetItemString(d,"ID_SAVE", SWIG_From_int((int)(wxID_SAVE)));
47990 }
47991 {
47992 PyDict_SetItemString(d,"ID_SAVEAS", SWIG_From_int((int)(wxID_SAVEAS)));
47993 }
47994 {
47995 PyDict_SetItemString(d,"ID_REVERT", SWIG_From_int((int)(wxID_REVERT)));
47996 }
47997 {
47998 PyDict_SetItemString(d,"ID_EXIT", SWIG_From_int((int)(wxID_EXIT)));
47999 }
48000 {
48001 PyDict_SetItemString(d,"ID_UNDO", SWIG_From_int((int)(wxID_UNDO)));
48002 }
48003 {
48004 PyDict_SetItemString(d,"ID_REDO", SWIG_From_int((int)(wxID_REDO)));
48005 }
48006 {
48007 PyDict_SetItemString(d,"ID_HELP", SWIG_From_int((int)(wxID_HELP)));
48008 }
48009 {
48010 PyDict_SetItemString(d,"ID_PRINT", SWIG_From_int((int)(wxID_PRINT)));
48011 }
48012 {
48013 PyDict_SetItemString(d,"ID_PRINT_SETUP", SWIG_From_int((int)(wxID_PRINT_SETUP)));
48014 }
48015 {
48016 PyDict_SetItemString(d,"ID_PREVIEW", SWIG_From_int((int)(wxID_PREVIEW)));
48017 }
48018 {
48019 PyDict_SetItemString(d,"ID_ABOUT", SWIG_From_int((int)(wxID_ABOUT)));
48020 }
48021 {
48022 PyDict_SetItemString(d,"ID_HELP_CONTENTS", SWIG_From_int((int)(wxID_HELP_CONTENTS)));
48023 }
48024 {
48025 PyDict_SetItemString(d,"ID_HELP_COMMANDS", SWIG_From_int((int)(wxID_HELP_COMMANDS)));
48026 }
48027 {
48028 PyDict_SetItemString(d,"ID_HELP_PROCEDURES", SWIG_From_int((int)(wxID_HELP_PROCEDURES)));
48029 }
48030 {
48031 PyDict_SetItemString(d,"ID_HELP_CONTEXT", SWIG_From_int((int)(wxID_HELP_CONTEXT)));
48032 }
48033 {
48034 PyDict_SetItemString(d,"ID_CLOSE_ALL", SWIG_From_int((int)(wxID_CLOSE_ALL)));
48035 }
48036 {
48037 PyDict_SetItemString(d,"ID_PREFERENCES", SWIG_From_int((int)(wxID_PREFERENCES)));
48038 }
48039 {
48040 PyDict_SetItemString(d,"ID_CUT", SWIG_From_int((int)(wxID_CUT)));
48041 }
48042 {
48043 PyDict_SetItemString(d,"ID_COPY", SWIG_From_int((int)(wxID_COPY)));
48044 }
48045 {
48046 PyDict_SetItemString(d,"ID_PASTE", SWIG_From_int((int)(wxID_PASTE)));
48047 }
48048 {
48049 PyDict_SetItemString(d,"ID_CLEAR", SWIG_From_int((int)(wxID_CLEAR)));
48050 }
48051 {
48052 PyDict_SetItemString(d,"ID_FIND", SWIG_From_int((int)(wxID_FIND)));
48053 }
48054 {
48055 PyDict_SetItemString(d,"ID_DUPLICATE", SWIG_From_int((int)(wxID_DUPLICATE)));
48056 }
48057 {
48058 PyDict_SetItemString(d,"ID_SELECTALL", SWIG_From_int((int)(wxID_SELECTALL)));
48059 }
48060 {
48061 PyDict_SetItemString(d,"ID_DELETE", SWIG_From_int((int)(wxID_DELETE)));
48062 }
48063 {
48064 PyDict_SetItemString(d,"ID_REPLACE", SWIG_From_int((int)(wxID_REPLACE)));
48065 }
48066 {
48067 PyDict_SetItemString(d,"ID_REPLACE_ALL", SWIG_From_int((int)(wxID_REPLACE_ALL)));
48068 }
48069 {
48070 PyDict_SetItemString(d,"ID_PROPERTIES", SWIG_From_int((int)(wxID_PROPERTIES)));
48071 }
48072 {
48073 PyDict_SetItemString(d,"ID_VIEW_DETAILS", SWIG_From_int((int)(wxID_VIEW_DETAILS)));
48074 }
48075 {
48076 PyDict_SetItemString(d,"ID_VIEW_LARGEICONS", SWIG_From_int((int)(wxID_VIEW_LARGEICONS)));
48077 }
48078 {
48079 PyDict_SetItemString(d,"ID_VIEW_SMALLICONS", SWIG_From_int((int)(wxID_VIEW_SMALLICONS)));
48080 }
48081 {
48082 PyDict_SetItemString(d,"ID_VIEW_LIST", SWIG_From_int((int)(wxID_VIEW_LIST)));
48083 }
48084 {
48085 PyDict_SetItemString(d,"ID_VIEW_SORTDATE", SWIG_From_int((int)(wxID_VIEW_SORTDATE)));
48086 }
48087 {
48088 PyDict_SetItemString(d,"ID_VIEW_SORTNAME", SWIG_From_int((int)(wxID_VIEW_SORTNAME)));
48089 }
48090 {
48091 PyDict_SetItemString(d,"ID_VIEW_SORTSIZE", SWIG_From_int((int)(wxID_VIEW_SORTSIZE)));
48092 }
48093 {
48094 PyDict_SetItemString(d,"ID_VIEW_SORTTYPE", SWIG_From_int((int)(wxID_VIEW_SORTTYPE)));
48095 }
48096 {
48097 PyDict_SetItemString(d,"ID_FILE1", SWIG_From_int((int)(wxID_FILE1)));
48098 }
48099 {
48100 PyDict_SetItemString(d,"ID_FILE2", SWIG_From_int((int)(wxID_FILE2)));
48101 }
48102 {
48103 PyDict_SetItemString(d,"ID_FILE3", SWIG_From_int((int)(wxID_FILE3)));
48104 }
48105 {
48106 PyDict_SetItemString(d,"ID_FILE4", SWIG_From_int((int)(wxID_FILE4)));
48107 }
48108 {
48109 PyDict_SetItemString(d,"ID_FILE5", SWIG_From_int((int)(wxID_FILE5)));
48110 }
48111 {
48112 PyDict_SetItemString(d,"ID_FILE6", SWIG_From_int((int)(wxID_FILE6)));
48113 }
48114 {
48115 PyDict_SetItemString(d,"ID_FILE7", SWIG_From_int((int)(wxID_FILE7)));
48116 }
48117 {
48118 PyDict_SetItemString(d,"ID_FILE8", SWIG_From_int((int)(wxID_FILE8)));
48119 }
48120 {
48121 PyDict_SetItemString(d,"ID_FILE9", SWIG_From_int((int)(wxID_FILE9)));
48122 }
48123 {
48124 PyDict_SetItemString(d,"ID_OK", SWIG_From_int((int)(wxID_OK)));
48125 }
48126 {
48127 PyDict_SetItemString(d,"ID_CANCEL", SWIG_From_int((int)(wxID_CANCEL)));
48128 }
48129 {
48130 PyDict_SetItemString(d,"ID_APPLY", SWIG_From_int((int)(wxID_APPLY)));
48131 }
48132 {
48133 PyDict_SetItemString(d,"ID_YES", SWIG_From_int((int)(wxID_YES)));
48134 }
48135 {
48136 PyDict_SetItemString(d,"ID_NO", SWIG_From_int((int)(wxID_NO)));
48137 }
48138 {
48139 PyDict_SetItemString(d,"ID_STATIC", SWIG_From_int((int)(wxID_STATIC)));
48140 }
48141 {
48142 PyDict_SetItemString(d,"ID_FORWARD", SWIG_From_int((int)(wxID_FORWARD)));
48143 }
48144 {
48145 PyDict_SetItemString(d,"ID_BACKWARD", SWIG_From_int((int)(wxID_BACKWARD)));
48146 }
48147 {
48148 PyDict_SetItemString(d,"ID_DEFAULT", SWIG_From_int((int)(wxID_DEFAULT)));
48149 }
48150 {
48151 PyDict_SetItemString(d,"ID_MORE", SWIG_From_int((int)(wxID_MORE)));
48152 }
48153 {
48154 PyDict_SetItemString(d,"ID_SETUP", SWIG_From_int((int)(wxID_SETUP)));
48155 }
48156 {
48157 PyDict_SetItemString(d,"ID_RESET", SWIG_From_int((int)(wxID_RESET)));
48158 }
48159 {
48160 PyDict_SetItemString(d,"ID_CONTEXT_HELP", SWIG_From_int((int)(wxID_CONTEXT_HELP)));
48161 }
48162 {
48163 PyDict_SetItemString(d,"ID_YESTOALL", SWIG_From_int((int)(wxID_YESTOALL)));
48164 }
48165 {
48166 PyDict_SetItemString(d,"ID_NOTOALL", SWIG_From_int((int)(wxID_NOTOALL)));
48167 }
48168 {
48169 PyDict_SetItemString(d,"ID_ABORT", SWIG_From_int((int)(wxID_ABORT)));
48170 }
48171 {
48172 PyDict_SetItemString(d,"ID_RETRY", SWIG_From_int((int)(wxID_RETRY)));
48173 }
48174 {
48175 PyDict_SetItemString(d,"ID_IGNORE", SWIG_From_int((int)(wxID_IGNORE)));
48176 }
48177 {
48178 PyDict_SetItemString(d,"ID_ADD", SWIG_From_int((int)(wxID_ADD)));
48179 }
48180 {
48181 PyDict_SetItemString(d,"ID_REMOVE", SWIG_From_int((int)(wxID_REMOVE)));
48182 }
48183 {
48184 PyDict_SetItemString(d,"ID_UP", SWIG_From_int((int)(wxID_UP)));
48185 }
48186 {
48187 PyDict_SetItemString(d,"ID_DOWN", SWIG_From_int((int)(wxID_DOWN)));
48188 }
48189 {
48190 PyDict_SetItemString(d,"ID_HOME", SWIG_From_int((int)(wxID_HOME)));
48191 }
48192 {
48193 PyDict_SetItemString(d,"ID_REFRESH", SWIG_From_int((int)(wxID_REFRESH)));
48194 }
48195 {
48196 PyDict_SetItemString(d,"ID_STOP", SWIG_From_int((int)(wxID_STOP)));
48197 }
48198 {
48199 PyDict_SetItemString(d,"ID_INDEX", SWIG_From_int((int)(wxID_INDEX)));
48200 }
48201 {
48202 PyDict_SetItemString(d,"ID_BOLD", SWIG_From_int((int)(wxID_BOLD)));
48203 }
48204 {
48205 PyDict_SetItemString(d,"ID_ITALIC", SWIG_From_int((int)(wxID_ITALIC)));
48206 }
48207 {
48208 PyDict_SetItemString(d,"ID_JUSTIFY_CENTER", SWIG_From_int((int)(wxID_JUSTIFY_CENTER)));
48209 }
48210 {
48211 PyDict_SetItemString(d,"ID_JUSTIFY_FILL", SWIG_From_int((int)(wxID_JUSTIFY_FILL)));
48212 }
48213 {
48214 PyDict_SetItemString(d,"ID_JUSTIFY_RIGHT", SWIG_From_int((int)(wxID_JUSTIFY_RIGHT)));
48215 }
48216 {
48217 PyDict_SetItemString(d,"ID_JUSTIFY_LEFT", SWIG_From_int((int)(wxID_JUSTIFY_LEFT)));
48218 }
48219 {
48220 PyDict_SetItemString(d,"ID_UNDERLINE", SWIG_From_int((int)(wxID_UNDERLINE)));
48221 }
48222 {
48223 PyDict_SetItemString(d,"ID_INDENT", SWIG_From_int((int)(wxID_INDENT)));
48224 }
48225 {
48226 PyDict_SetItemString(d,"ID_UNINDENT", SWIG_From_int((int)(wxID_UNINDENT)));
48227 }
48228 {
48229 PyDict_SetItemString(d,"ID_ZOOM_100", SWIG_From_int((int)(wxID_ZOOM_100)));
48230 }
48231 {
48232 PyDict_SetItemString(d,"ID_ZOOM_FIT", SWIG_From_int((int)(wxID_ZOOM_FIT)));
48233 }
48234 {
48235 PyDict_SetItemString(d,"ID_ZOOM_IN", SWIG_From_int((int)(wxID_ZOOM_IN)));
48236 }
48237 {
48238 PyDict_SetItemString(d,"ID_ZOOM_OUT", SWIG_From_int((int)(wxID_ZOOM_OUT)));
48239 }
48240 {
48241 PyDict_SetItemString(d,"ID_UNDELETE", SWIG_From_int((int)(wxID_UNDELETE)));
48242 }
48243 {
48244 PyDict_SetItemString(d,"ID_REVERT_TO_SAVED", SWIG_From_int((int)(wxID_REVERT_TO_SAVED)));
48245 }
48246 {
48247 PyDict_SetItemString(d,"ID_HIGHEST", SWIG_From_int((int)(wxID_HIGHEST)));
48248 }
48249 {
48250 PyDict_SetItemString(d,"OPEN", SWIG_From_int((int)(wxOPEN)));
48251 }
48252 {
48253 PyDict_SetItemString(d,"SAVE", SWIG_From_int((int)(wxSAVE)));
48254 }
48255 {
48256 PyDict_SetItemString(d,"HIDE_READONLY", SWIG_From_int((int)(wxHIDE_READONLY)));
48257 }
48258 {
48259 PyDict_SetItemString(d,"OVERWRITE_PROMPT", SWIG_From_int((int)(wxOVERWRITE_PROMPT)));
48260 }
48261 {
48262 PyDict_SetItemString(d,"FILE_MUST_EXIST", SWIG_From_int((int)(wxFILE_MUST_EXIST)));
48263 }
48264 {
48265 PyDict_SetItemString(d,"MULTIPLE", SWIG_From_int((int)(wxMULTIPLE)));
48266 }
48267 {
48268 PyDict_SetItemString(d,"CHANGE_DIR", SWIG_From_int((int)(wxCHANGE_DIR)));
48269 }
48270 {
48271 PyDict_SetItemString(d,"ACCEL_ALT", SWIG_From_int((int)(wxACCEL_ALT)));
48272 }
48273 {
48274 PyDict_SetItemString(d,"ACCEL_CTRL", SWIG_From_int((int)(wxACCEL_CTRL)));
48275 }
48276 {
48277 PyDict_SetItemString(d,"ACCEL_SHIFT", SWIG_From_int((int)(wxACCEL_SHIFT)));
48278 }
48279 {
48280 PyDict_SetItemString(d,"ACCEL_NORMAL", SWIG_From_int((int)(wxACCEL_NORMAL)));
48281 }
48282 {
48283 PyDict_SetItemString(d,"PD_AUTO_HIDE", SWIG_From_int((int)(wxPD_AUTO_HIDE)));
48284 }
48285 {
48286 PyDict_SetItemString(d,"PD_APP_MODAL", SWIG_From_int((int)(wxPD_APP_MODAL)));
48287 }
48288 {
48289 PyDict_SetItemString(d,"PD_CAN_ABORT", SWIG_From_int((int)(wxPD_CAN_ABORT)));
48290 }
48291 {
48292 PyDict_SetItemString(d,"PD_ELAPSED_TIME", SWIG_From_int((int)(wxPD_ELAPSED_TIME)));
48293 }
48294 {
48295 PyDict_SetItemString(d,"PD_ESTIMATED_TIME", SWIG_From_int((int)(wxPD_ESTIMATED_TIME)));
48296 }
48297 {
48298 PyDict_SetItemString(d,"PD_REMAINING_TIME", SWIG_From_int((int)(wxPD_REMAINING_TIME)));
48299 }
48300 {
48301 PyDict_SetItemString(d,"PD_SMOOTH", SWIG_From_int((int)(wxPD_SMOOTH)));
48302 }
48303 {
48304 PyDict_SetItemString(d,"PD_CAN_SKIP", SWIG_From_int((int)(wxPD_CAN_SKIP)));
48305 }
48306 {
48307 PyDict_SetItemString(d,"DD_NEW_DIR_BUTTON", SWIG_From_int((int)(wxDD_NEW_DIR_BUTTON)));
48308 }
48309 {
48310 PyDict_SetItemString(d,"DD_DEFAULT_STYLE", SWIG_From_int((int)(wxDD_DEFAULT_STYLE)));
48311 }
48312 {
48313 PyDict_SetItemString(d,"MENU_TEAROFF", SWIG_From_int((int)(wxMENU_TEAROFF)));
48314 }
48315 {
48316 PyDict_SetItemString(d,"MB_DOCKABLE", SWIG_From_int((int)(wxMB_DOCKABLE)));
48317 }
48318 {
48319 PyDict_SetItemString(d,"NO_FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxNO_FULL_REPAINT_ON_RESIZE)));
48320 }
48321 {
48322 PyDict_SetItemString(d,"FULL_REPAINT_ON_RESIZE", SWIG_From_int((int)(wxFULL_REPAINT_ON_RESIZE)));
48323 }
48324 {
48325 PyDict_SetItemString(d,"LI_HORIZONTAL", SWIG_From_int((int)(wxLI_HORIZONTAL)));
48326 }
48327 {
48328 PyDict_SetItemString(d,"LI_VERTICAL", SWIG_From_int((int)(wxLI_VERTICAL)));
48329 }
48330 {
48331 PyDict_SetItemString(d,"WS_EX_VALIDATE_RECURSIVELY", SWIG_From_int((int)(wxWS_EX_VALIDATE_RECURSIVELY)));
48332 }
48333 {
48334 PyDict_SetItemString(d,"WS_EX_BLOCK_EVENTS", SWIG_From_int((int)(wxWS_EX_BLOCK_EVENTS)));
48335 }
48336 {
48337 PyDict_SetItemString(d,"WS_EX_TRANSIENT", SWIG_From_int((int)(wxWS_EX_TRANSIENT)));
48338 }
48339 {
48340 PyDict_SetItemString(d,"WS_EX_THEMED_BACKGROUND", SWIG_From_int((int)(wxWS_EX_THEMED_BACKGROUND)));
48341 }
48342 {
48343 PyDict_SetItemString(d,"WS_EX_PROCESS_IDLE", SWIG_From_int((int)(wxWS_EX_PROCESS_IDLE)));
48344 }
48345 {
48346 PyDict_SetItemString(d,"WS_EX_PROCESS_UI_UPDATES", SWIG_From_int((int)(wxWS_EX_PROCESS_UI_UPDATES)));
48347 }
48348 {
48349 PyDict_SetItemString(d,"MM_TEXT", SWIG_From_int((int)(wxMM_TEXT)));
48350 }
48351 {
48352 PyDict_SetItemString(d,"MM_LOMETRIC", SWIG_From_int((int)(wxMM_LOMETRIC)));
48353 }
48354 {
48355 PyDict_SetItemString(d,"MM_HIMETRIC", SWIG_From_int((int)(wxMM_HIMETRIC)));
48356 }
48357 {
48358 PyDict_SetItemString(d,"MM_LOENGLISH", SWIG_From_int((int)(wxMM_LOENGLISH)));
48359 }
48360 {
48361 PyDict_SetItemString(d,"MM_HIENGLISH", SWIG_From_int((int)(wxMM_HIENGLISH)));
48362 }
48363 {
48364 PyDict_SetItemString(d,"MM_TWIPS", SWIG_From_int((int)(wxMM_TWIPS)));
48365 }
48366 {
48367 PyDict_SetItemString(d,"MM_ISOTROPIC", SWIG_From_int((int)(wxMM_ISOTROPIC)));
48368 }
48369 {
48370 PyDict_SetItemString(d,"MM_ANISOTROPIC", SWIG_From_int((int)(wxMM_ANISOTROPIC)));
48371 }
48372 {
48373 PyDict_SetItemString(d,"MM_POINTS", SWIG_From_int((int)(wxMM_POINTS)));
48374 }
48375 {
48376 PyDict_SetItemString(d,"MM_METRIC", SWIG_From_int((int)(wxMM_METRIC)));
48377 }
48378 {
48379 PyDict_SetItemString(d,"CENTRE", SWIG_From_int((int)(wxCENTRE)));
48380 }
48381 {
48382 PyDict_SetItemString(d,"CENTER", SWIG_From_int((int)(wxCENTER)));
48383 }
48384 {
48385 PyDict_SetItemString(d,"HORIZONTAL", SWIG_From_int((int)(wxHORIZONTAL)));
48386 }
48387 {
48388 PyDict_SetItemString(d,"VERTICAL", SWIG_From_int((int)(wxVERTICAL)));
48389 }
48390 {
48391 PyDict_SetItemString(d,"BOTH", SWIG_From_int((int)(wxBOTH)));
48392 }
48393 {
48394 PyDict_SetItemString(d,"LEFT", SWIG_From_int((int)(wxLEFT)));
48395 }
48396 {
48397 PyDict_SetItemString(d,"RIGHT", SWIG_From_int((int)(wxRIGHT)));
48398 }
48399 {
48400 PyDict_SetItemString(d,"UP", SWIG_From_int((int)(wxUP)));
48401 }
48402 {
48403 PyDict_SetItemString(d,"DOWN", SWIG_From_int((int)(wxDOWN)));
48404 }
48405 {
48406 PyDict_SetItemString(d,"TOP", SWIG_From_int((int)(wxTOP)));
48407 }
48408 {
48409 PyDict_SetItemString(d,"BOTTOM", SWIG_From_int((int)(wxBOTTOM)));
48410 }
48411 {
48412 PyDict_SetItemString(d,"NORTH", SWIG_From_int((int)(wxNORTH)));
48413 }
48414 {
48415 PyDict_SetItemString(d,"SOUTH", SWIG_From_int((int)(wxSOUTH)));
48416 }
48417 {
48418 PyDict_SetItemString(d,"WEST", SWIG_From_int((int)(wxWEST)));
48419 }
48420 {
48421 PyDict_SetItemString(d,"EAST", SWIG_From_int((int)(wxEAST)));
48422 }
48423 {
48424 PyDict_SetItemString(d,"ALL", SWIG_From_int((int)(wxALL)));
48425 }
48426 {
48427 PyDict_SetItemString(d,"ALIGN_NOT", SWIG_From_int((int)(wxALIGN_NOT)));
48428 }
48429 {
48430 PyDict_SetItemString(d,"ALIGN_CENTER_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTER_HORIZONTAL)));
48431 }
48432 {
48433 PyDict_SetItemString(d,"ALIGN_CENTRE_HORIZONTAL", SWIG_From_int((int)(wxALIGN_CENTRE_HORIZONTAL)));
48434 }
48435 {
48436 PyDict_SetItemString(d,"ALIGN_LEFT", SWIG_From_int((int)(wxALIGN_LEFT)));
48437 }
48438 {
48439 PyDict_SetItemString(d,"ALIGN_TOP", SWIG_From_int((int)(wxALIGN_TOP)));
48440 }
48441 {
48442 PyDict_SetItemString(d,"ALIGN_RIGHT", SWIG_From_int((int)(wxALIGN_RIGHT)));
48443 }
48444 {
48445 PyDict_SetItemString(d,"ALIGN_BOTTOM", SWIG_From_int((int)(wxALIGN_BOTTOM)));
48446 }
48447 {
48448 PyDict_SetItemString(d,"ALIGN_CENTER_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTER_VERTICAL)));
48449 }
48450 {
48451 PyDict_SetItemString(d,"ALIGN_CENTRE_VERTICAL", SWIG_From_int((int)(wxALIGN_CENTRE_VERTICAL)));
48452 }
48453 {
48454 PyDict_SetItemString(d,"ALIGN_CENTER", SWIG_From_int((int)(wxALIGN_CENTER)));
48455 }
48456 {
48457 PyDict_SetItemString(d,"ALIGN_CENTRE", SWIG_From_int((int)(wxALIGN_CENTRE)));
48458 }
48459 {
48460 PyDict_SetItemString(d,"ALIGN_MASK", SWIG_From_int((int)(wxALIGN_MASK)));
48461 }
48462 {
48463 PyDict_SetItemString(d,"STRETCH_NOT", SWIG_From_int((int)(wxSTRETCH_NOT)));
48464 }
48465 {
48466 PyDict_SetItemString(d,"SHRINK", SWIG_From_int((int)(wxSHRINK)));
48467 }
48468 {
48469 PyDict_SetItemString(d,"GROW", SWIG_From_int((int)(wxGROW)));
48470 }
48471 {
48472 PyDict_SetItemString(d,"EXPAND", SWIG_From_int((int)(wxEXPAND)));
48473 }
48474 {
48475 PyDict_SetItemString(d,"SHAPED", SWIG_From_int((int)(wxSHAPED)));
48476 }
48477 {
48478 PyDict_SetItemString(d,"FIXED_MINSIZE", SWIG_From_int((int)(wxFIXED_MINSIZE)));
48479 }
48480 {
48481 PyDict_SetItemString(d,"TILE", SWIG_From_int((int)(wxTILE)));
48482 }
48483 {
48484 PyDict_SetItemString(d,"ADJUST_MINSIZE", SWIG_From_int((int)(wxADJUST_MINSIZE)));
48485 }
48486 {
48487 PyDict_SetItemString(d,"BORDER_DEFAULT", SWIG_From_int((int)(wxBORDER_DEFAULT)));
48488 }
48489 {
48490 PyDict_SetItemString(d,"BORDER_NONE", SWIG_From_int((int)(wxBORDER_NONE)));
48491 }
48492 {
48493 PyDict_SetItemString(d,"BORDER_STATIC", SWIG_From_int((int)(wxBORDER_STATIC)));
48494 }
48495 {
48496 PyDict_SetItemString(d,"BORDER_SIMPLE", SWIG_From_int((int)(wxBORDER_SIMPLE)));
48497 }
48498 {
48499 PyDict_SetItemString(d,"BORDER_RAISED", SWIG_From_int((int)(wxBORDER_RAISED)));
48500 }
48501 {
48502 PyDict_SetItemString(d,"BORDER_SUNKEN", SWIG_From_int((int)(wxBORDER_SUNKEN)));
48503 }
48504 {
48505 PyDict_SetItemString(d,"BORDER_DOUBLE", SWIG_From_int((int)(wxBORDER_DOUBLE)));
48506 }
48507 {
48508 PyDict_SetItemString(d,"BORDER_MASK", SWIG_From_int((int)(wxBORDER_MASK)));
48509 }
48510 {
48511 PyDict_SetItemString(d,"BG_STYLE_SYSTEM", SWIG_From_int((int)(wxBG_STYLE_SYSTEM)));
48512 }
48513 {
48514 PyDict_SetItemString(d,"BG_STYLE_COLOUR", SWIG_From_int((int)(wxBG_STYLE_COLOUR)));
48515 }
48516 {
48517 PyDict_SetItemString(d,"BG_STYLE_CUSTOM", SWIG_From_int((int)(wxBG_STYLE_CUSTOM)));
48518 }
48519 {
48520 PyDict_SetItemString(d,"DEFAULT", SWIG_From_int((int)(wxDEFAULT)));
48521 }
48522 {
48523 PyDict_SetItemString(d,"DECORATIVE", SWIG_From_int((int)(wxDECORATIVE)));
48524 }
48525 {
48526 PyDict_SetItemString(d,"ROMAN", SWIG_From_int((int)(wxROMAN)));
48527 }
48528 {
48529 PyDict_SetItemString(d,"SCRIPT", SWIG_From_int((int)(wxSCRIPT)));
48530 }
48531 {
48532 PyDict_SetItemString(d,"SWISS", SWIG_From_int((int)(wxSWISS)));
48533 }
48534 {
48535 PyDict_SetItemString(d,"MODERN", SWIG_From_int((int)(wxMODERN)));
48536 }
48537 {
48538 PyDict_SetItemString(d,"TELETYPE", SWIG_From_int((int)(wxTELETYPE)));
48539 }
48540 {
48541 PyDict_SetItemString(d,"VARIABLE", SWIG_From_int((int)(wxVARIABLE)));
48542 }
48543 {
48544 PyDict_SetItemString(d,"FIXED", SWIG_From_int((int)(wxFIXED)));
48545 }
48546 {
48547 PyDict_SetItemString(d,"NORMAL", SWIG_From_int((int)(wxNORMAL)));
48548 }
48549 {
48550 PyDict_SetItemString(d,"LIGHT", SWIG_From_int((int)(wxLIGHT)));
48551 }
48552 {
48553 PyDict_SetItemString(d,"BOLD", SWIG_From_int((int)(wxBOLD)));
48554 }
48555 {
48556 PyDict_SetItemString(d,"ITALIC", SWIG_From_int((int)(wxITALIC)));
48557 }
48558 {
48559 PyDict_SetItemString(d,"SLANT", SWIG_From_int((int)(wxSLANT)));
48560 }
48561 {
48562 PyDict_SetItemString(d,"SOLID", SWIG_From_int((int)(wxSOLID)));
48563 }
48564 {
48565 PyDict_SetItemString(d,"DOT", SWIG_From_int((int)(wxDOT)));
48566 }
48567 {
48568 PyDict_SetItemString(d,"LONG_DASH", SWIG_From_int((int)(wxLONG_DASH)));
48569 }
48570 {
48571 PyDict_SetItemString(d,"SHORT_DASH", SWIG_From_int((int)(wxSHORT_DASH)));
48572 }
48573 {
48574 PyDict_SetItemString(d,"DOT_DASH", SWIG_From_int((int)(wxDOT_DASH)));
48575 }
48576 {
48577 PyDict_SetItemString(d,"USER_DASH", SWIG_From_int((int)(wxUSER_DASH)));
48578 }
48579 {
48580 PyDict_SetItemString(d,"TRANSPARENT", SWIG_From_int((int)(wxTRANSPARENT)));
48581 }
48582 {
48583 PyDict_SetItemString(d,"STIPPLE", SWIG_From_int((int)(wxSTIPPLE)));
48584 }
48585 {
48586 PyDict_SetItemString(d,"BDIAGONAL_HATCH", SWIG_From_int((int)(wxBDIAGONAL_HATCH)));
48587 }
48588 {
48589 PyDict_SetItemString(d,"CROSSDIAG_HATCH", SWIG_From_int((int)(wxCROSSDIAG_HATCH)));
48590 }
48591 {
48592 PyDict_SetItemString(d,"FDIAGONAL_HATCH", SWIG_From_int((int)(wxFDIAGONAL_HATCH)));
48593 }
48594 {
48595 PyDict_SetItemString(d,"CROSS_HATCH", SWIG_From_int((int)(wxCROSS_HATCH)));
48596 }
48597 {
48598 PyDict_SetItemString(d,"HORIZONTAL_HATCH", SWIG_From_int((int)(wxHORIZONTAL_HATCH)));
48599 }
48600 {
48601 PyDict_SetItemString(d,"VERTICAL_HATCH", SWIG_From_int((int)(wxVERTICAL_HATCH)));
48602 }
48603 {
48604 PyDict_SetItemString(d,"JOIN_BEVEL", SWIG_From_int((int)(wxJOIN_BEVEL)));
48605 }
48606 {
48607 PyDict_SetItemString(d,"JOIN_MITER", SWIG_From_int((int)(wxJOIN_MITER)));
48608 }
48609 {
48610 PyDict_SetItemString(d,"JOIN_ROUND", SWIG_From_int((int)(wxJOIN_ROUND)));
48611 }
48612 {
48613 PyDict_SetItemString(d,"CAP_ROUND", SWIG_From_int((int)(wxCAP_ROUND)));
48614 }
48615 {
48616 PyDict_SetItemString(d,"CAP_PROJECTING", SWIG_From_int((int)(wxCAP_PROJECTING)));
48617 }
48618 {
48619 PyDict_SetItemString(d,"CAP_BUTT", SWIG_From_int((int)(wxCAP_BUTT)));
48620 }
48621 {
48622 PyDict_SetItemString(d,"CLEAR", SWIG_From_int((int)(wxCLEAR)));
48623 }
48624 {
48625 PyDict_SetItemString(d,"XOR", SWIG_From_int((int)(wxXOR)));
48626 }
48627 {
48628 PyDict_SetItemString(d,"INVERT", SWIG_From_int((int)(wxINVERT)));
48629 }
48630 {
48631 PyDict_SetItemString(d,"OR_REVERSE", SWIG_From_int((int)(wxOR_REVERSE)));
48632 }
48633 {
48634 PyDict_SetItemString(d,"AND_REVERSE", SWIG_From_int((int)(wxAND_REVERSE)));
48635 }
48636 {
48637 PyDict_SetItemString(d,"COPY", SWIG_From_int((int)(wxCOPY)));
48638 }
48639 {
48640 PyDict_SetItemString(d,"AND", SWIG_From_int((int)(wxAND)));
48641 }
48642 {
48643 PyDict_SetItemString(d,"AND_INVERT", SWIG_From_int((int)(wxAND_INVERT)));
48644 }
48645 {
48646 PyDict_SetItemString(d,"NO_OP", SWIG_From_int((int)(wxNO_OP)));
48647 }
48648 {
48649 PyDict_SetItemString(d,"NOR", SWIG_From_int((int)(wxNOR)));
48650 }
48651 {
48652 PyDict_SetItemString(d,"EQUIV", SWIG_From_int((int)(wxEQUIV)));
48653 }
48654 {
48655 PyDict_SetItemString(d,"SRC_INVERT", SWIG_From_int((int)(wxSRC_INVERT)));
48656 }
48657 {
48658 PyDict_SetItemString(d,"OR_INVERT", SWIG_From_int((int)(wxOR_INVERT)));
48659 }
48660 {
48661 PyDict_SetItemString(d,"NAND", SWIG_From_int((int)(wxNAND)));
48662 }
48663 {
48664 PyDict_SetItemString(d,"OR", SWIG_From_int((int)(wxOR)));
48665 }
48666 {
48667 PyDict_SetItemString(d,"SET", SWIG_From_int((int)(wxSET)));
48668 }
48669 {
48670 PyDict_SetItemString(d,"WXK_BACK", SWIG_From_int((int)(WXK_BACK)));
48671 }
48672 {
48673 PyDict_SetItemString(d,"WXK_TAB", SWIG_From_int((int)(WXK_TAB)));
48674 }
48675 {
48676 PyDict_SetItemString(d,"WXK_RETURN", SWIG_From_int((int)(WXK_RETURN)));
48677 }
48678 {
48679 PyDict_SetItemString(d,"WXK_ESCAPE", SWIG_From_int((int)(WXK_ESCAPE)));
48680 }
48681 {
48682 PyDict_SetItemString(d,"WXK_SPACE", SWIG_From_int((int)(WXK_SPACE)));
48683 }
48684 {
48685 PyDict_SetItemString(d,"WXK_DELETE", SWIG_From_int((int)(WXK_DELETE)));
48686 }
48687 {
48688 PyDict_SetItemString(d,"WXK_START", SWIG_From_int((int)(WXK_START)));
48689 }
48690 {
48691 PyDict_SetItemString(d,"WXK_LBUTTON", SWIG_From_int((int)(WXK_LBUTTON)));
48692 }
48693 {
48694 PyDict_SetItemString(d,"WXK_RBUTTON", SWIG_From_int((int)(WXK_RBUTTON)));
48695 }
48696 {
48697 PyDict_SetItemString(d,"WXK_CANCEL", SWIG_From_int((int)(WXK_CANCEL)));
48698 }
48699 {
48700 PyDict_SetItemString(d,"WXK_MBUTTON", SWIG_From_int((int)(WXK_MBUTTON)));
48701 }
48702 {
48703 PyDict_SetItemString(d,"WXK_CLEAR", SWIG_From_int((int)(WXK_CLEAR)));
48704 }
48705 {
48706 PyDict_SetItemString(d,"WXK_SHIFT", SWIG_From_int((int)(WXK_SHIFT)));
48707 }
48708 {
48709 PyDict_SetItemString(d,"WXK_ALT", SWIG_From_int((int)(WXK_ALT)));
48710 }
48711 {
48712 PyDict_SetItemString(d,"WXK_CONTROL", SWIG_From_int((int)(WXK_CONTROL)));
48713 }
48714 {
48715 PyDict_SetItemString(d,"WXK_MENU", SWIG_From_int((int)(WXK_MENU)));
48716 }
48717 {
48718 PyDict_SetItemString(d,"WXK_PAUSE", SWIG_From_int((int)(WXK_PAUSE)));
48719 }
48720 {
48721 PyDict_SetItemString(d,"WXK_CAPITAL", SWIG_From_int((int)(WXK_CAPITAL)));
48722 }
48723 {
48724 PyDict_SetItemString(d,"WXK_PRIOR", SWIG_From_int((int)(WXK_PRIOR)));
48725 }
48726 {
48727 PyDict_SetItemString(d,"WXK_NEXT", SWIG_From_int((int)(WXK_NEXT)));
48728 }
48729 {
48730 PyDict_SetItemString(d,"WXK_END", SWIG_From_int((int)(WXK_END)));
48731 }
48732 {
48733 PyDict_SetItemString(d,"WXK_HOME", SWIG_From_int((int)(WXK_HOME)));
48734 }
48735 {
48736 PyDict_SetItemString(d,"WXK_LEFT", SWIG_From_int((int)(WXK_LEFT)));
48737 }
48738 {
48739 PyDict_SetItemString(d,"WXK_UP", SWIG_From_int((int)(WXK_UP)));
48740 }
48741 {
48742 PyDict_SetItemString(d,"WXK_RIGHT", SWIG_From_int((int)(WXK_RIGHT)));
48743 }
48744 {
48745 PyDict_SetItemString(d,"WXK_DOWN", SWIG_From_int((int)(WXK_DOWN)));
48746 }
48747 {
48748 PyDict_SetItemString(d,"WXK_SELECT", SWIG_From_int((int)(WXK_SELECT)));
48749 }
48750 {
48751 PyDict_SetItemString(d,"WXK_PRINT", SWIG_From_int((int)(WXK_PRINT)));
48752 }
48753 {
48754 PyDict_SetItemString(d,"WXK_EXECUTE", SWIG_From_int((int)(WXK_EXECUTE)));
48755 }
48756 {
48757 PyDict_SetItemString(d,"WXK_SNAPSHOT", SWIG_From_int((int)(WXK_SNAPSHOT)));
48758 }
48759 {
48760 PyDict_SetItemString(d,"WXK_INSERT", SWIG_From_int((int)(WXK_INSERT)));
48761 }
48762 {
48763 PyDict_SetItemString(d,"WXK_HELP", SWIG_From_int((int)(WXK_HELP)));
48764 }
48765 {
48766 PyDict_SetItemString(d,"WXK_NUMPAD0", SWIG_From_int((int)(WXK_NUMPAD0)));
48767 }
48768 {
48769 PyDict_SetItemString(d,"WXK_NUMPAD1", SWIG_From_int((int)(WXK_NUMPAD1)));
48770 }
48771 {
48772 PyDict_SetItemString(d,"WXK_NUMPAD2", SWIG_From_int((int)(WXK_NUMPAD2)));
48773 }
48774 {
48775 PyDict_SetItemString(d,"WXK_NUMPAD3", SWIG_From_int((int)(WXK_NUMPAD3)));
48776 }
48777 {
48778 PyDict_SetItemString(d,"WXK_NUMPAD4", SWIG_From_int((int)(WXK_NUMPAD4)));
48779 }
48780 {
48781 PyDict_SetItemString(d,"WXK_NUMPAD5", SWIG_From_int((int)(WXK_NUMPAD5)));
48782 }
48783 {
48784 PyDict_SetItemString(d,"WXK_NUMPAD6", SWIG_From_int((int)(WXK_NUMPAD6)));
48785 }
48786 {
48787 PyDict_SetItemString(d,"WXK_NUMPAD7", SWIG_From_int((int)(WXK_NUMPAD7)));
48788 }
48789 {
48790 PyDict_SetItemString(d,"WXK_NUMPAD8", SWIG_From_int((int)(WXK_NUMPAD8)));
48791 }
48792 {
48793 PyDict_SetItemString(d,"WXK_NUMPAD9", SWIG_From_int((int)(WXK_NUMPAD9)));
48794 }
48795 {
48796 PyDict_SetItemString(d,"WXK_MULTIPLY", SWIG_From_int((int)(WXK_MULTIPLY)));
48797 }
48798 {
48799 PyDict_SetItemString(d,"WXK_ADD", SWIG_From_int((int)(WXK_ADD)));
48800 }
48801 {
48802 PyDict_SetItemString(d,"WXK_SEPARATOR", SWIG_From_int((int)(WXK_SEPARATOR)));
48803 }
48804 {
48805 PyDict_SetItemString(d,"WXK_SUBTRACT", SWIG_From_int((int)(WXK_SUBTRACT)));
48806 }
48807 {
48808 PyDict_SetItemString(d,"WXK_DECIMAL", SWIG_From_int((int)(WXK_DECIMAL)));
48809 }
48810 {
48811 PyDict_SetItemString(d,"WXK_DIVIDE", SWIG_From_int((int)(WXK_DIVIDE)));
48812 }
48813 {
48814 PyDict_SetItemString(d,"WXK_F1", SWIG_From_int((int)(WXK_F1)));
48815 }
48816 {
48817 PyDict_SetItemString(d,"WXK_F2", SWIG_From_int((int)(WXK_F2)));
48818 }
48819 {
48820 PyDict_SetItemString(d,"WXK_F3", SWIG_From_int((int)(WXK_F3)));
48821 }
48822 {
48823 PyDict_SetItemString(d,"WXK_F4", SWIG_From_int((int)(WXK_F4)));
48824 }
48825 {
48826 PyDict_SetItemString(d,"WXK_F5", SWIG_From_int((int)(WXK_F5)));
48827 }
48828 {
48829 PyDict_SetItemString(d,"WXK_F6", SWIG_From_int((int)(WXK_F6)));
48830 }
48831 {
48832 PyDict_SetItemString(d,"WXK_F7", SWIG_From_int((int)(WXK_F7)));
48833 }
48834 {
48835 PyDict_SetItemString(d,"WXK_F8", SWIG_From_int((int)(WXK_F8)));
48836 }
48837 {
48838 PyDict_SetItemString(d,"WXK_F9", SWIG_From_int((int)(WXK_F9)));
48839 }
48840 {
48841 PyDict_SetItemString(d,"WXK_F10", SWIG_From_int((int)(WXK_F10)));
48842 }
48843 {
48844 PyDict_SetItemString(d,"WXK_F11", SWIG_From_int((int)(WXK_F11)));
48845 }
48846 {
48847 PyDict_SetItemString(d,"WXK_F12", SWIG_From_int((int)(WXK_F12)));
48848 }
48849 {
48850 PyDict_SetItemString(d,"WXK_F13", SWIG_From_int((int)(WXK_F13)));
48851 }
48852 {
48853 PyDict_SetItemString(d,"WXK_F14", SWIG_From_int((int)(WXK_F14)));
48854 }
48855 {
48856 PyDict_SetItemString(d,"WXK_F15", SWIG_From_int((int)(WXK_F15)));
48857 }
48858 {
48859 PyDict_SetItemString(d,"WXK_F16", SWIG_From_int((int)(WXK_F16)));
48860 }
48861 {
48862 PyDict_SetItemString(d,"WXK_F17", SWIG_From_int((int)(WXK_F17)));
48863 }
48864 {
48865 PyDict_SetItemString(d,"WXK_F18", SWIG_From_int((int)(WXK_F18)));
48866 }
48867 {
48868 PyDict_SetItemString(d,"WXK_F19", SWIG_From_int((int)(WXK_F19)));
48869 }
48870 {
48871 PyDict_SetItemString(d,"WXK_F20", SWIG_From_int((int)(WXK_F20)));
48872 }
48873 {
48874 PyDict_SetItemString(d,"WXK_F21", SWIG_From_int((int)(WXK_F21)));
48875 }
48876 {
48877 PyDict_SetItemString(d,"WXK_F22", SWIG_From_int((int)(WXK_F22)));
48878 }
48879 {
48880 PyDict_SetItemString(d,"WXK_F23", SWIG_From_int((int)(WXK_F23)));
48881 }
48882 {
48883 PyDict_SetItemString(d,"WXK_F24", SWIG_From_int((int)(WXK_F24)));
48884 }
48885 {
48886 PyDict_SetItemString(d,"WXK_NUMLOCK", SWIG_From_int((int)(WXK_NUMLOCK)));
48887 }
48888 {
48889 PyDict_SetItemString(d,"WXK_SCROLL", SWIG_From_int((int)(WXK_SCROLL)));
48890 }
48891 {
48892 PyDict_SetItemString(d,"WXK_PAGEUP", SWIG_From_int((int)(WXK_PAGEUP)));
48893 }
48894 {
48895 PyDict_SetItemString(d,"WXK_PAGEDOWN", SWIG_From_int((int)(WXK_PAGEDOWN)));
48896 }
48897 {
48898 PyDict_SetItemString(d,"WXK_NUMPAD_SPACE", SWIG_From_int((int)(WXK_NUMPAD_SPACE)));
48899 }
48900 {
48901 PyDict_SetItemString(d,"WXK_NUMPAD_TAB", SWIG_From_int((int)(WXK_NUMPAD_TAB)));
48902 }
48903 {
48904 PyDict_SetItemString(d,"WXK_NUMPAD_ENTER", SWIG_From_int((int)(WXK_NUMPAD_ENTER)));
48905 }
48906 {
48907 PyDict_SetItemString(d,"WXK_NUMPAD_F1", SWIG_From_int((int)(WXK_NUMPAD_F1)));
48908 }
48909 {
48910 PyDict_SetItemString(d,"WXK_NUMPAD_F2", SWIG_From_int((int)(WXK_NUMPAD_F2)));
48911 }
48912 {
48913 PyDict_SetItemString(d,"WXK_NUMPAD_F3", SWIG_From_int((int)(WXK_NUMPAD_F3)));
48914 }
48915 {
48916 PyDict_SetItemString(d,"WXK_NUMPAD_F4", SWIG_From_int((int)(WXK_NUMPAD_F4)));
48917 }
48918 {
48919 PyDict_SetItemString(d,"WXK_NUMPAD_HOME", SWIG_From_int((int)(WXK_NUMPAD_HOME)));
48920 }
48921 {
48922 PyDict_SetItemString(d,"WXK_NUMPAD_LEFT", SWIG_From_int((int)(WXK_NUMPAD_LEFT)));
48923 }
48924 {
48925 PyDict_SetItemString(d,"WXK_NUMPAD_UP", SWIG_From_int((int)(WXK_NUMPAD_UP)));
48926 }
48927 {
48928 PyDict_SetItemString(d,"WXK_NUMPAD_RIGHT", SWIG_From_int((int)(WXK_NUMPAD_RIGHT)));
48929 }
48930 {
48931 PyDict_SetItemString(d,"WXK_NUMPAD_DOWN", SWIG_From_int((int)(WXK_NUMPAD_DOWN)));
48932 }
48933 {
48934 PyDict_SetItemString(d,"WXK_NUMPAD_PRIOR", SWIG_From_int((int)(WXK_NUMPAD_PRIOR)));
48935 }
48936 {
48937 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEUP", SWIG_From_int((int)(WXK_NUMPAD_PAGEUP)));
48938 }
48939 {
48940 PyDict_SetItemString(d,"WXK_NUMPAD_NEXT", SWIG_From_int((int)(WXK_NUMPAD_NEXT)));
48941 }
48942 {
48943 PyDict_SetItemString(d,"WXK_NUMPAD_PAGEDOWN", SWIG_From_int((int)(WXK_NUMPAD_PAGEDOWN)));
48944 }
48945 {
48946 PyDict_SetItemString(d,"WXK_NUMPAD_END", SWIG_From_int((int)(WXK_NUMPAD_END)));
48947 }
48948 {
48949 PyDict_SetItemString(d,"WXK_NUMPAD_BEGIN", SWIG_From_int((int)(WXK_NUMPAD_BEGIN)));
48950 }
48951 {
48952 PyDict_SetItemString(d,"WXK_NUMPAD_INSERT", SWIG_From_int((int)(WXK_NUMPAD_INSERT)));
48953 }
48954 {
48955 PyDict_SetItemString(d,"WXK_NUMPAD_DELETE", SWIG_From_int((int)(WXK_NUMPAD_DELETE)));
48956 }
48957 {
48958 PyDict_SetItemString(d,"WXK_NUMPAD_EQUAL", SWIG_From_int((int)(WXK_NUMPAD_EQUAL)));
48959 }
48960 {
48961 PyDict_SetItemString(d,"WXK_NUMPAD_MULTIPLY", SWIG_From_int((int)(WXK_NUMPAD_MULTIPLY)));
48962 }
48963 {
48964 PyDict_SetItemString(d,"WXK_NUMPAD_ADD", SWIG_From_int((int)(WXK_NUMPAD_ADD)));
48965 }
48966 {
48967 PyDict_SetItemString(d,"WXK_NUMPAD_SEPARATOR", SWIG_From_int((int)(WXK_NUMPAD_SEPARATOR)));
48968 }
48969 {
48970 PyDict_SetItemString(d,"WXK_NUMPAD_SUBTRACT", SWIG_From_int((int)(WXK_NUMPAD_SUBTRACT)));
48971 }
48972 {
48973 PyDict_SetItemString(d,"WXK_NUMPAD_DECIMAL", SWIG_From_int((int)(WXK_NUMPAD_DECIMAL)));
48974 }
48975 {
48976 PyDict_SetItemString(d,"WXK_NUMPAD_DIVIDE", SWIG_From_int((int)(WXK_NUMPAD_DIVIDE)));
48977 }
48978 {
48979 PyDict_SetItemString(d,"WXK_WINDOWS_LEFT", SWIG_From_int((int)(WXK_WINDOWS_LEFT)));
48980 }
48981 {
48982 PyDict_SetItemString(d,"WXK_WINDOWS_RIGHT", SWIG_From_int((int)(WXK_WINDOWS_RIGHT)));
48983 }
48984 {
48985 PyDict_SetItemString(d,"WXK_WINDOWS_MENU", SWIG_From_int((int)(WXK_WINDOWS_MENU)));
48986 }
48987 {
48988 PyDict_SetItemString(d,"WXK_COMMAND", SWIG_From_int((int)(WXK_COMMAND)));
48989 }
48990 {
48991 PyDict_SetItemString(d,"WXK_SPECIAL1", SWIG_From_int((int)(WXK_SPECIAL1)));
48992 }
48993 {
48994 PyDict_SetItemString(d,"WXK_SPECIAL2", SWIG_From_int((int)(WXK_SPECIAL2)));
48995 }
48996 {
48997 PyDict_SetItemString(d,"WXK_SPECIAL3", SWIG_From_int((int)(WXK_SPECIAL3)));
48998 }
48999 {
49000 PyDict_SetItemString(d,"WXK_SPECIAL4", SWIG_From_int((int)(WXK_SPECIAL4)));
49001 }
49002 {
49003 PyDict_SetItemString(d,"WXK_SPECIAL5", SWIG_From_int((int)(WXK_SPECIAL5)));
49004 }
49005 {
49006 PyDict_SetItemString(d,"WXK_SPECIAL6", SWIG_From_int((int)(WXK_SPECIAL6)));
49007 }
49008 {
49009 PyDict_SetItemString(d,"WXK_SPECIAL7", SWIG_From_int((int)(WXK_SPECIAL7)));
49010 }
49011 {
49012 PyDict_SetItemString(d,"WXK_SPECIAL8", SWIG_From_int((int)(WXK_SPECIAL8)));
49013 }
49014 {
49015 PyDict_SetItemString(d,"WXK_SPECIAL9", SWIG_From_int((int)(WXK_SPECIAL9)));
49016 }
49017 {
49018 PyDict_SetItemString(d,"WXK_SPECIAL10", SWIG_From_int((int)(WXK_SPECIAL10)));
49019 }
49020 {
49021 PyDict_SetItemString(d,"WXK_SPECIAL11", SWIG_From_int((int)(WXK_SPECIAL11)));
49022 }
49023 {
49024 PyDict_SetItemString(d,"WXK_SPECIAL12", SWIG_From_int((int)(WXK_SPECIAL12)));
49025 }
49026 {
49027 PyDict_SetItemString(d,"WXK_SPECIAL13", SWIG_From_int((int)(WXK_SPECIAL13)));
49028 }
49029 {
49030 PyDict_SetItemString(d,"WXK_SPECIAL14", SWIG_From_int((int)(WXK_SPECIAL14)));
49031 }
49032 {
49033 PyDict_SetItemString(d,"WXK_SPECIAL15", SWIG_From_int((int)(WXK_SPECIAL15)));
49034 }
49035 {
49036 PyDict_SetItemString(d,"WXK_SPECIAL16", SWIG_From_int((int)(WXK_SPECIAL16)));
49037 }
49038 {
49039 PyDict_SetItemString(d,"WXK_SPECIAL17", SWIG_From_int((int)(WXK_SPECIAL17)));
49040 }
49041 {
49042 PyDict_SetItemString(d,"WXK_SPECIAL18", SWIG_From_int((int)(WXK_SPECIAL18)));
49043 }
49044 {
49045 PyDict_SetItemString(d,"WXK_SPECIAL19", SWIG_From_int((int)(WXK_SPECIAL19)));
49046 }
49047 {
49048 PyDict_SetItemString(d,"WXK_SPECIAL20", SWIG_From_int((int)(WXK_SPECIAL20)));
49049 }
49050 {
49051 PyDict_SetItemString(d,"PAPER_NONE", SWIG_From_int((int)(wxPAPER_NONE)));
49052 }
49053 {
49054 PyDict_SetItemString(d,"PAPER_LETTER", SWIG_From_int((int)(wxPAPER_LETTER)));
49055 }
49056 {
49057 PyDict_SetItemString(d,"PAPER_LEGAL", SWIG_From_int((int)(wxPAPER_LEGAL)));
49058 }
49059 {
49060 PyDict_SetItemString(d,"PAPER_A4", SWIG_From_int((int)(wxPAPER_A4)));
49061 }
49062 {
49063 PyDict_SetItemString(d,"PAPER_CSHEET", SWIG_From_int((int)(wxPAPER_CSHEET)));
49064 }
49065 {
49066 PyDict_SetItemString(d,"PAPER_DSHEET", SWIG_From_int((int)(wxPAPER_DSHEET)));
49067 }
49068 {
49069 PyDict_SetItemString(d,"PAPER_ESHEET", SWIG_From_int((int)(wxPAPER_ESHEET)));
49070 }
49071 {
49072 PyDict_SetItemString(d,"PAPER_LETTERSMALL", SWIG_From_int((int)(wxPAPER_LETTERSMALL)));
49073 }
49074 {
49075 PyDict_SetItemString(d,"PAPER_TABLOID", SWIG_From_int((int)(wxPAPER_TABLOID)));
49076 }
49077 {
49078 PyDict_SetItemString(d,"PAPER_LEDGER", SWIG_From_int((int)(wxPAPER_LEDGER)));
49079 }
49080 {
49081 PyDict_SetItemString(d,"PAPER_STATEMENT", SWIG_From_int((int)(wxPAPER_STATEMENT)));
49082 }
49083 {
49084 PyDict_SetItemString(d,"PAPER_EXECUTIVE", SWIG_From_int((int)(wxPAPER_EXECUTIVE)));
49085 }
49086 {
49087 PyDict_SetItemString(d,"PAPER_A3", SWIG_From_int((int)(wxPAPER_A3)));
49088 }
49089 {
49090 PyDict_SetItemString(d,"PAPER_A4SMALL", SWIG_From_int((int)(wxPAPER_A4SMALL)));
49091 }
49092 {
49093 PyDict_SetItemString(d,"PAPER_A5", SWIG_From_int((int)(wxPAPER_A5)));
49094 }
49095 {
49096 PyDict_SetItemString(d,"PAPER_B4", SWIG_From_int((int)(wxPAPER_B4)));
49097 }
49098 {
49099 PyDict_SetItemString(d,"PAPER_B5", SWIG_From_int((int)(wxPAPER_B5)));
49100 }
49101 {
49102 PyDict_SetItemString(d,"PAPER_FOLIO", SWIG_From_int((int)(wxPAPER_FOLIO)));
49103 }
49104 {
49105 PyDict_SetItemString(d,"PAPER_QUARTO", SWIG_From_int((int)(wxPAPER_QUARTO)));
49106 }
49107 {
49108 PyDict_SetItemString(d,"PAPER_10X14", SWIG_From_int((int)(wxPAPER_10X14)));
49109 }
49110 {
49111 PyDict_SetItemString(d,"PAPER_11X17", SWIG_From_int((int)(wxPAPER_11X17)));
49112 }
49113 {
49114 PyDict_SetItemString(d,"PAPER_NOTE", SWIG_From_int((int)(wxPAPER_NOTE)));
49115 }
49116 {
49117 PyDict_SetItemString(d,"PAPER_ENV_9", SWIG_From_int((int)(wxPAPER_ENV_9)));
49118 }
49119 {
49120 PyDict_SetItemString(d,"PAPER_ENV_10", SWIG_From_int((int)(wxPAPER_ENV_10)));
49121 }
49122 {
49123 PyDict_SetItemString(d,"PAPER_ENV_11", SWIG_From_int((int)(wxPAPER_ENV_11)));
49124 }
49125 {
49126 PyDict_SetItemString(d,"PAPER_ENV_12", SWIG_From_int((int)(wxPAPER_ENV_12)));
49127 }
49128 {
49129 PyDict_SetItemString(d,"PAPER_ENV_14", SWIG_From_int((int)(wxPAPER_ENV_14)));
49130 }
49131 {
49132 PyDict_SetItemString(d,"PAPER_ENV_DL", SWIG_From_int((int)(wxPAPER_ENV_DL)));
49133 }
49134 {
49135 PyDict_SetItemString(d,"PAPER_ENV_C5", SWIG_From_int((int)(wxPAPER_ENV_C5)));
49136 }
49137 {
49138 PyDict_SetItemString(d,"PAPER_ENV_C3", SWIG_From_int((int)(wxPAPER_ENV_C3)));
49139 }
49140 {
49141 PyDict_SetItemString(d,"PAPER_ENV_C4", SWIG_From_int((int)(wxPAPER_ENV_C4)));
49142 }
49143 {
49144 PyDict_SetItemString(d,"PAPER_ENV_C6", SWIG_From_int((int)(wxPAPER_ENV_C6)));
49145 }
49146 {
49147 PyDict_SetItemString(d,"PAPER_ENV_C65", SWIG_From_int((int)(wxPAPER_ENV_C65)));
49148 }
49149 {
49150 PyDict_SetItemString(d,"PAPER_ENV_B4", SWIG_From_int((int)(wxPAPER_ENV_B4)));
49151 }
49152 {
49153 PyDict_SetItemString(d,"PAPER_ENV_B5", SWIG_From_int((int)(wxPAPER_ENV_B5)));
49154 }
49155 {
49156 PyDict_SetItemString(d,"PAPER_ENV_B6", SWIG_From_int((int)(wxPAPER_ENV_B6)));
49157 }
49158 {
49159 PyDict_SetItemString(d,"PAPER_ENV_ITALY", SWIG_From_int((int)(wxPAPER_ENV_ITALY)));
49160 }
49161 {
49162 PyDict_SetItemString(d,"PAPER_ENV_MONARCH", SWIG_From_int((int)(wxPAPER_ENV_MONARCH)));
49163 }
49164 {
49165 PyDict_SetItemString(d,"PAPER_ENV_PERSONAL", SWIG_From_int((int)(wxPAPER_ENV_PERSONAL)));
49166 }
49167 {
49168 PyDict_SetItemString(d,"PAPER_FANFOLD_US", SWIG_From_int((int)(wxPAPER_FANFOLD_US)));
49169 }
49170 {
49171 PyDict_SetItemString(d,"PAPER_FANFOLD_STD_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_STD_GERMAN)));
49172 }
49173 {
49174 PyDict_SetItemString(d,"PAPER_FANFOLD_LGL_GERMAN", SWIG_From_int((int)(wxPAPER_FANFOLD_LGL_GERMAN)));
49175 }
49176 {
49177 PyDict_SetItemString(d,"PAPER_ISO_B4", SWIG_From_int((int)(wxPAPER_ISO_B4)));
49178 }
49179 {
49180 PyDict_SetItemString(d,"PAPER_JAPANESE_POSTCARD", SWIG_From_int((int)(wxPAPER_JAPANESE_POSTCARD)));
49181 }
49182 {
49183 PyDict_SetItemString(d,"PAPER_9X11", SWIG_From_int((int)(wxPAPER_9X11)));
49184 }
49185 {
49186 PyDict_SetItemString(d,"PAPER_10X11", SWIG_From_int((int)(wxPAPER_10X11)));
49187 }
49188 {
49189 PyDict_SetItemString(d,"PAPER_15X11", SWIG_From_int((int)(wxPAPER_15X11)));
49190 }
49191 {
49192 PyDict_SetItemString(d,"PAPER_ENV_INVITE", SWIG_From_int((int)(wxPAPER_ENV_INVITE)));
49193 }
49194 {
49195 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA)));
49196 }
49197 {
49198 PyDict_SetItemString(d,"PAPER_LEGAL_EXTRA", SWIG_From_int((int)(wxPAPER_LEGAL_EXTRA)));
49199 }
49200 {
49201 PyDict_SetItemString(d,"PAPER_TABLOID_EXTRA", SWIG_From_int((int)(wxPAPER_TABLOID_EXTRA)));
49202 }
49203 {
49204 PyDict_SetItemString(d,"PAPER_A4_EXTRA", SWIG_From_int((int)(wxPAPER_A4_EXTRA)));
49205 }
49206 {
49207 PyDict_SetItemString(d,"PAPER_LETTER_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_TRANSVERSE)));
49208 }
49209 {
49210 PyDict_SetItemString(d,"PAPER_A4_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A4_TRANSVERSE)));
49211 }
49212 {
49213 PyDict_SetItemString(d,"PAPER_LETTER_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
49214 }
49215 {
49216 PyDict_SetItemString(d,"PAPER_A_PLUS", SWIG_From_int((int)(wxPAPER_A_PLUS)));
49217 }
49218 {
49219 PyDict_SetItemString(d,"PAPER_B_PLUS", SWIG_From_int((int)(wxPAPER_B_PLUS)));
49220 }
49221 {
49222 PyDict_SetItemString(d,"PAPER_LETTER_PLUS", SWIG_From_int((int)(wxPAPER_LETTER_PLUS)));
49223 }
49224 {
49225 PyDict_SetItemString(d,"PAPER_A4_PLUS", SWIG_From_int((int)(wxPAPER_A4_PLUS)));
49226 }
49227 {
49228 PyDict_SetItemString(d,"PAPER_A5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A5_TRANSVERSE)));
49229 }
49230 {
49231 PyDict_SetItemString(d,"PAPER_B5_TRANSVERSE", SWIG_From_int((int)(wxPAPER_B5_TRANSVERSE)));
49232 }
49233 {
49234 PyDict_SetItemString(d,"PAPER_A3_EXTRA", SWIG_From_int((int)(wxPAPER_A3_EXTRA)));
49235 }
49236 {
49237 PyDict_SetItemString(d,"PAPER_A5_EXTRA", SWIG_From_int((int)(wxPAPER_A5_EXTRA)));
49238 }
49239 {
49240 PyDict_SetItemString(d,"PAPER_B5_EXTRA", SWIG_From_int((int)(wxPAPER_B5_EXTRA)));
49241 }
49242 {
49243 PyDict_SetItemString(d,"PAPER_A2", SWIG_From_int((int)(wxPAPER_A2)));
49244 }
49245 {
49246 PyDict_SetItemString(d,"PAPER_A3_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_TRANSVERSE)));
49247 }
49248 {
49249 PyDict_SetItemString(d,"PAPER_A3_EXTRA_TRANSVERSE", SWIG_From_int((int)(wxPAPER_A3_EXTRA_TRANSVERSE)));
49250 }
49251 {
49252 PyDict_SetItemString(d,"DUPLEX_SIMPLEX", SWIG_From_int((int)(wxDUPLEX_SIMPLEX)));
49253 }
49254 {
49255 PyDict_SetItemString(d,"DUPLEX_HORIZONTAL", SWIG_From_int((int)(wxDUPLEX_HORIZONTAL)));
49256 }
49257 {
49258 PyDict_SetItemString(d,"DUPLEX_VERTICAL", SWIG_From_int((int)(wxDUPLEX_VERTICAL)));
49259 }
49260 {
49261 PyDict_SetItemString(d,"ITEM_SEPARATOR", SWIG_From_int((int)(wxITEM_SEPARATOR)));
49262 }
49263 {
49264 PyDict_SetItemString(d,"ITEM_NORMAL", SWIG_From_int((int)(wxITEM_NORMAL)));
49265 }
49266 {
49267 PyDict_SetItemString(d,"ITEM_CHECK", SWIG_From_int((int)(wxITEM_CHECK)));
49268 }
49269 {
49270 PyDict_SetItemString(d,"ITEM_RADIO", SWIG_From_int((int)(wxITEM_RADIO)));
49271 }
49272 {
49273 PyDict_SetItemString(d,"ITEM_MAX", SWIG_From_int((int)(wxITEM_MAX)));
49274 }
49275 {
49276 PyDict_SetItemString(d,"HT_NOWHERE", SWIG_From_int((int)(wxHT_NOWHERE)));
49277 }
49278 {
49279 PyDict_SetItemString(d,"HT_SCROLLBAR_FIRST", SWIG_From_int((int)(wxHT_SCROLLBAR_FIRST)));
49280 }
49281 {
49282 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_1)));
49283 }
49284 {
49285 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_LINE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_LINE_2)));
49286 }
49287 {
49288 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_1", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_1)));
49289 }
49290 {
49291 PyDict_SetItemString(d,"HT_SCROLLBAR_ARROW_PAGE_2", SWIG_From_int((int)(wxHT_SCROLLBAR_ARROW_PAGE_2)));
49292 }
49293 {
49294 PyDict_SetItemString(d,"HT_SCROLLBAR_THUMB", SWIG_From_int((int)(wxHT_SCROLLBAR_THUMB)));
49295 }
49296 {
49297 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_1", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_1)));
49298 }
49299 {
49300 PyDict_SetItemString(d,"HT_SCROLLBAR_BAR_2", SWIG_From_int((int)(wxHT_SCROLLBAR_BAR_2)));
49301 }
49302 {
49303 PyDict_SetItemString(d,"HT_SCROLLBAR_LAST", SWIG_From_int((int)(wxHT_SCROLLBAR_LAST)));
49304 }
49305 {
49306 PyDict_SetItemString(d,"HT_WINDOW_OUTSIDE", SWIG_From_int((int)(wxHT_WINDOW_OUTSIDE)));
49307 }
49308 {
49309 PyDict_SetItemString(d,"HT_WINDOW_INSIDE", SWIG_From_int((int)(wxHT_WINDOW_INSIDE)));
49310 }
49311 {
49312 PyDict_SetItemString(d,"HT_WINDOW_VERT_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_VERT_SCROLLBAR)));
49313 }
49314 {
49315 PyDict_SetItemString(d,"HT_WINDOW_HORZ_SCROLLBAR", SWIG_From_int((int)(wxHT_WINDOW_HORZ_SCROLLBAR)));
49316 }
49317 {
49318 PyDict_SetItemString(d,"HT_WINDOW_CORNER", SWIG_From_int((int)(wxHT_WINDOW_CORNER)));
49319 }
49320 {
49321 PyDict_SetItemString(d,"HT_MAX", SWIG_From_int((int)(wxHT_MAX)));
49322 }
49323 {
49324 PyDict_SetItemString(d,"MOD_NONE", SWIG_From_int((int)(wxMOD_NONE)));
49325 }
49326 {
49327 PyDict_SetItemString(d,"MOD_ALT", SWIG_From_int((int)(wxMOD_ALT)));
49328 }
49329 {
49330 PyDict_SetItemString(d,"MOD_CONTROL", SWIG_From_int((int)(wxMOD_CONTROL)));
49331 }
49332 {
49333 PyDict_SetItemString(d,"MOD_SHIFT", SWIG_From_int((int)(wxMOD_SHIFT)));
49334 }
49335 {
49336 PyDict_SetItemString(d,"MOD_WIN", SWIG_From_int((int)(wxMOD_WIN)));
49337 }
49338 {
49339 PyDict_SetItemString(d,"UPDATE_UI_NONE", SWIG_From_int((int)(wxUPDATE_UI_NONE)));
49340 }
49341 {
49342 PyDict_SetItemString(d,"UPDATE_UI_RECURSE", SWIG_From_int((int)(wxUPDATE_UI_RECURSE)));
49343 }
49344 {
49345 PyDict_SetItemString(d,"UPDATE_UI_FROMIDLE", SWIG_From_int((int)(wxUPDATE_UI_FROMIDLE)));
49346 }
49347 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
49348 SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
49349 {
49350 PyDict_SetItemString(d,"BITMAP_TYPE_INVALID", SWIG_From_int((int)(wxBITMAP_TYPE_INVALID)));
49351 }
49352 {
49353 PyDict_SetItemString(d,"BITMAP_TYPE_BMP", SWIG_From_int((int)(wxBITMAP_TYPE_BMP)));
49354 }
49355 {
49356 PyDict_SetItemString(d,"BITMAP_TYPE_ICO", SWIG_From_int((int)(wxBITMAP_TYPE_ICO)));
49357 }
49358 {
49359 PyDict_SetItemString(d,"BITMAP_TYPE_CUR", SWIG_From_int((int)(wxBITMAP_TYPE_CUR)));
49360 }
49361 {
49362 PyDict_SetItemString(d,"BITMAP_TYPE_XBM", SWIG_From_int((int)(wxBITMAP_TYPE_XBM)));
49363 }
49364 {
49365 PyDict_SetItemString(d,"BITMAP_TYPE_XBM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XBM_DATA)));
49366 }
49367 {
49368 PyDict_SetItemString(d,"BITMAP_TYPE_XPM", SWIG_From_int((int)(wxBITMAP_TYPE_XPM)));
49369 }
49370 {
49371 PyDict_SetItemString(d,"BITMAP_TYPE_XPM_DATA", SWIG_From_int((int)(wxBITMAP_TYPE_XPM_DATA)));
49372 }
49373 {
49374 PyDict_SetItemString(d,"BITMAP_TYPE_TIF", SWIG_From_int((int)(wxBITMAP_TYPE_TIF)));
49375 }
49376 {
49377 PyDict_SetItemString(d,"BITMAP_TYPE_GIF", SWIG_From_int((int)(wxBITMAP_TYPE_GIF)));
49378 }
49379 {
49380 PyDict_SetItemString(d,"BITMAP_TYPE_PNG", SWIG_From_int((int)(wxBITMAP_TYPE_PNG)));
49381 }
49382 {
49383 PyDict_SetItemString(d,"BITMAP_TYPE_JPEG", SWIG_From_int((int)(wxBITMAP_TYPE_JPEG)));
49384 }
49385 {
49386 PyDict_SetItemString(d,"BITMAP_TYPE_PNM", SWIG_From_int((int)(wxBITMAP_TYPE_PNM)));
49387 }
49388 {
49389 PyDict_SetItemString(d,"BITMAP_TYPE_PCX", SWIG_From_int((int)(wxBITMAP_TYPE_PCX)));
49390 }
49391 {
49392 PyDict_SetItemString(d,"BITMAP_TYPE_PICT", SWIG_From_int((int)(wxBITMAP_TYPE_PICT)));
49393 }
49394 {
49395 PyDict_SetItemString(d,"BITMAP_TYPE_ICON", SWIG_From_int((int)(wxBITMAP_TYPE_ICON)));
49396 }
49397 {
49398 PyDict_SetItemString(d,"BITMAP_TYPE_ANI", SWIG_From_int((int)(wxBITMAP_TYPE_ANI)));
49399 }
49400 {
49401 PyDict_SetItemString(d,"BITMAP_TYPE_IFF", SWIG_From_int((int)(wxBITMAP_TYPE_IFF)));
49402 }
49403 {
49404 PyDict_SetItemString(d,"BITMAP_TYPE_MACCURSOR", SWIG_From_int((int)(wxBITMAP_TYPE_MACCURSOR)));
49405 }
49406 {
49407 PyDict_SetItemString(d,"BITMAP_TYPE_ANY", SWIG_From_int((int)(wxBITMAP_TYPE_ANY)));
49408 }
49409 {
49410 PyDict_SetItemString(d,"CURSOR_NONE", SWIG_From_int((int)(wxCURSOR_NONE)));
49411 }
49412 {
49413 PyDict_SetItemString(d,"CURSOR_ARROW", SWIG_From_int((int)(wxCURSOR_ARROW)));
49414 }
49415 {
49416 PyDict_SetItemString(d,"CURSOR_RIGHT_ARROW", SWIG_From_int((int)(wxCURSOR_RIGHT_ARROW)));
49417 }
49418 {
49419 PyDict_SetItemString(d,"CURSOR_BULLSEYE", SWIG_From_int((int)(wxCURSOR_BULLSEYE)));
49420 }
49421 {
49422 PyDict_SetItemString(d,"CURSOR_CHAR", SWIG_From_int((int)(wxCURSOR_CHAR)));
49423 }
49424 {
49425 PyDict_SetItemString(d,"CURSOR_CROSS", SWIG_From_int((int)(wxCURSOR_CROSS)));
49426 }
49427 {
49428 PyDict_SetItemString(d,"CURSOR_HAND", SWIG_From_int((int)(wxCURSOR_HAND)));
49429 }
49430 {
49431 PyDict_SetItemString(d,"CURSOR_IBEAM", SWIG_From_int((int)(wxCURSOR_IBEAM)));
49432 }
49433 {
49434 PyDict_SetItemString(d,"CURSOR_LEFT_BUTTON", SWIG_From_int((int)(wxCURSOR_LEFT_BUTTON)));
49435 }
49436 {
49437 PyDict_SetItemString(d,"CURSOR_MAGNIFIER", SWIG_From_int((int)(wxCURSOR_MAGNIFIER)));
49438 }
49439 {
49440 PyDict_SetItemString(d,"CURSOR_MIDDLE_BUTTON", SWIG_From_int((int)(wxCURSOR_MIDDLE_BUTTON)));
49441 }
49442 {
49443 PyDict_SetItemString(d,"CURSOR_NO_ENTRY", SWIG_From_int((int)(wxCURSOR_NO_ENTRY)));
49444 }
49445 {
49446 PyDict_SetItemString(d,"CURSOR_PAINT_BRUSH", SWIG_From_int((int)(wxCURSOR_PAINT_BRUSH)));
49447 }
49448 {
49449 PyDict_SetItemString(d,"CURSOR_PENCIL", SWIG_From_int((int)(wxCURSOR_PENCIL)));
49450 }
49451 {
49452 PyDict_SetItemString(d,"CURSOR_POINT_LEFT", SWIG_From_int((int)(wxCURSOR_POINT_LEFT)));
49453 }
49454 {
49455 PyDict_SetItemString(d,"CURSOR_POINT_RIGHT", SWIG_From_int((int)(wxCURSOR_POINT_RIGHT)));
49456 }
49457 {
49458 PyDict_SetItemString(d,"CURSOR_QUESTION_ARROW", SWIG_From_int((int)(wxCURSOR_QUESTION_ARROW)));
49459 }
49460 {
49461 PyDict_SetItemString(d,"CURSOR_RIGHT_BUTTON", SWIG_From_int((int)(wxCURSOR_RIGHT_BUTTON)));
49462 }
49463 {
49464 PyDict_SetItemString(d,"CURSOR_SIZENESW", SWIG_From_int((int)(wxCURSOR_SIZENESW)));
49465 }
49466 {
49467 PyDict_SetItemString(d,"CURSOR_SIZENS", SWIG_From_int((int)(wxCURSOR_SIZENS)));
49468 }
49469 {
49470 PyDict_SetItemString(d,"CURSOR_SIZENWSE", SWIG_From_int((int)(wxCURSOR_SIZENWSE)));
49471 }
49472 {
49473 PyDict_SetItemString(d,"CURSOR_SIZEWE", SWIG_From_int((int)(wxCURSOR_SIZEWE)));
49474 }
49475 {
49476 PyDict_SetItemString(d,"CURSOR_SIZING", SWIG_From_int((int)(wxCURSOR_SIZING)));
49477 }
49478 {
49479 PyDict_SetItemString(d,"CURSOR_SPRAYCAN", SWIG_From_int((int)(wxCURSOR_SPRAYCAN)));
49480 }
49481 {
49482 PyDict_SetItemString(d,"CURSOR_WAIT", SWIG_From_int((int)(wxCURSOR_WAIT)));
49483 }
49484 {
49485 PyDict_SetItemString(d,"CURSOR_WATCH", SWIG_From_int((int)(wxCURSOR_WATCH)));
49486 }
49487 {
49488 PyDict_SetItemString(d,"CURSOR_BLANK", SWIG_From_int((int)(wxCURSOR_BLANK)));
49489 }
49490 {
49491 PyDict_SetItemString(d,"CURSOR_DEFAULT", SWIG_From_int((int)(wxCURSOR_DEFAULT)));
49492 }
49493 {
49494 PyDict_SetItemString(d,"CURSOR_COPY_ARROW", SWIG_From_int((int)(wxCURSOR_COPY_ARROW)));
49495 }
49496 {
49497 PyDict_SetItemString(d,"CURSOR_ARROWWAIT", SWIG_From_int((int)(wxCURSOR_ARROWWAIT)));
49498 }
49499 {
49500 PyDict_SetItemString(d,"CURSOR_MAX", SWIG_From_int((int)(wxCURSOR_MAX)));
49501 }
49502 SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
49503 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
49504 {
49505 PyDict_SetItemString(d,"FromStart", SWIG_From_int((int)(wxFromStart)));
49506 }
49507 {
49508 PyDict_SetItemString(d,"FromCurrent", SWIG_From_int((int)(wxFromCurrent)));
49509 }
49510 {
49511 PyDict_SetItemString(d,"FromEnd", SWIG_From_int((int)(wxFromEnd)));
49512 }
49513
49514 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
49515
49516
49517 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
49518
49519 {
49520 PyDict_SetItemString(d,"IMAGE_ALPHA_TRANSPARENT", SWIG_From_int((int)(wxIMAGE_ALPHA_TRANSPARENT)));
49521 }
49522 {
49523 PyDict_SetItemString(d,"IMAGE_ALPHA_THRESHOLD", SWIG_From_int((int)(wxIMAGE_ALPHA_THRESHOLD)));
49524 }
49525 {
49526 PyDict_SetItemString(d,"IMAGE_ALPHA_OPAQUE", SWIG_From_int((int)(wxIMAGE_ALPHA_OPAQUE)));
49527 }
49528 SWIG_addvarlink(SWIG_globals,(char*)"NullImage",_wrap_NullImage_get, _wrap_NullImage_set);
49529 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_FILENAME",_wrap_IMAGE_OPTION_FILENAME_get, _wrap_IMAGE_OPTION_FILENAME_set);
49530 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BMP_FORMAT",_wrap_IMAGE_OPTION_BMP_FORMAT_get, _wrap_IMAGE_OPTION_BMP_FORMAT_set);
49531 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",_wrap_IMAGE_OPTION_CUR_HOTSPOT_X_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_X_set);
49532 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",_wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_get, _wrap_IMAGE_OPTION_CUR_HOTSPOT_Y_set);
49533 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTION",_wrap_IMAGE_OPTION_RESOLUTION_get, _wrap_IMAGE_OPTION_RESOLUTION_set);
49534 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONX",_wrap_IMAGE_OPTION_RESOLUTIONX_get, _wrap_IMAGE_OPTION_RESOLUTIONX_set);
49535 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONY",_wrap_IMAGE_OPTION_RESOLUTIONY_get, _wrap_IMAGE_OPTION_RESOLUTIONY_set);
49536 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_RESOLUTIONUNIT",_wrap_IMAGE_OPTION_RESOLUTIONUNIT_get, _wrap_IMAGE_OPTION_RESOLUTIONUNIT_set);
49537 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_QUALITY",_wrap_IMAGE_OPTION_QUALITY_get, _wrap_IMAGE_OPTION_QUALITY_set);
49538 {
49539 PyDict_SetItemString(d,"IMAGE_RESOLUTION_INCHES", SWIG_From_int((int)(wxIMAGE_RESOLUTION_INCHES)));
49540 }
49541 {
49542 PyDict_SetItemString(d,"IMAGE_RESOLUTION_CM", SWIG_From_int((int)(wxIMAGE_RESOLUTION_CM)));
49543 }
49544 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_BITSPERSAMPLE",_wrap_IMAGE_OPTION_BITSPERSAMPLE_get, _wrap_IMAGE_OPTION_BITSPERSAMPLE_set);
49545 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",_wrap_IMAGE_OPTION_SAMPLESPERPIXEL_get, _wrap_IMAGE_OPTION_SAMPLESPERPIXEL_set);
49546 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_COMPRESSION",_wrap_IMAGE_OPTION_COMPRESSION_get, _wrap_IMAGE_OPTION_COMPRESSION_set);
49547 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",_wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_get, _wrap_IMAGE_OPTION_IMAGEDESCRIPTOR_set);
49548 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_FORMAT",_wrap_IMAGE_OPTION_PNG_FORMAT_get, _wrap_IMAGE_OPTION_PNG_FORMAT_set);
49549 SWIG_addvarlink(SWIG_globals,(char*)"IMAGE_OPTION_PNG_BITDEPTH",_wrap_IMAGE_OPTION_PNG_BITDEPTH_get, _wrap_IMAGE_OPTION_PNG_BITDEPTH_set);
49550 {
49551 PyDict_SetItemString(d,"PNG_TYPE_COLOUR", SWIG_From_int((int)(wxPNG_TYPE_COLOUR)));
49552 }
49553 {
49554 PyDict_SetItemString(d,"PNG_TYPE_GREY", SWIG_From_int((int)(wxPNG_TYPE_GREY)));
49555 }
49556 {
49557 PyDict_SetItemString(d,"PNG_TYPE_GREY_RED", SWIG_From_int((int)(wxPNG_TYPE_GREY_RED)));
49558 }
49559 {
49560 PyDict_SetItemString(d,"BMP_24BPP", SWIG_From_int((int)(wxBMP_24BPP)));
49561 }
49562 {
49563 PyDict_SetItemString(d,"BMP_8BPP", SWIG_From_int((int)(wxBMP_8BPP)));
49564 }
49565 {
49566 PyDict_SetItemString(d,"BMP_8BPP_GREY", SWIG_From_int((int)(wxBMP_8BPP_GREY)));
49567 }
49568 {
49569 PyDict_SetItemString(d,"BMP_8BPP_GRAY", SWIG_From_int((int)(wxBMP_8BPP_GRAY)));
49570 }
49571 {
49572 PyDict_SetItemString(d,"BMP_8BPP_RED", SWIG_From_int((int)(wxBMP_8BPP_RED)));
49573 }
49574 {
49575 PyDict_SetItemString(d,"BMP_8BPP_PALETTE", SWIG_From_int((int)(wxBMP_8BPP_PALETTE)));
49576 }
49577 {
49578 PyDict_SetItemString(d,"BMP_4BPP", SWIG_From_int((int)(wxBMP_4BPP)));
49579 }
49580 {
49581 PyDict_SetItemString(d,"BMP_1BPP", SWIG_From_int((int)(wxBMP_1BPP)));
49582 }
49583 {
49584 PyDict_SetItemString(d,"BMP_1BPP_BW", SWIG_From_int((int)(wxBMP_1BPP_BW)));
49585 }
49586 {
49587 PyDict_SetItemString(d,"QUANTIZE_INCLUDE_WINDOWS_COLOURS", SWIG_From_int((int)(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
49588 }
49589 {
49590 PyDict_SetItemString(d,"QUANTIZE_FILL_DESTINATION_IMAGE", SWIG_From_int((int)(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
49591 }
49592 {
49593 PyDict_SetItemString(d,"EVENT_PROPAGATE_NONE", SWIG_From_int((int)(wxEVENT_PROPAGATE_NONE)));
49594 }
49595 {
49596 PyDict_SetItemString(d,"EVENT_PROPAGATE_MAX", SWIG_From_int((int)(wxEVENT_PROPAGATE_MAX)));
49597 }
49598 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
49599 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
49600 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
49601 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
49602 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
49603 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
49604 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
49605 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
49606 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
49607 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
49608 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
49609 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
49610 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
49611 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
49612 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
49613 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
49614 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
49615 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
49616 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
49617 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
49618 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
49619 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
49620 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
49621 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
49622 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
49623 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
49624 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
49625 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
49626 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
49627 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
49628 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
49629 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
49630 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
49631 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
49632 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
49633 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
49634 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
49635 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
49636 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
49637 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
49638 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
49639 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
49640 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
49641 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
49642 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
49643 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
49644 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
49645 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
49646 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
49647 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
49648 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
49649 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
49650 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
49651 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
49652 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
49653 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
49654 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
49655 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
49656 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
49657 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
49658 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
49659 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
49660 PyDict_SetItemString(d, "wxEVT_SCROLL_ENDSCROLL", PyInt_FromLong(wxEVT_SCROLL_ENDSCROLL));
49661 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
49662 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
49663 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
49664 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
49665 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
49666 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
49667 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
49668 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
49669 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
49670 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
49671 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
49672 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
49673 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
49674 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
49675 PyDict_SetItemString(d, "wxEVT_POWER", PyInt_FromLong(wxEVT_POWER));
49676 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
49677 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
49678 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
49679 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
49680 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
49681 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
49682 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
49683 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
49684 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
49685 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
49686 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
49687 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
49688 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
49689 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
49690 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
49691 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
49692 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
49693 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
49694 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
49695 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
49696 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
49697 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
49698 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
49699 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
49700 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
49701 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
49702 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
49703 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
49704 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
49705 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
49706 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
49707 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
49708 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
49709 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
49710 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
49711 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
49712 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
49713 {
49714 PyDict_SetItemString(d,"MOUSE_BTN_ANY", SWIG_From_int((int)(wxMOUSE_BTN_ANY)));
49715 }
49716 {
49717 PyDict_SetItemString(d,"MOUSE_BTN_NONE", SWIG_From_int((int)(wxMOUSE_BTN_NONE)));
49718 }
49719 {
49720 PyDict_SetItemString(d,"MOUSE_BTN_LEFT", SWIG_From_int((int)(wxMOUSE_BTN_LEFT)));
49721 }
49722 {
49723 PyDict_SetItemString(d,"MOUSE_BTN_MIDDLE", SWIG_From_int((int)(wxMOUSE_BTN_MIDDLE)));
49724 }
49725 {
49726 PyDict_SetItemString(d,"MOUSE_BTN_RIGHT", SWIG_From_int((int)(wxMOUSE_BTN_RIGHT)));
49727 }
49728 {
49729 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_ALL", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_ALL)));
49730 }
49731 {
49732 PyDict_SetItemString(d,"UPDATE_UI_PROCESS_SPECIFIED", SWIG_From_int((int)(wxUPDATE_UI_PROCESS_SPECIFIED)));
49733 }
49734 {
49735 PyDict_SetItemString(d,"NavigationKeyEvent_IsBackward", SWIG_From_int((int)(wxNavigationKeyEvent::IsBackward)));
49736 }
49737 {
49738 PyDict_SetItemString(d,"NavigationKeyEvent_IsForward", SWIG_From_int((int)(wxNavigationKeyEvent::IsForward)));
49739 }
49740 {
49741 PyDict_SetItemString(d,"NavigationKeyEvent_WinChange", SWIG_From_int((int)(wxNavigationKeyEvent::WinChange)));
49742 }
49743 {
49744 PyDict_SetItemString(d,"NavigationKeyEvent_FromTab", SWIG_From_int((int)(wxNavigationKeyEvent::FromTab)));
49745 }
49746 {
49747 PyDict_SetItemString(d,"IDLE_PROCESS_ALL", SWIG_From_int((int)(wxIDLE_PROCESS_ALL)));
49748 }
49749 {
49750 PyDict_SetItemString(d,"IDLE_PROCESS_SPECIFIED", SWIG_From_int((int)(wxIDLE_PROCESS_SPECIFIED)));
49751 }
49752 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
49753 {
49754 PyDict_SetItemString(d,"PYAPP_ASSERT_SUPPRESS", SWIG_From_int((int)(wxPYAPP_ASSERT_SUPPRESS)));
49755 }
49756 {
49757 PyDict_SetItemString(d,"PYAPP_ASSERT_EXCEPTION", SWIG_From_int((int)(wxPYAPP_ASSERT_EXCEPTION)));
49758 }
49759 {
49760 PyDict_SetItemString(d,"PYAPP_ASSERT_DIALOG", SWIG_From_int((int)(wxPYAPP_ASSERT_DIALOG)));
49761 }
49762 {
49763 PyDict_SetItemString(d,"PYAPP_ASSERT_LOG", SWIG_From_int((int)(wxPYAPP_ASSERT_LOG)));
49764 }
49765 {
49766 PyDict_SetItemString(d,"PRINT_WINDOWS", SWIG_From_int((int)(wxPRINT_WINDOWS)));
49767 }
49768 {
49769 PyDict_SetItemString(d,"PRINT_POSTSCRIPT", SWIG_From_int((int)(wxPRINT_POSTSCRIPT)));
49770 }
49771 SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
49772 SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
49773 {
49774 PyDict_SetItemString(d,"WINDOW_VARIANT_NORMAL", SWIG_From_int((int)(wxWINDOW_VARIANT_NORMAL)));
49775 }
49776 {
49777 PyDict_SetItemString(d,"WINDOW_VARIANT_SMALL", SWIG_From_int((int)(wxWINDOW_VARIANT_SMALL)));
49778 }
49779 {
49780 PyDict_SetItemString(d,"WINDOW_VARIANT_MINI", SWIG_From_int((int)(wxWINDOW_VARIANT_MINI)));
49781 }
49782 {
49783 PyDict_SetItemString(d,"WINDOW_VARIANT_LARGE", SWIG_From_int((int)(wxWINDOW_VARIANT_LARGE)));
49784 }
49785 {
49786 PyDict_SetItemString(d,"WINDOW_VARIANT_MAX", SWIG_From_int((int)(wxWINDOW_VARIANT_MAX)));
49787 }
49788 SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
49789 SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
49790 {
49791 PyDict_SetItemString(d,"FLEX_GROWMODE_NONE", SWIG_From_int((int)(wxFLEX_GROWMODE_NONE)));
49792 }
49793 {
49794 PyDict_SetItemString(d,"FLEX_GROWMODE_SPECIFIED", SWIG_From_int((int)(wxFLEX_GROWMODE_SPECIFIED)));
49795 }
49796 {
49797 PyDict_SetItemString(d,"FLEX_GROWMODE_ALL", SWIG_From_int((int)(wxFLEX_GROWMODE_ALL)));
49798 }
49799 SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
49800 {
49801 PyDict_SetItemString(d,"Left", SWIG_From_int((int)(wxLeft)));
49802 }
49803 {
49804 PyDict_SetItemString(d,"Top", SWIG_From_int((int)(wxTop)));
49805 }
49806 {
49807 PyDict_SetItemString(d,"Right", SWIG_From_int((int)(wxRight)));
49808 }
49809 {
49810 PyDict_SetItemString(d,"Bottom", SWIG_From_int((int)(wxBottom)));
49811 }
49812 {
49813 PyDict_SetItemString(d,"Width", SWIG_From_int((int)(wxWidth)));
49814 }
49815 {
49816 PyDict_SetItemString(d,"Height", SWIG_From_int((int)(wxHeight)));
49817 }
49818 {
49819 PyDict_SetItemString(d,"Centre", SWIG_From_int((int)(wxCentre)));
49820 }
49821 {
49822 PyDict_SetItemString(d,"Center", SWIG_From_int((int)(wxCenter)));
49823 }
49824 {
49825 PyDict_SetItemString(d,"CentreX", SWIG_From_int((int)(wxCentreX)));
49826 }
49827 {
49828 PyDict_SetItemString(d,"CentreY", SWIG_From_int((int)(wxCentreY)));
49829 }
49830 {
49831 PyDict_SetItemString(d,"Unconstrained", SWIG_From_int((int)(wxUnconstrained)));
49832 }
49833 {
49834 PyDict_SetItemString(d,"AsIs", SWIG_From_int((int)(wxAsIs)));
49835 }
49836 {
49837 PyDict_SetItemString(d,"PercentOf", SWIG_From_int((int)(wxPercentOf)));
49838 }
49839 {
49840 PyDict_SetItemString(d,"Above", SWIG_From_int((int)(wxAbove)));
49841 }
49842 {
49843 PyDict_SetItemString(d,"Below", SWIG_From_int((int)(wxBelow)));
49844 }
49845 {
49846 PyDict_SetItemString(d,"LeftOf", SWIG_From_int((int)(wxLeftOf)));
49847 }
49848 {
49849 PyDict_SetItemString(d,"RightOf", SWIG_From_int((int)(wxRightOf)));
49850 }
49851 {
49852 PyDict_SetItemString(d,"SameAs", SWIG_From_int((int)(wxSameAs)));
49853 }
49854 {
49855 PyDict_SetItemString(d,"Absolute", SWIG_From_int((int)(wxAbsolute)));
49856 }
49857
49858 // Initialize threading, some globals and such
49859 __wxPyPreStart(d);
49860
49861
49862 // Although these are defined in __version__ they need to be here too so
49863 // that an assert can be done to ensure that the wxPython and the wxWindows
49864 // versions match.
49865 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
49866 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
49867 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
49868
49869 }
49870
wxWidgets (Impactor)